H.248 ASN.1 HTML

Version 2

--
-- Abstract Syntax Notion (ASN.1) file for H.248 Version 2
--
-- File provided by Packetizer, Inc. <hhttps://www.packetizer.com>
-- Last Updated: May 27, 2003
--
-- NOTE: This file was intended to be used only for hyperlinking
-- betweeen fields and structures.  Developers should not use this file
-- in implementations.  Rather, use the file found here:
--     https://www.packetizer.com/voip/h248/h248v2.asn
--
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

-- Pretty-printed by Asnp, the pretty-printer of France Telecom R&D