--
-- Abstract Syntax Notion (ASN.1) file for H.248 Version 1
--
-- File provided by Packetizer, Inc. <https://www.packetizer.com>
-- Last Updated: May 27, 2003
--

MEDIA-GATEWAY-CONTROL DEFINITIONS AUTOMATIC TAGS ::= BEGIN 

MegacoMessage ::= SEQUENCE
{
    authHeader      AuthenticationHeader OPTIONAL,
    mess            Message
}

AuthenticationHeader ::= SEQUENCE
{
    secParmIndex    SecurityParmIndex,
    seqNum            SequenceNum,
    ad              AuthData
}

SecurityParmIndex ::= OCTET STRING(SIZE(4))

SequenceNum       ::= OCTET STRING(SIZE(4))

AuthData          ::= OCTET STRING (SIZE (12..32))

Message ::= SEQUENCE
{
    version         INTEGER(0..99),
-- The version of the protocol defined here is equal to 1.
    mId             MId,    -- Name/address of message originator
    messageBody     CHOICE
    {
        messageError    ErrorDescriptor,
        transactions    SEQUENCE OF Transaction
    },
    ...
}

MId ::= CHOICE
{
    ip4Address              IP4Address,
    ip6Address              IP6Address,
    domainName              DomainName,
    deviceName              PathName,
    mtpAddress              OCTET STRING(SIZE(2..4)),
 -- Addressing structure of mtpAddress:
 --      25-15                0
 --        |  PC        | NI |
 --        24 - 14 bits    2 bits
 -- Note: 14 bits are defined for international use.
 -- Two national options exist where the point code is 16 or 24  
       -- bits.
 -- To octet align the mtpAddress the MSBs shall be encoded as 0s.
      ...
}

DomainName ::= SEQUENCE
{
    name        IA5String,
-- The name starts with an alphanumeric digit followed by a
-- sequence of alphanumeric digits, hyphens and dots.  No two
-- dots shall occur consecutively.
    portNumber  INTEGER(0..65535) OPTIONAL
}

IP4Address ::= SEQUENCE
{
    address OCTET STRING (SIZE(4)),
    portNumber  INTEGER(0..65535) OPTIONAL
}

IP6Address ::= SEQUENCE
{
    address OCTET STRING (SIZE(16)),
    portNumber  INTEGER(0..65535) OPTIONAL
}

PathName ::= IA5String(SIZE (1..64))
-- See section A.3

Transaction ::= CHOICE
{
    transactionRequest      TransactionRequest,
    transactionPending  TransactionPending,
    transactionReply    TransactionReply,
    transactionResponseAck  TransactionResponseAck,
          -- use of response acks is dependent on underlying transport
    ...
}

TransactionId ::= INTEGER(0..4294967295)  -- 32 bit unsigned integer

TransactionRequest ::= SEQUENCE
{
    transactionId       TransactionId,
    actions             SEQUENCE OF ActionRequest,
    ...
}

TransactionPending ::= SEQUENCE
{
    transactionId       TransactionId,
    ...
}

TransactionReply ::= SEQUENCE
{
    transactionId       TransactionId,
    immAckRequired      NULL OPTIONAL,
    transactionResult   CHOICE
    {
         transactionError   ErrorDescriptor,
         actionReplies  SEQUENCE OF ActionReply
    },
    ...
}

TransactionResponseAck ::= SEQUENCE OF TransactionAck
TransactionAck ::= SEQUENCE
{
    firstAck    TransactionId,
    lastAck TransactionId OPTIONAL
}

ErrorDescriptor ::= SEQUENCE
{
    errorCode   ErrorCode,
    errorText   ErrorText OPTIONAL
}

ErrorCode ::= INTEGER(0..65535)
-- See section 13 for IANA considerations with respect to error codes

ErrorText ::= IA5String

ContextID ::= INTEGER(0..4294967295)

-- Context NULL Value: 0
-- Context CHOOSE Value: 4294967294 (0xFFFFFFFE) 
-- Context ALL Value: 4294967295 (0xFFFFFFFF)


