ftp.muug.mb.ca/2014.06.ftp.muug.mb.ca.tar/ftp.muug.mb.ca/pub/openh323.tar.gz/openh323.tar/openh323/src/h248.asn

Text File | 2002-11-27 | 20KB | 971 lines

-- H.248 (Megaco) ASN from Temporary Document 31r1


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 2.
    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)

    },
    ...,
    streamID        StreamID OPTIONAL
}

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,
    ...,
    auditPropertyToken SEQUENCE OF IndAuditParameter OPTIONAL
}

IndAuditParameter ::= CHOICE
{
    indaudmediaDescriptor         IndAudMediaDescriptor,
    indaudeventsDescriptor          IndAudEventsDescriptor,
    indaudeventBufferDescriptor    IndAudEventBufferDescriptor,
    indaudsignalsDescriptor         IndAudSignalsDescriptor,
    indauddigitMapDescriptor    IndAudDigitMapDescriptor,
    indaudstatisticsDescriptor    IndAudStatisticsDescriptor,
    indaudpackagesDescriptor    IndAudPackagesDescriptor,
...
}

IndAudMediaDescriptor ::= SEQUENCE
{

    termStateDescr    IndAudTerminationStateDescriptor OPTIONAL,
    streams    CHOICE
    {
        oneStream    IndAudStreamParms,
        multiStream    SEQUENCE OF IndAudStreamDescriptor
    } OPTIONAL,
    ...
}

IndAudStreamDescriptor ::= SEQUENCE
{
    streamID        StreamID,
    streamParms    IndAudStreamParms
}

IndAudStreamParms ::= SEQUENCE
{
    localControlDescriptor     IndAudLocalControlDescriptor OPTIONAL,
    localDescriptor            IndAudLocalRemoteDescriptor OPTIONAL,
    remoteDescriptor           IndAudLocalRemoteDescriptor OPTIONAL,
    ...
}

IndAudLocalControlDescriptor ::= SEQUENCE
{
    streamMode        NULL OPTIONAL,
    reserveValue    NULL OPTIONAL,
    reserveGroup    NULL OPTIONAL,
    propertyParms     SEQUENCE OF IndAudPropertyParm OPTIONAL,
    ...
}

IndAudPropertyParm ::= SEQUENCE
{
    name         PkgdName,
    ...
}

IndAudLocalRemoteDescriptor ::= SEQUENCE
{
    propGroupID    INTEGER(0..65535) OPTIONAL,
    propGrps    IndAudPropertyGroup,
    ...
}

IndAudPropertyGroup ::= SEQUENCE OF IndAudPropertyParm

IndAudTerminationStateDescriptor ::= SEQUENCE
{
    propertyParms           SEQUENCE OF IndAudPropertyParm,
    eventBufferControl    NULL OPTIONAL,
    serviceState            NULL OPTIONAL,
    ...
}

IndAudEventsDescriptor ::= SEQUENCE
{
    requestID    RequestID OPTIONAL,
    pkgdName        PkgdName,
    streamID    StreamID OPTIONAL,
    ...
}

IndAudEventBufferDescriptor ::= SEQUENCE
{
    eventName    PkgdName,
    streamID    StreamID OPTIONAL,
    ...
}

IndAudSignalsDescriptor ::=CHOICE
{
    signal        IndAudSignal,
    seqSigList    IndAudSeqSigList,
    ...
}

IndAudSeqSigList ::= SEQUENCE
{
    id        INTEGER(0..65535),
    signalList    IndAudSignal OPTIONAL
}

IndAudSignal ::= SEQUENCE
{
    signalName     PkgdName,
    streamID    StreamID OPTIONAL,
    ...
}



IndAudDigitMapDescriptor ::= SEQUENCE
{
    digitMapName      DigitMapName    OPTIONAL
}

IndAudStatisticsDescriptor ::= SEQUENCE
{
    statName     PkgdName
}

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

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),
    ...,
    nx64k(4)
}

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
    ...,
    durationTimer     INTEGER(0..99) OPTIONAL
}

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,
    ...,
    serviceChangeInfo    AuditDescriptor 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