ActionRequest ::= SEQUENCE
{
    contextId           ContextID,
    contextRequest      ContextRequest OPTIONAL,
    contextAttrAuditReq ContextAttrAuditRequest OPTIONAL,
    commandRequests     SEQUENCE OF CommandRequest
}

ActionReply ::= SEQUENCE
{
    contextId       ContextID,
    errorDescriptor ErrorDescriptor OPTIONAL,
    contextReply    ContextRequest OPTIONAL,
    commandReply    SEQUENCE OF CommandReply
}

ContextRequest ::= SEQUENCE
{
    priority        INTEGER(0..15) OPTIONAL,
    emergency       BOOLEAN OPTIONAL,
    topologyReq     SEQUENCE OF TopologyRequest OPTIONAL,
    ...
}

ContextAttrAuditRequest ::= SEQUENCE
{
    topology    NULL OPTIONAL,
    emergency   NULL OPTIONAL,
    priority    NULL OPTIONAL,
    ...
}

CommandRequest ::= SEQUENCE
{
    command     Command,
    optional        NULL OPTIONAL,
    wildcardReturn  NULL OPTIONAL,
    ...
}

Command ::= CHOICE
{
    addReq          AmmRequest,
    moveReq             AmmRequest,
    modReq              AmmRequest,
    -- Add, Move, Modify requests have the same parameters
    subtractReq         SubtractRequest,
    auditCapRequest     AuditRequest,
    auditValueRequest   AuditRequest,
    notifyReq           NotifyRequest,
    serviceChangeReq    ServiceChangeRequest,
    ...
}

CommandReply ::= CHOICE
{
    addReply            AmmsReply,
    moveReply           AmmsReply,
    modReply            AmmsReply,
    subtractReply       AmmsReply,
    -- Add, Move, Modify, Subtract replies have the same parameters
    auditCapReply       AuditReply,
    auditValueReply     AuditReply,
    notifyReply         NotifyReply,
    serviceChangeReply  ServiceChangeReply,
    ...
}

TopologyRequest ::= SEQUENCE
{
    terminationFrom         TerminationID,
    terminationTo       TerminationID,
    topologyDirection   ENUMERATED
    {
        bothway(0),
        isolate(1),
        oneway(2)

    },
    ...
}

AmmRequest ::= SEQUENCE
{
    terminationID       TerminationIDList,
    descriptors         SEQUENCE OF AmmDescriptor,
    -- At most one descriptor of each type (see AmmDescriptor)
    -- allowed in the sequence.
    ...
}

AmmDescriptor ::= CHOICE
{
    mediaDescriptor         MediaDescriptor,
    modemDescriptor         ModemDescriptor,
    muxDescriptor           MuxDescriptor,
    eventsDescriptor            EventsDescriptor,
    eventBufferDescriptor       EventBufferDescriptor,
    signalsDescriptor           SignalsDescriptor,
    digitMapDescriptor      DigitMapDescriptor,
    auditDescriptor         AuditDescriptor,
    ...
}

AmmsReply ::= SEQUENCE
{
    terminationID       TerminationIDList,
    terminationAudit        TerminationAudit OPTIONAL,
    ...
}

SubtractRequest ::= SEQUENCE
{
    terminationID           TerminationIDList,
    auditDescriptor         AuditDescriptor OPTIONAL,
    ...
}

AuditRequest ::= SEQUENCE
{
    terminationID       TerminationID,
    auditDescriptor     AuditDescriptor,
    ...
}

AuditReply ::= CHOICE
{
    contextAuditResult  TerminationIDList,
    error               ErrorDescriptor,
    auditResult         AuditResult,
    ...
}

AuditResult ::= SEQUENCE
{
    terminationID       TerminationID,
    terminationAuditResult  TerminationAudit
}



TerminationAudit ::= SEQUENCE OF AuditReturnParameter

AuditReturnParameter ::= CHOICE
{
    errorDescriptor         ErrorDescriptor,
    mediaDescriptor             MediaDescriptor,
    modemDescriptor             ModemDescriptor,
    muxDescriptor           MuxDescriptor,
    eventsDescriptor            EventsDescriptor,
    eventBufferDescriptor       EventBufferDescriptor,
    signalsDescriptor           SignalsDescriptor,
    digitMapDescriptor          DigitMapDescriptor,
    observedEventsDescriptor    ObservedEventsDescriptor,
    statisticsDescriptor        StatisticsDescriptor,
    packagesDescriptor          PackagesDescriptor,
    emptyDescriptors              AuditDescriptor,
    ...
}

AuditDescriptor ::= SEQUENCE
{
    auditToken  BIT STRING
    {
        muxToken(0), modemToken(1), mediaToken(2),
        eventsToken(3), signalsToken(4),
        digitMapToken(5), statsToken(6),
        observedEventsToken(7),
        packagesToken(8), eventBufferToken(9)
    } OPTIONAL,
    ...
}

NotifyRequest ::= SEQUENCE
{
    terminationID               TerminationIDList,
    observedEventsDescriptor    ObservedEventsDescriptor,
    errorDescriptor         ErrorDescriptor OPTIONAL,
    ...
}

NotifyReply ::= SEQUENCE
{
    terminationID               TerminationIDList,
    errorDescriptor             ErrorDescriptor OPTIONAL,
    ...
}

ObservedEventsDescriptor ::= SEQUENCE
{
    requestId                   RequestID,
    observedEventLst            SEQUENCE OF ObservedEvent
}

ObservedEvent ::= SEQUENCE
{
    eventName               EventName,
    streamID                StreamID OPTIONAL,
    eventParList            SEQUENCE OF EventParameter,
    timeNotation            TimeNotation OPTIONAL,
    ...
}

EventName ::= PkgdName

EventParameter ::= SEQUENCE
{
    eventParameterName  Name,
    value                   Value,
-- For use of extraInfo see the comment related to PropertyParm
    extraInfo CHOICE
    {
        relation    Relation,
        range       BOOLEAN,
        sublist BOOLEAN
    } OPTIONAL,
    ...
}

ServiceChangeRequest ::= SEQUENCE
{
    terminationID           TerminationIDList,
    serviceChangeParms      ServiceChangeParm,
    ...
}

ServiceChangeReply ::= SEQUENCE
{
    terminationID               TerminationIDList,
    serviceChangeResult         ServiceChangeResult,
    ...
}

-- For ServiceChangeResult, no parameters are mandatory.  Hence the
-- distinction between ServiceChangeParm and ServiceChangeResParm.

ServiceChangeResult ::= CHOICE
{
    errorDescriptor             ErrorDescriptor,
    serviceChangeResParms       ServiceChangeResParm
}

WildcardField ::= OCTET STRING(SIZE(1))

TerminationID ::= SEQUENCE
{
    wildcard    SEQUENCE OF WildcardField, 
    id      OCTET STRING(SIZE(1..8)),
    ...
}
-- See Section A.1 for explanation of wildcarding mechanism.
-- Termination ID 0xFFFFFFFFFFFFFFFF indicates the ROOT Termination.

TerminationIDList ::= SEQUENCE OF TerminationID

MediaDescriptor ::= SEQUENCE
{
    
    termStateDescr  TerminationStateDescriptor OPTIONAL,
    streams     CHOICE
                {
                    oneStream   StreamParms,
                    multiStream SEQUENCE OF StreamDescriptor
                } OPTIONAL,
    ...
}

StreamDescriptor ::= SEQUENCE
{
    streamID                    StreamID,
    streamParms             StreamParms
}

StreamParms ::= SEQUENCE
{
    localControlDescriptor      LocalControlDescriptor OPTIONAL,
    localDescriptor             LocalRemoteDescriptor OPTIONAL,
    remoteDescriptor            LocalRemoteDescriptor OPTIONAL,
    ...
}

LocalControlDescriptor ::= SEQUENCE
{
    streamMode      StreamMode OPTIONAL,
    reserveValue    BOOLEAN OPTIONAL,
    reserveGroup    BOOLEAN OPTIONAL,
    propertyParms   SEQUENCE OF PropertyParm,
    ...
}

StreamMode ::= ENUMERATED 
{
    sendOnly(0),
    recvOnly(1),
    sendRecv(2),
    inactive(3),
    loopBack(4),
        ...
}

-- In PropertyParm, value is a SEQUENCE OF octet string.  When sent
-- by an MGC the interpretation is as follows:
-- empty sequence means CHOOSE
-- one element sequence specifies value
-- If the sublist field is not selected, a longer sequence means
-- "choose one of the values" (i.e. value1 OR value2 OR ...)
-- If the sublist field is selected,
-- a sequence with more than one element encodes the value of a
-- list-valued property (i.e. value1 AND value2 AND ...).
-- The relation field may only be selected if the value sequence
-- has length 1.  It indicates that the MG has to choose a value
-- for the property. E.g., x > 3 (using the greaterThan
-- value for relation) instructs the MG to choose any value larger
-- than 3 for property x.
-- The range field may only be selected if the value sequence
-- has length 2.  It indicates that the MG has to choose a value
-- in the range between the first octet in the value sequence and
-- the trailing octet in the value sequence, including the
-- boundary values.
-- When sent by the MG, only responses to an AuditCapability request
-- may contain multiple values, a range, or a relation field.

PropertyParm ::= SEQUENCE
{
    name        PkgdName,
    value   SEQUENCE OF OCTET STRING,
    extraInfo   CHOICE
    {
        relation    Relation,
        range       BOOLEAN,
        sublist BOOLEAN
    } OPTIONAL,
    ...
}

Name ::= OCTET STRING(SIZE(2))

PkgdName ::= OCTET STRING(SIZE(4))
-- represents Package Name (2 octets) plus Property, Event,
-- Signal Names or Statistics ID. (2 octets)
-- To wildcard a package use 0xFFFF for first two octets, choose
-- is not allowed. To reference native property tag specified in
-- Annex C, use 0x0000 as first two octets.
-- To wildcard a Property, Event, Signal, or Statistics ID, use 
-- 0xFFFF for last two octets, choose is not allowed.
-- Wildcarding of Package Name is permitted only if Property,
--Event, Signal, or Statistics ID is
-- also wildcarded.

Relation ::= ENUMERATED
{
    greaterThan(0),
    smallerThan(1),
    unequalTo(2),
    ...
}

LocalRemoteDescriptor ::= SEQUENCE
{
    propGrps    SEQUENCE OF PropertyGroup,
    ...
}

PropertyGroup ::= SEQUENCE OF PropertyParm

TerminationStateDescriptor ::= SEQUENCE 
{
    propertyParms       SEQUENCE OF PropertyParm,
    eventBufferControl    EventBufferControl OPTIONAL,
    serviceState        ServiceState OPTIONAL,
    ...
}

EventBufferControl ::= ENUMERATED
{
    off(0),
    lockStep(1),
    ...
}

ServiceState ::= ENUMERATED
{
    test(0),
    outOfSvc(1),
    inSvc(2),
      ...
}

MuxDescriptor   ::= SEQUENCE
{
    muxType             MuxType,
    termList        SEQUENCE OF TerminationID,
    nonStandardData NonStandardData OPTIONAL,
    ...
}

MuxType ::= ENUMERATED
{
    h221(0),
    h223(1),
    h226(2),
    v76(3),
    ...
}

StreamID ::= INTEGER(0..65535)  -- 16 bit unsigned integer

EventsDescriptor ::= SEQUENCE
{
    requestID       RequestID OPTIONAL,
                -- RequestID must be present if eventList
-- is non empty,
    eventList       SEQUENCE OF RequestedEvent,
    ...
}

RequestedEvent ::= SEQUENCE
{
    pkgdName        PkgdName,
    streamID        StreamID OPTIONAL,
    eventAction     RequestedActions OPTIONAL,
    evParList       SEQUENCE OF EventParameter,
    ...
}

RequestedActions ::= SEQUENCE
{
    keepActive          BOOLEAN OPTIONAL,
    eventDM         EventDM OPTIONAL,
    secondEvent             SecondEventsDescriptor OPTIONAL,
    signalsDescriptor       SignalsDescriptor OPTIONAL,
    ...
}


EventDM ::= CHOICE
{   digitMapName    DigitMapName,
    digitMapValue   DigitMapValue
}

SecondEventsDescriptor ::= SEQUENCE
{
    requestID           RequestID OPTIONAL,
    eventList           SEQUENCE OF SecondRequestedEvent,
    ...
}

SecondRequestedEvent ::= SEQUENCE
{
    pkgdName            PkgdName,
    streamID            StreamID OPTIONAL,
    eventAction         SecondRequestedActions OPTIONAL,
    evParList           SEQUENCE OF EventParameter,
    ...
}

SecondRequestedActions ::= SEQUENCE
{
    keepActive          BOOLEAN OPTIONAL,
    eventDM         EventDM OPTIONAL,
    signalsDescriptor   SignalsDescriptor OPTIONAL,
    ...
}

EventBufferDescriptor ::= SEQUENCE OF EventSpec

EventSpec ::= SEQUENCE
{
    eventName       EventName,
    streamID        StreamID OPTIONAL,
    eventParList    SEQUENCE OF EventParameter,
    ...
}


SignalsDescriptor ::= SEQUENCE OF SignalRequest

SignalRequest ::=CHOICE
{
    signal      Signal,
    seqSigList      SeqSigList,
    ...
}

SeqSigList ::= SEQUENCE
{
    id          INTEGER(0..65535),
    signalList      SEQUENCE OF Signal
}

Signal ::= SEQUENCE
{
    signalName      SignalName,
    streamID        StreamID OPTIONAL,
    sigType     SignalType OPTIONAL,
    duration        INTEGER (0..65535) OPTIONAL,
    notifyCompletion    NotifyCompletion OPTIONAL,
    keepActive      BOOLEAN OPTIONAL,
    sigParList      SEQUENCE OF SigParameter,
    ...
}

SignalType ::= ENUMERATED
{
    brief(0),
    onOff(1),
    timeOut(2),
    ...
}

SignalName ::= PkgdName

NotifyCompletion ::= BIT STRING
{
    onTimeOut(0), onInterruptByEvent(1),
    onInterruptByNewSignalDescr(2), otherReason(3)
}

SigParameter ::= SEQUENCE
{
    sigParameterName        Name,
    value                   Value,
-- For use of extraInfo see the comment related to PropertyParm
    extraInfo CHOICE
    {
        relation    Relation,
        range       BOOLEAN,
        sublist BOOLEAN
    } OPTIONAL,
    ...
}

-- For an AuditCapReply with all events, the RequestID SHALL be ALL.
-- ALL is represented by 0xffffffff.

RequestID ::= INTEGER(0..4294967295)   -- 32 bit unsigned integer

ModemDescriptor ::= SEQUENCE
{
    mtl     SEQUENCE OF ModemType, 
    mpl     SEQUENCE OF PropertyParm,
    nonStandardData NonStandardData OPTIONAL
}

ModemType ::= ENUMERATED
{
    v18(0),
    v22(1),
    v22bis(2),
    v32(3),
    v32bis(4),
    v34(5),
    v90(6),
    v91(7),
    synchISDN(8),
    ...
}

DigitMapDescriptor ::= SEQUENCE
{
    digitMapName    DigitMapName    OPTIONAL,
    digitMapValue   DigitMapValue   OPTIONAL
}

DigitMapName ::= Name

DigitMapValue ::= SEQUENCE
{
    startTimer      INTEGER(0..99) OPTIONAL,
    shortTimer      INTEGER(0..99) OPTIONAL,
    longTimer       INTEGER(0..99) OPTIONAL,
    digitMapBody    IA5String,
-- Units are seconds for start, short and long timers, and
-- hundreds of milliseconds for duration timer. Thus start,
-- short, and long range from 1 to 99 seconds and duration
-- from 100 ms to 9.9 s
    -- See Section A.3 for explanation of digit map syntax
    ...
}

ServiceChangeParm ::= SEQUENCE
{
    serviceChangeMethod     ServiceChangeMethod,
    serviceChangeAddress    ServiceChangeAddress OPTIONAL,
    serviceChangeVersion    INTEGER(0..99) OPTIONAL,
    serviceChangeProfile    ServiceChangeProfile OPTIONAL,
    serviceChangeReason     Value, 
-- A serviceChangeReason consists of a numeric reason code
-- and an optional text description.
-- The serviceChangeReason SHALL be a string consisting of 
-- a decimal reason code, optionally followed by a single 
-- space character and a textual description string.
-- This string is first BER-encoded as an IA5String.
-- The result of this BER-encoding is then encoded as
-- an ASN.1 OCTET STRING type, "double wrapping" the 
--value
-- as was done for package elements.
    serviceChangeDelay      INTEGER(0..4294967295) OPTIONAL,
                                -- 32 bit unsigned integer
    serviceChangeMgcId      MId OPTIONAL,
    timeStamp           TimeNotation OPTIONAL,
    nonStandardData     NonStandardData OPTIONAL,
    ...
}

ServiceChangeAddress ::= CHOICE
{
    portNumber          INTEGER(0..65535), -- TCP/UDP port number
    ip4Address          IP4Address,
    ip6Address          IP6Address,
    domainName          DomainName,
    deviceName          PathName,
    mtpAddress          OCTET STRING(SIZE(2..4)),
    ...
}

ServiceChangeResParm ::= SEQUENCE
{
    serviceChangeMgcId  MId OPTIONAL,
    serviceChangeAddress    ServiceChangeAddress OPTIONAL,
    serviceChangeVersion    INTEGER(0..99) OPTIONAL,
    serviceChangeProfile    ServiceChangeProfile OPTIONAL,
    timestamp           TimeNotation OPTIONAL,
    ...
}

ServiceChangeMethod ::= ENUMERATED
{
    failover(0),
    forced(1),
    graceful(2),
    restart(3),
    disconnected(4),
    handOff(5),
    ...
}

ServiceChangeProfile ::= SEQUENCE
{
    profileName     IA5String(SIZE (1..67))
    
-- 64 characters for name, 1 for "/", 2 for version to match ABNF
}

PackagesDescriptor ::= SEQUENCE OF PackagesItem

PackagesItem ::= SEQUENCE
{
    packageName     Name,
    packageVersion  INTEGER(0..99),
    ...
}

StatisticsDescriptor ::= SEQUENCE OF StatisticsParameter

StatisticsParameter ::= SEQUENCE
{
    statName        PkgdName,
    statValue       Value OPTIONAL
}

NonStandardData ::= SEQUENCE
{
    nonStandardIdentifier   NonStandardIdentifier,
    data                OCTET STRING
}

NonStandardIdentifier       ::= CHOICE
{
    object          OBJECT IDENTIFIER,
    h221NonStandard     H221NonStandard,
    experimental        IA5String(SIZE(8)), 
 -- first two characters should be "X-" or "X+"
    ...
}

H221NonStandard ::= SEQUENCE
{
    t35CountryCode1     INTEGER(0..255),
    t35CountryCode2     INTEGER(0..255),     -- country, as per T.35
    t35Extension        INTEGER(0..255),     -- assigned nationally
    manufacturerCode        INTEGER(0..65535), -- assigned nationally
    ...
}

TimeNotation ::= SEQUENCE
{
    date        IA5String(SIZE(8)),  -- yyyymmdd format
    time        IA5String(SIZE(8))  -- hhmmssss format
    -- per ISO 8601:1988
}

Value ::= SEQUENCE OF OCTET STRING


END