-- Module H323-MESSAGES (H.225.0v03:09/1999)
-- See also ITU-T H.225.0 (09/1999)
-- See also the index of all ASN.1 assignments needed in this document

H323-MESSAGES DEFINITIONS AUTOMATIC TAGS ::=
BEGIN

IMPORTS
  SIGNED{}, ENCRYPTED{}, HASHED{}, ChallengeString, TimeStamp, RandomVal,
    Password, EncodedPwdCertToken, ClearToken, CryptoToken,
    AuthenticationMechanism
    FROM H235-SECURITY-MESSAGES
  DataProtocolCapability, T38FaxProfile
    FROM MULTIMEDIA-SYSTEM-CONTROL;

H323-UserInformation ::= SEQUENCE -- root for all Q.931 related ASN.1
                          {
  h323-uu-pdu  H323-UU-PDU,
  user-data
    SEQUENCE {protocol-discriminator  INTEGER(0..255),
              user-information        OCTET STRING(SIZE (1..131)),
              ...} OPTIONAL,
  ...
}

H323-UU-PDU ::= SEQUENCE {
  h323-message-body
    CHOICE {setup            Setup-UUIE,
            callProceeding   CallProceeding-UUIE,
            connect          Connect-UUIE,
            alerting         Alerting-UUIE,
            information      Information-UUIE,
            releaseComplete  ReleaseComplete-UUIE,
            facility         Facility-UUIE,
            ...,
            progress         Progress-UUIE,
            empty            NULL},
  -- used when a FACILITY message is sent,
  -- but the Facility-UUIE is not to be invoked
  -- (possible when transporting supplementary
  -- services messages)
  nonStandardData               NonStandardParameter OPTIONAL,
  ...,
  h4501SupplementaryService     SEQUENCE OF OCTET STRING OPTIONAL,
  -- each sequence of octet string is defined as one
  -- H4501SupplementaryService APDU as defined in
  -- Table 3/H.450.1
  h245Tunneling                 BOOLEAN,
  -- if TRUE, tunneling of H.245 messages is enabled
  h245Control                   SEQUENCE OF OCTET STRING OPTIONAL,
  -- each octet string may contain exactly
  -- one H.245 PDU
  nonStandardControl            SEQUENCE OF NonStandardParameter OPTIONAL
}

Alerting-UUIE ::= SEQUENCE {
  protocolIdentifier        ProtocolIdentifier,
  destinationInfo           EndpointType,
  h245Address               TransportAddress OPTIONAL,
  ...,
  callIdentifier            CallIdentifier,
  h245SecurityMode          H245Security OPTIONAL,
  tokens                    SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens              SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart                 SEQUENCE OF OCTET STRING OPTIONAL,
  multipleCalls             BOOLEAN,
  maintainConnection        BOOLEAN,
  alertingAddress           SEQUENCE OF AliasAddress OPTIONAL,
  presentationIndicator     PresentationIndicator,
  screeningIndicator        ScreeningIndicator
}

CallProceeding-UUIE ::= SEQUENCE {
  protocolIdentifier     ProtocolIdentifier,
  destinationInfo        EndpointType,
  h245Address            TransportAddress OPTIONAL,
  ...,
  callIdentifier         CallIdentifier,
  h245SecurityMode       H245Security OPTIONAL,
  tokens                 SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens           SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart              SEQUENCE OF OCTET STRING OPTIONAL,
  multipleCalls          BOOLEAN,
  maintainConnection     BOOLEAN
}

Connect-UUIE ::= SEQUENCE {
  protocolIdentifier        ProtocolIdentifier,
  h245Address               TransportAddress OPTIONAL,
  destinationInfo           EndpointType,
  conferenceID              ConferenceIdentifier,
  ...,
  callIdentifier            CallIdentifier,
  h245SecurityMode          H245Security OPTIONAL,
  tokens                    SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens              SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart                 SEQUENCE OF OCTET STRING OPTIONAL,
  multipleCalls             BOOLEAN,
  maintainConnection        BOOLEAN,
  language                  SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL,
  -- RFC1766 language tag
  connectedAddress          SEQUENCE OF AliasAddress OPTIONAL,
  presentationIndicator     PresentationIndicator,
  screeningIndicator        ScreeningIndicator
}

Information-UUIE ::= SEQUENCE {
  protocolIdentifier  ProtocolIdentifier,
  ...,
  callIdentifier      CallIdentifier,
  tokens              SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens        SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart           SEQUENCE OF OCTET STRING OPTIONAL
}

ReleaseComplete-UUIE ::= SEQUENCE {
  protocolIdentifier        ProtocolIdentifier,
  reason                    ReleaseCompleteReason OPTIONAL,
  ...,
  callIdentifier            CallIdentifier,
  tokens                    SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens              SEQUENCE OF CryptoH323Token OPTIONAL,
  busyAddress               SEQUENCE OF AliasAddress OPTIONAL,
  presentationIndicator     PresentationIndicator,
  screeningIndicator        ScreeningIndicator
}

ReleaseCompleteReason ::= CHOICE {
  noBandwidth                  NULL, -- bandwidth taken away or ARQ denied
  gatekeeperResources          NULL, -- exhausted
  unreachableDestination       NULL, -- no transport path to the destination
  destinationRejection         NULL, -- rejected at destination
  invalidRevision              NULL,
  noPermission                 NULL, -- called party's gatekeeper rejects
  unreachableGatekeeper        NULL, -- terminal cannot reach gatekeeper for ARQ
  gatewayResources             NULL,
  badFormatAddress             NULL,
  adaptiveBusy                 NULL, -- call is dropping due to LAN crowding
  inConf                       NULL, -- no address in AlternativeAddress
  undefinedReason              NULL,
  ...,
  facilityCallDeflection       NULL, -- call was deflected using a Facility message
  securityDenied               NULL, -- incompatible security settings
  calledPartyNotRegistered     NULL, -- used by gatekeeper when endpoint has
  
  -- preGrantedARQ to bypass ARQ/ACF
  callerNotRegistered          NULL, -- used by gatekeeper when endpoint has
  
  -- preGrantedARQ to bypass ARQ/ACF
  newConnectionNeeded          NULL, -- indicates that the Setup was not accepted on this
  
  -- connection, but that the Setup may be accepted on
  -- a new connection
  nonStandardReason            NonStandardParameter,
  replaceWithConferenceInvite  ConferenceIdentifier
} -- call dropped due to subsequent

-- invitation to a conference
-- (see 8.4.3.8/H.323)
Setup-UUIE ::= SEQUENCE {
  protocolIdentifier          ProtocolIdentifier,
  h245Address                 TransportAddress OPTIONAL,
  sourceAddress               SEQUENCE OF AliasAddress OPTIONAL,
  sourceInfo                  EndpointType,
  destinationAddress          SEQUENCE OF AliasAddress OPTIONAL,
  destCallSignalAddress       TransportAddress OPTIONAL,
  destExtraCallInfo           SEQUENCE OF AliasAddress OPTIONAL, -- Note 1
  destExtraCRV                SEQUENCE OF CallReferenceValue OPTIONAL, -- Note 1
  activeMC                    BOOLEAN,
  conferenceID                ConferenceIdentifier,
  conferenceGoal
    CHOICE {create                               NULL,
            join                                 NULL,
            invite                               NULL,
            ...,
            capability-negotiation               NULL,
            callIndependentSupplementaryService  NULL},
  callServices                QseriesOptions OPTIONAL,
  callType                    CallType,
  ...,
  sourceCallSignalAddress     TransportAddress OPTIONAL,
  remoteExtensionAddress      AliasAddress OPTIONAL,
  callIdentifier              CallIdentifier,
  h245SecurityCapability      SEQUENCE OF H245Security OPTIONAL,
  tokens                      SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart                   SEQUENCE OF OCTET STRING OPTIONAL,
  mediaWaitForConnect         BOOLEAN,
  canOverlapSend              BOOLEAN,
  endpointIdentifier          EndpointIdentifier OPTIONAL,
  multipleCalls               BOOLEAN,
  maintainConnection          BOOLEAN,
  connectionParameters
    SEQUENCE-- additional gateway parameters-- {connectionType
                                                  ScnConnectionType,
                                                numberOfScnConnections
                                                  INTEGER(0..65535),
                                                connectionAggregation
                                                  ScnConnectionAggregation,
                                                ...} OPTIONAL,
  language                    SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL,
  -- RFC1766 language tag
  presentationIndicator       PresentationIndicator,
  screeningIndicator          ScreeningIndicator
}

ScnConnectionType ::= CHOICE {
  unknown     NULL, -- should be seleceted when connection type is unknown
  bChannel    NULL, -- each individual connection on the SCN is 64kbps.
  
  -- Note that where SCN delivers 56kbps usable data, the
  -- actual bandwidth allocated on SCN is still 64kbps.
  hybrid2x64  NULL, -- each connection is a 128kbps hybrid call
  hybrid384   NULL, -- each connection is an H0 (384kbps) hybrid call
  hybrid1536  NULL, -- each connection is an H11 (1536kbps) hybrid call
  hybrid1920  NULL, -- each connection is an H12 (1920kbps) hybrid call
  multirate   NULL, -- bandwidth supplied by SCN using multirate.
  
  -- In this case, the information transfer rate octet in the
  -- bearer capability shall be set to multirate and the rate
  -- multiplier octet shall denote the number of B channels.
  ...
}

ScnConnectionAggregation ::= CHOICE {
  auto          NULL, -- aggregation mechanism is unknown
  none          NULL, -- call produced using a single SCN connection
  h221          NULL, -- use H.221 framing to aggregate the connections
  bonded-mode1  NULL, -- use ISO/IEC 13871 bonding mode 1.
  
  -- Use bonded-mode1 to signal a bonded call if the precise
  -- bonding mode to be used is unknown.
  bonded-mode2  NULL, -- use ISO/IEC 13871 bonding mode 2
  bonded-mode3  NULL, -- use ISO/IEC 13871 bonding mode 3
  ...
}

PresentationIndicator ::= CHOICE {
  presentationAllowed     NULL,
  presentationRestricted  NULL,
  addressNotAvailable     NULL,
  ...
}

ScreeningIndicator ::= ENUMERATED {
  userProvidedNotScreened(0),
  -- number was provided by a remote user
  -- and has not been screened by a gatekeeper
  userProvidedVerifiedAndPassed(1),
  -- number was provided by a user
  -- equipment (or by a remote network), and has
  -- been screened by a gatekeeper
  userProvidedVerifiedAndFailed(2),
  -- not used, value reserved
  networkProvided(3),
  -- number was provided by a gatekeeper
  ...
  }

Facility-UUIE ::= SEQUENCE {
  protocolIdentifier         ProtocolIdentifier,
  alternativeAddress         TransportAddress OPTIONAL,
  alternativeAliasAddress    SEQUENCE OF AliasAddress OPTIONAL,
  conferenceID               ConferenceIdentifier OPTIONAL,
  reason                     FacilityReason,
  ...,
  callIdentifier             CallIdentifier,
  destExtraCallInfo          SEQUENCE OF AliasAddress OPTIONAL,
  remoteExtensionAddress     AliasAddress OPTIONAL,
  tokens                     SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens               SEQUENCE OF CryptoH323Token OPTIONAL,
  conferences                SEQUENCE OF ConferenceList OPTIONAL,
  h245Address                TransportAddress OPTIONAL,
  fastStart                  SEQUENCE OF OCTET STRING OPTIONAL,
  multipleCalls              BOOLEAN,
  maintainConnection         BOOLEAN
}

ConferenceList ::= SEQUENCE {
  conferenceID     ConferenceIdentifier OPTIONAL,
  conferenceAlias  AliasAddress OPTIONAL,
  nonStandardData  NonStandardParameter OPTIONAL,
  ...
}

FacilityReason ::= CHOICE {
  routeCallToGatekeeper  NULL, -- call must use gatekeeper model
  
  -- gatekeeper is alternativeAddress
  callForwarded          NULL,
  routeCallToMC          NULL,
  undefinedReason        NULL,
  ...,
  conferenceListChoice   NULL,
  startH245              NULL, -- recipient should connect to h245Address
  noH245                 NULL
} -- endpoint does not support H.245

Progress-UUIE ::= SEQUENCE {
  protocolIdentifier     ProtocolIdentifier,
  destinationInfo        EndpointType,
  h245Address            TransportAddress OPTIONAL,
  callIdentifier         CallIdentifier,
  h245SecurityMode       H245Security OPTIONAL,
  tokens                 SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens           SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart              SEQUENCE OF OCTET STRING OPTIONAL,
  ...,
  multipleCalls          BOOLEAN,
  maintainConnection     BOOLEAN
}

TransportAddress ::= CHOICE {
  ipAddress
    SEQUENCE {ip    OCTET STRING(SIZE (4)),
              port  INTEGER(0..65535)},
  ipSourceRoute
    SEQUENCE {ip       OCTET STRING(SIZE (4)),
              port     INTEGER(0..65535),
              route    SEQUENCE OF OCTET STRING(SIZE (4)),
              routing  CHOICE {strict  NULL,
                               loose   NULL,
                               ...},
              ...},
  ipxAddress
    SEQUENCE {node    OCTET STRING(SIZE (6)),
              netnum  OCTET STRING(SIZE (4)),
              port    OCTET STRING(SIZE (2))},
  ip6Address
    SEQUENCE {ip    OCTET STRING(SIZE (16)),
              port  INTEGER(0..65535),
              ...},
  netBios             OCTET STRING(SIZE (16)),
  nsap                OCTET STRING(SIZE (1..20)),
  nonStandardAddress  NonStandardParameter,
  ...
}

EndpointType ::= SEQUENCE {
  nonStandardData  NonStandardParameter OPTIONAL,
  vendor           VendorIdentifier OPTIONAL,
  gatekeeper       GatekeeperInfo OPTIONAL,
  gateway          GatewayInfo OPTIONAL,
  mcu              McuInfo OPTIONAL, -- mc must be set as well
  terminal         TerminalInfo OPTIONAL,
  mc               BOOLEAN, -- shall not be set by itself
  undefinedNode    BOOLEAN,
  ...,
  set              BIT STRING(SIZE (32)) OPTIONAL
}

-- shall not be used with mc, gatekeeper
-- code points for the various SET devices
-- are defined in the respective SET Annexes
GatewayInfo ::= SEQUENCE {
  protocol         SEQUENCE OF SupportedProtocols OPTIONAL,
  nonStandardData  NonStandardParameter OPTIONAL,
  ...
}

SupportedProtocols ::= CHOICE {
  nonStandardData      NonStandardParameter,
  h310                 H310Caps,
  h320                 H320Caps,
  h321                 H321Caps,
  h322                 H322Caps,
  h323                 H323Caps,
  h324                 H324Caps,
  voice                VoiceCaps,
  t120-only            T120OnlyCaps,
  ...,
  nonStandardProtocol  NonStandardProtocol,
  t38FaxAnnexbOnly     T38FaxAnnexbOnlyCaps
}

H310Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H320Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H321Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H322Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H323Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H324Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

VoiceCaps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

T120OnlyCaps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

NonStandardProtocol ::= SEQUENCE {
  nonStandardData     NonStandardParameter OPTIONAL,
  dataRatesSupported  SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes   SEQUENCE OF SupportedPrefix,
  ...
}

T38FaxAnnexbOnlyCaps ::= SEQUENCE {
  nonStandardData     NonStandardParameter OPTIONAL,
  dataRatesSupported  SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes   SEQUENCE OF SupportedPrefix,
  t38FaxProtocol      DataProtocolCapability,
  t38FaxProfile       T38FaxProfile,
  ...
}

McuInfo ::= SEQUENCE {nonStandardData  NonStandardParameter OPTIONAL,
                      ...
}

TerminalInfo ::= SEQUENCE {nonStandardData  NonStandardParameter OPTIONAL,
                           ...
}

GatekeeperInfo ::= SEQUENCE {
  nonStandardData  NonStandardParameter OPTIONAL,
  ...
}

VendorIdentifier ::= SEQUENCE {
  vendor     H221NonStandard,
  productId  OCTET STRING(SIZE (1..256)) OPTIONAL, -- per vendor
  versionId  OCTET STRING(SIZE (1..256)) OPTIONAL, -- per product
  ...
}

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

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

NonStandardIdentifier ::= CHOICE {
  object           OBJECT IDENTIFIER,
  h221NonStandard  H221NonStandard,
  ...
}

AliasAddress ::= CHOICE {
  e164         IA5String(SIZE (1..128))(FROM ("0123456789#*,")),
  h323-ID      BMPString(SIZE (1..256)), -- Basic ISO/IEC 10646-1 (Unicode)
  ...,
  url-ID       IA5String(SIZE (1..512)), -- URL style address
  transportID  TransportAddress,
  email-ID     IA5String(SIZE (1..512)), -- rfc822-compliant email address
  partyNumber  PartyNumber
}

PartyNumber ::= CHOICE {
  publicNumber                 PublicPartyNumber,
  -- the numbering plan is according to
  -- Recommendations E.163 and E.164.
  dataPartyNumber              NumberDigits,
  -- not used, value reserved.
  telexPartyNumber             NumberDigits,
  -- not used, value reserved.
  privateNumber                PrivatePartyNumber,
  nationalStandardPartyNumber  NumberDigits,
  -- not used, value reserved.
  ...
}

PublicPartyNumber ::= SEQUENCE {
  publicTypeOfNumber  PublicTypeOfNumber,
  publicNumberDigits  NumberDigits
}

PrivatePartyNumber ::= SEQUENCE {
  privateTypeOfNumber  PrivateTypeOfNumber,
  privateNumberDigits  NumberDigits
}

NumberDigits ::= IA5String(SIZE (1..128))(FROM ("0123456789#*,"))

PublicTypeOfNumber ::= CHOICE {
  unknown                NULL,
  -- if used number digits carry prefix indicating type
  -- of number according to national recommendations.
  internationalNumber    NULL,
  nationalNumber         NULL,
  networkSpecificNumber  NULL,
  -- not used, value reserved
  subscriberNumber       NULL,
  abbreviatedNumber      NULL,
  -- valid only for called party number at the outgoing
  -- access, network substitutes appropriate number.
  ...
}

PrivateTypeOfNumber ::= CHOICE {
  unknown               NULL,
  level2RegionalNumber  NULL,
  level1RegionalNumber  NULL,
  pISNSpecificNumber    NULL,
  localNumber           NULL,
  abbreviatedNumber     NULL,
  ...
}

Endpoint ::= SEQUENCE {
  nonStandardData         NonStandardParameter OPTIONAL,
  aliasAddress            SEQUENCE OF AliasAddress OPTIONAL,
  callSignalAddress       SEQUENCE OF TransportAddress OPTIONAL,
  rasAddress              SEQUENCE OF TransportAddress OPTIONAL,
  endpointType            EndpointType OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  priority                INTEGER(0..127) OPTIONAL,
  remoteExtensionAddress  SEQUENCE OF AliasAddress OPTIONAL,
  destExtraCallInfo       SEQUENCE OF AliasAddress OPTIONAL,
  ...
}

AlternateGK ::= SEQUENCE {
  rasAddress            TransportAddress,
  gatekeeperIdentifier  GatekeeperIdentifier OPTIONAL,
  needToRegister        BOOLEAN,
  priority              INTEGER(0..127),
  ...
}

AltGKInfo ::= SEQUENCE {
  alternateGatekeeper  SEQUENCE OF AlternateGK,
  altGKisPermanent     BOOLEAN,
  ...
}

SecurityServiceMode ::= CHOICE {
  nonStandard  NonStandardParameter,
  none         NULL,
  default      NULL,
  ...
} -- can be extended with other specific modes

SecurityCapabilities ::= SEQUENCE {
  nonStandard    NonStandardParameter OPTIONAL,
  encryption     SecurityServiceMode,
  authenticaton  SecurityServiceMode,
  integrity      SecurityServiceMode,
  ...
}

H245Security ::= CHOICE {
  nonStandard  NonStandardParameter,
  noSecurity   NULL,
  tls          SecurityCapabilities,
  ipsec        SecurityCapabilities,
  ...
}

QseriesOptions ::= SEQUENCE {
  q932Full  BOOLEAN, -- if true, indicates full support for Q.932
  q951Full  BOOLEAN, -- if true, indicates full support for Q.951
  q952Full  BOOLEAN, -- if true, indicates full support for Q.952
  q953Full  BOOLEAN, -- if true, indicates full support for Q.953
  q955Full  BOOLEAN, -- if true, indicates full support for Q.955
  q956Full  BOOLEAN, -- if true, indicates full support for Q.956
  q957Full  BOOLEAN, -- if true, indicates full support for Q.957
  q954Info  Q954Details,
  ...
}

Q954Details ::= SEQUENCE {
  conferenceCalling  BOOLEAN,
  threePartyService  BOOLEAN,
  ...
}

GloballyUniqueID ::= OCTET STRING(SIZE (16))

ConferenceIdentifier ::= GloballyUniqueID

RequestSeqNum ::= INTEGER(1..65535)

GatekeeperIdentifier ::= BMPString(SIZE (1..128))

BandWidth ::= INTEGER(0..4294967295) -- in 100s of bits
                     

CallReferenceValue ::= INTEGER(0..65535)

EndpointIdentifier ::= BMPString(SIZE (1..128))

ProtocolIdentifier ::= OBJECT IDENTIFIER

-- shall be set to
-- {itu-t (0) recommendation (0) h (8) 2250 version (0) 3}
TimeToLive ::= INTEGER(1..4294967295) --in seconds
                      

CallIdentifier ::= SEQUENCE {guid  GloballyUniqueID,
                             ...
}

EncryptIntAlg ::=
  CHOICE { -- core encryption algorithms for RAS message integrity
  nonStandard   NonStandardParameter,
  isoAlgorithm  OBJECT IDENTIFIER, -- defined in ISO/IEC 9979
  ...
}

NonIsoIntegrityMechanism ::=
  CHOICE { -- HMAC mechanism used, no truncation, tagging may be necessary!
  hMAC-MD5           NULL,
  hMAC-iso10118-2-s  EncryptIntAlg, -- according to ISO/IEC 10118-2 using
  
  -- EncryptIntAlg as core block encryption algorithm
  -- (short MAC)
  hMAC-iso10118-2-l  EncryptIntAlg, -- according to ISO/IEC 10118-2 using
  
  -- EncryptIntAlg as core block encryption algorithm
  -- (long MAC)
  hMAC-iso10118-3    OBJECT IDENTIFIER, -- according to ISO/IEC 10118-3 using
  
  -- OID as hash function (OID is SHA-1,
  -- RIPE-MD160,
  -- RIPE-MD128)
  ...
}

IntegrityMechanism ::= CHOICE { -- for RAS message integrity
  nonStandard  NonStandardParameter,
  digSig       NULL, -- indicates to apply a digital signature
  iso9797      OBJECT IDENTIFIER, -- according to ISO/IEC 9797 using OID as
  
  -- core encryption algorithm (X-CBC MAC)
  nonIsoIM     NonIsoIntegrityMechanism,
  ...
}

ICV ::= SEQUENCE {
  algorithmOID  OBJECT IDENTIFIER, -- the algorithm used to compute the signature
  icv           BIT STRING
} -- the computed cryptographic integrity check value

-- or signature
FastStartToken ::=
  ClearToken
    (WITH COMPONENTS {
       ...,
       timeStamp  PRESENT,
       dhkey      PRESENT,
       generalID  PRESENT
     }) -- set to 'alias' 
    

EncodedFastStartToken ::= TYPE-IDENTIFIER.&Type(FastStartToken)

CryptoH323Token ::= CHOICE {
  cryptoEPPwdHash
    SEQUENCE {alias      AliasAddress, -- alias of entity generating hash--
              timeStamp  TimeStamp, -- timestamp used in hash--
              token      HASHED{EncodedPwdCertToken} -- generalID set to 'alias' 
  },
  cryptoGKPwdHash
    SEQUENCE {gatekeeperId  GatekeeperIdentifier, -- GatekeeperID of GK generating hash--
              timeStamp     TimeStamp, -- timestamp used in hash--
              token         HASHED{EncodedPwdCertToken} -- generalID set to Gatekeeperid 
  },
  cryptoEPPwdEncr    ENCRYPTED{EncodedPwdCertToken}, -- generalID set to Gatekeeperid 
  cryptoGKPwdEncr    ENCRYPTED{EncodedPwdCertToken}, -- generalID set to Gatekeeperid 
  cryptoEPCert       SIGNED{EncodedPwdCertToken}, -- generalID set to Gatekeeperid 
  cryptoGKCert       SIGNED{EncodedPwdCertToken}, -- generalID set to alias 
  cryptoFastStart    SIGNED{EncodedFastStartToken},
  nestedcryptoToken  CryptoToken,
  ...
}

DataRate ::= SEQUENCE {
  nonStandardData    NonStandardParameter OPTIONAL,
  channelRate        BandWidth,
  channelMultiplier  INTEGER(1..256) OPTIONAL,
  ...
}

SupportedPrefix ::= SEQUENCE {
  nonStandardData  NonStandardParameter OPTIONAL,
  prefix           AliasAddress,
  ...
}

RasMessage ::= CHOICE {
  gatekeeperRequest           GatekeeperRequest,
  gatekeeperConfirm           GatekeeperConfirm,
  gatekeeperReject            GatekeeperReject,
  registrationRequest         RegistrationRequest,
  registrationConfirm         RegistrationConfirm,
  registrationReject          RegistrationReject,
  unregistrationRequest       UnregistrationRequest,
  unregistrationConfirm       UnregistrationConfirm,
  unregistrationReject        UnregistrationReject,
  admissionRequest            AdmissionRequest,
  admissionConfirm            AdmissionConfirm,
  admissionReject             AdmissionReject,
  bandwidthRequest            BandwidthRequest,
  bandwidthConfirm            BandwidthConfirm,
  bandwidthReject             BandwidthReject,
  disengageRequest            DisengageRequest,
  disengageConfirm            DisengageConfirm,
  disengageReject             DisengageReject,
  locationRequest             LocationRequest,
  locationConfirm             LocationConfirm,
  locationReject              LocationReject,
  infoRequest                 InfoRequest,
  infoRequestResponse         InfoRequestResponse,
  nonStandardMessage          NonStandardMessage,
  unknownMessageResponse      UnknownMessageResponse,
  ...,
  requestInProgress           RequestInProgress,
  resourcesAvailableIndicate  ResourcesAvailableIndicate,
  resourcesAvailableConfirm   ResourcesAvailableConfirm,
  infoRequestAck              InfoRequestAck,
  infoRequestNak              InfoRequestNak
}

GatekeeperRequest ::= SEQUENCE --(GRQ)
                       {
  requestSeqNum                RequestSeqNum,
  protocolIdentifier           ProtocolIdentifier,
  nonStandardData              NonStandardParameter OPTIONAL,
  rasAddress                   TransportAddress,
  endpointType                 EndpointType,
  gatekeeperIdentifier         GatekeeperIdentifier OPTIONAL,
  callServices                 QseriesOptions OPTIONAL,
  endpointAlias                SEQUENCE OF AliasAddress OPTIONAL,
  ...,
  alternateEndpoints           SEQUENCE OF Endpoint OPTIONAL,
  tokens                       SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                 SEQUENCE OF CryptoH323Token OPTIONAL,
  authenticationCapability     SEQUENCE OF AuthenticationMechanism OPTIONAL,
  algorithmOIDs                SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
  integrity                    SEQUENCE OF IntegrityMechanism OPTIONAL,
  integrityCheckValue          ICV OPTIONAL
}

GatekeeperConfirm ::= SEQUENCE --(GCF)
                       {
  requestSeqNum           RequestSeqNum,
  protocolIdentifier      ProtocolIdentifier,
  nonStandardData         NonStandardParameter OPTIONAL,
  gatekeeperIdentifier    GatekeeperIdentifier OPTIONAL,
  rasAddress              TransportAddress,
  ...,
  alternateGatekeeper     SEQUENCE OF AlternateGK OPTIONAL,
  authenticationMode      AuthenticationMechanism OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  algorithmOID            OBJECT IDENTIFIER OPTIONAL,
  integrity               SEQUENCE OF IntegrityMechanism OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

GatekeeperReject ::= SEQUENCE --(GRJ)
                      {
  requestSeqNum           RequestSeqNum,
  protocolIdentifier      ProtocolIdentifier,
  nonStandardData         NonStandardParameter OPTIONAL,
  gatekeeperIdentifier    GatekeeperIdentifier OPTIONAL,
  rejectReason            GatekeeperRejectReason,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

GatekeeperRejectReason ::= CHOICE {
  resourceUnavailable  NULL,
  terminalExcluded     NULL, -- permission failure, not a resource failure
  invalidRevision      NULL,
  undefinedReason      NULL,
  ...,
  securityDenial       NULL
}

RegistrationRequest ::= SEQUENCE --(RRQ)
                         {
  requestSeqNum                    RequestSeqNum,
  protocolIdentifier               ProtocolIdentifier,
  nonStandardData                  NonStandardParameter OPTIONAL,
  discoveryComplete                BOOLEAN,
  callSignalAddress                SEQUENCE OF TransportAddress,
  rasAddress                       SEQUENCE OF TransportAddress,
  terminalType                     EndpointType,
  terminalAlias                    SEQUENCE OF AliasAddress OPTIONAL,
  gatekeeperIdentifier             GatekeeperIdentifier OPTIONAL,
  endpointVendor                   VendorIdentifier,
  ...,
  alternateEndpoints               SEQUENCE OF Endpoint OPTIONAL,
  timeToLive                       TimeToLive OPTIONAL,
  tokens                           SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                     SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue              ICV OPTIONAL,
  keepAlive                        BOOLEAN,
  endpointIdentifier               EndpointIdentifier OPTIONAL,
  willSupplyUUIEs                  BOOLEAN,
  maintainConnection               BOOLEAN,
  supportsAnnexECallSignalling     BOOLEAN
}

RegistrationConfirm ::= SEQUENCE --(RCF)
                         {
  requestSeqNum           RequestSeqNum,
  protocolIdentifier      ProtocolIdentifier,
  nonStandardData         NonStandardParameter OPTIONAL,
  callSignalAddress       SEQUENCE OF TransportAddress,
  terminalAlias           SEQUENCE OF AliasAddress OPTIONAL,
  gatekeeperIdentifier    GatekeeperIdentifier OPTIONAL,
  endpointIdentifier      EndpointIdentifier,
  ...,
  alternateGatekeeper     SEQUENCE OF AlternateGK OPTIONAL,
  timeToLive              TimeToLive OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  willRespondToIRR        BOOLEAN,
  preGrantedARQ
    SEQUENCE {makeCall                          BOOLEAN,
              useGKCallSignalAddressToMakeCall  BOOLEAN,
              answerCall                        BOOLEAN,
              useGKCallSignalAddressToAnswer    BOOLEAN,
              ...,
              irrFrequencyInCall                INTEGER(1..65535) OPTIONAL, -- in seconds; not--
              -- present if GK
              -- does not want IRRs
              totalBandwidthRestriction         BandWidth OPTIONAL, -- total limit for all--
              -- concurrent calls
              useAnnexECallSignalling           BOOLEAN} OPTIONAL,
  maintainConnection      BOOLEAN
}

RegistrationReject ::= SEQUENCE --(RRJ)
                        {
  requestSeqNum           RequestSeqNum,
  protocolIdentifier      ProtocolIdentifier,
  nonStandardData         NonStandardParameter OPTIONAL,
  rejectReason            RegistrationRejectReason,
  gatekeeperIdentifier    GatekeeperIdentifier OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

RegistrationRejectReason ::= CHOICE {
  discoveryRequired         NULL,
  invalidRevision           NULL,
  invalidCallSignalAddress  NULL,
  invalidRASAddress         NULL, -- supplied address is invalid
  duplicateAlias            SEQUENCE OF AliasAddress,
  -- alias registered to another endpoint
  invalidTerminalType       NULL,
  undefinedReason           NULL,
  transportNotSupported     NULL, -- one or more of the transports
  ...,
  transportQOSNotSupported  NULL, -- endpoint QOS not supported
  resourceUnavailable       NULL, -- gatekeeper resources exhausted
  invalidAlias              NULL, -- alias not consistent with gatekeeper rules
  securityDenial            NULL,
  fullRegistrationRequired  NULL
} -- registration permission has expired

UnregistrationRequest ::= SEQUENCE --(URQ)
                           {
  requestSeqNum            RequestSeqNum,
  callSignalAddress        SEQUENCE OF TransportAddress,
  endpointAlias            SEQUENCE OF AliasAddress OPTIONAL,
  nonStandardData          NonStandardParameter OPTIONAL,
  endpointIdentifier       EndpointIdentifier OPTIONAL,
  ...,
  alternateEndpoints       SEQUENCE OF Endpoint OPTIONAL,
  gatekeeperIdentifier     GatekeeperIdentifier OPTIONAL,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL,
  reason                   UnregRequestReason OPTIONAL
}

UnregRequestReason ::= CHOICE {
  reregistrationRequired  NULL,
  ttlExpired              NULL,
  securityDenial          NULL,
  undefinedReason         NULL,
  ...
}

UnregistrationConfirm ::= SEQUENCE --(UCF)
                           {
  requestSeqNum           RequestSeqNum,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

UnregistrationReject ::= SEQUENCE --(URJ)
                          {
  requestSeqNum           RequestSeqNum,
  rejectReason            UnregRejectReason,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

UnregRejectReason ::= CHOICE {
  notCurrentlyRegistered  NULL,
  callInProgress          NULL,
  undefinedReason         NULL,
  ...,
  permissionDenied        NULL, -- requesting user not allowed to unregister
  
  -- specified user
  securityDenial          NULL
}

AdmissionRequest ::= SEQUENCE --(ARQ)
                      {
  requestSeqNum            RequestSeqNum,
  callType                 CallType,
  callModel                CallModel OPTIONAL,
  endpointIdentifier       EndpointIdentifier,
  destinationInfo          SEQUENCE OF AliasAddress OPTIONAL, -- Note 1
  destCallSignalAddress    TransportAddress OPTIONAL, -- Note 1
  destExtraCallInfo        SEQUENCE OF AliasAddress OPTIONAL,
  srcInfo                  SEQUENCE OF AliasAddress,
  srcCallSignalAddress     TransportAddress OPTIONAL,
  bandWidth                BandWidth,
  callReferenceValue       CallReferenceValue,
  nonStandardData          NonStandardParameter OPTIONAL,
  callServices             QseriesOptions OPTIONAL,
  conferenceID             ConferenceIdentifier,
  activeMC                 BOOLEAN,
  answerCall               BOOLEAN, -- answering a call
  ...,
  canMapAlias              BOOLEAN, -- can handle alias address
  callIdentifier           CallIdentifier,
  srcAlternatives          SEQUENCE OF Endpoint OPTIONAL,
  destAlternatives         SEQUENCE OF Endpoint OPTIONAL,
  gatekeeperIdentifier     GatekeeperIdentifier OPTIONAL,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL,
  transportQOS             TransportQOS OPTIONAL,
  willSupplyUUIEs          BOOLEAN
}

CallType ::= CHOICE {
  pointToPoint  NULL, -- Point-to-point
  oneToN        NULL, -- no interaction (FFS)
  nToOne        NULL, -- no interaction (FFS)
  nToN          NULL, -- interactive (multipoint)
  ...
}

CallModel ::= CHOICE {direct            NULL,
                      gatekeeperRouted  NULL,
                      ...
}

TransportQOS ::= CHOICE {
  endpointControlled    NULL,
  gatekeeperControlled  NULL,
  noControl             NULL,
  ...
}

AdmissionConfirm ::= SEQUENCE --(ACF)
                      {
  requestSeqNum               RequestSeqNum,
  bandWidth                   BandWidth,
  callModel                   CallModel,
  destCallSignalAddress       TransportAddress,
  irrFrequency                INTEGER(1..65535) OPTIONAL,
  nonStandardData             NonStandardParameter OPTIONAL,
  ...,
  destinationInfo             SEQUENCE OF AliasAddress OPTIONAL,
  destExtraCallInfo           SEQUENCE OF AliasAddress OPTIONAL,
  destinationType             EndpointType OPTIONAL,
  remoteExtensionAddress      SEQUENCE OF AliasAddress OPTIONAL,
  alternateEndpoints          SEQUENCE OF Endpoint OPTIONAL,
  tokens                      SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue         ICV OPTIONAL,
  transportQOS                TransportQOS OPTIONAL,
  willRespondToIRR            BOOLEAN,
  uuiesRequested              UUIEsRequested,
  language                    SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL, -- RFC1766 language tag
  useAnnexECallSignalling     BOOLEAN
}

UUIEsRequested ::= SEQUENCE {
  setup            BOOLEAN,
  callProceeding   BOOLEAN,
  connect          BOOLEAN,
  alerting         BOOLEAN,
  information      BOOLEAN,
  releaseComplete  BOOLEAN,
  facility         BOOLEAN,
  progress         BOOLEAN,
  empty            BOOLEAN,
  ...
}

AdmissionReject ::= SEQUENCE --(ARJ)
                     {
  requestSeqNum           RequestSeqNum,
  rejectReason            AdmissionRejectReason,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  callSignalAddress       SEQUENCE OF TransportAddress OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

AdmissionRejectReason ::= CHOICE {
  calledPartyNotRegistered   NULL, -- cannot translate address
  invalidPermission          NULL, -- permission has expired
  requestDenied              NULL, -- no bandwidth available
  undefinedReason            NULL,
  callerNotRegistered        NULL,
  routeCallToGatekeeper      NULL,
  invalidEndpointIdentifier  NULL,
  resourceUnavailable        NULL,
  ...,
  securityDenial             NULL,
  qosControlNotSupported     NULL,
  incompleteAddress          NULL,
  routeCallToSCN             SEQUENCE OF PartyNumber,
  aliasesInconsistent        NULL
} -- multiple aliases in request identify distinct people

BandwidthRequest ::= SEQUENCE --(BRQ)
                      {
  requestSeqNum            RequestSeqNum,
  endpointIdentifier       EndpointIdentifier,
  conferenceID             ConferenceIdentifier,
  callReferenceValue       CallReferenceValue,
  callType                 CallType OPTIONAL,
  bandWidth                BandWidth,
  nonStandardData          NonStandardParameter OPTIONAL,
  ...,
  callIdentifier           CallIdentifier,
  gatekeeperIdentifier     GatekeeperIdentifier OPTIONAL,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL,
  answeredCall             BOOLEAN
}

BandwidthConfirm ::= SEQUENCE --(BCF)
                      {
  requestSeqNum           RequestSeqNum,
  bandWidth               BandWidth,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

BandwidthReject ::= SEQUENCE --(BRJ)
                     {
  requestSeqNum           RequestSeqNum,
  rejectReason            BandRejectReason,
  allowedBandWidth        BandWidth,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

BandRejectReason ::= CHOICE {
  notBound               NULL, -- discovery permission has aged
  invalidConferenceID    NULL, -- possible revision
  invalidPermission      NULL, -- true permission violation
  insufficientResources  NULL,
  invalidRevision        NULL,
  undefinedReason        NULL,
  ...,
  securityDenial         NULL
}

LocationRequest ::= SEQUENCE --(LRQ)
                     {
  requestSeqNum            RequestSeqNum,
  endpointIdentifier       EndpointIdentifier OPTIONAL,
  destinationInfo          SEQUENCE OF AliasAddress,
  nonStandardData          NonStandardParameter OPTIONAL,
  replyAddress             TransportAddress,
  ...,
  sourceInfo               SEQUENCE OF AliasAddress OPTIONAL,
  canMapAlias              BOOLEAN, -- can handle alias address
  gatekeeperIdentifier     GatekeeperIdentifier OPTIONAL,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL
}

LocationConfirm ::= SEQUENCE --(LCF)
                     {
  requestSeqNum                    RequestSeqNum,
  callSignalAddress                TransportAddress,
  rasAddress                       TransportAddress,
  nonStandardData                  NonStandardParameter OPTIONAL,
  ...,
  destinationInfo                  SEQUENCE OF AliasAddress OPTIONAL,
  destExtraCallInfo                SEQUENCE OF AliasAddress OPTIONAL,
  destinationType                  EndpointType OPTIONAL,
  remoteExtensionAddress           SEQUENCE OF AliasAddress OPTIONAL,
  alternateEndpoints               SEQUENCE OF Endpoint OPTIONAL,
  tokens                           SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                     SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue              ICV OPTIONAL,
  supportsAnnexECallSignalling     BOOLEAN
}

LocationReject ::= SEQUENCE --(LRJ)
                    {
  requestSeqNum           RequestSeqNum,
  rejectReason            LocationRejectReason,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

LocationRejectReason ::= CHOICE {
  notRegistered        NULL,
  invalidPermission    NULL, -- exclusion by administrator or feature
  requestDenied        NULL, -- cannot find location
  undefinedReason      NULL,
  ...,
  securityDenial       NULL,
  routeCallToSCN       SEQUENCE OF PartyNumber,
  aliasesInconsistent  NULL
} -- multiple aliases in request identify distinct people

DisengageRequest ::= SEQUENCE --(DRQ)
                      {
  requestSeqNum            RequestSeqNum,
  endpointIdentifier       EndpointIdentifier,
  conferenceID             ConferenceIdentifier,
  callReferenceValue       CallReferenceValue,
  disengageReason          DisengageReason,
  nonStandardData          NonStandardParameter OPTIONAL,
  ...,
  callIdentifier           CallIdentifier,
  gatekeeperIdentifier     GatekeeperIdentifier OPTIONAL,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL,
  answeredCall             BOOLEAN
}

DisengageReason ::= CHOICE {
  forcedDrop       NULL, -- gatekeeper is forcing the drop
  normalDrop       NULL, -- associated with normal drop
  undefinedReason  NULL,
  ...
}

DisengageConfirm ::= SEQUENCE --(DCF)
                      {
  requestSeqNum           RequestSeqNum,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

DisengageReject ::= SEQUENCE --(DRJ)
                     {
  requestSeqNum           RequestSeqNum,
  rejectReason            DisengageRejectReason,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

DisengageRejectReason ::= CHOICE {
  notRegistered       NULL, -- not registered with gatekeeper
  requestToDropOther  NULL, -- cannot request drop for others
  ...,
  securityDenial      NULL
}

InfoRequest ::= SEQUENCE --(IRQ)
                 {
  requestSeqNum           RequestSeqNum,
  callReferenceValue      CallReferenceValue,
  nonStandardData         NonStandardParameter OPTIONAL,
  replyAddress            TransportAddress OPTIONAL,
  ...,
  callIdentifier          CallIdentifier,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  uuiesRequested          UUIEsRequested OPTIONAL
}

InfoRequestResponse ::= SEQUENCE --(IRR)
                         {
  nonStandardData         NonStandardParameter OPTIONAL,
  requestSeqNum           RequestSeqNum,
  endpointType            EndpointType,
  endpointIdentifier      EndpointIdentifier,
  rasAddress              TransportAddress,
  callSignalAddress       SEQUENCE OF TransportAddress,
  endpointAlias           SEQUENCE OF AliasAddress OPTIONAL,
  perCallInfo
    SEQUENCE OF
      SEQUENCE {nonStandardData       NonStandardParameter OPTIONAL,
                callReferenceValue    CallReferenceValue,
                conferenceID          ConferenceIdentifier,
                originator            BOOLEAN OPTIONAL,
                audio                 SEQUENCE OF RTPSession OPTIONAL,
                video                 SEQUENCE OF RTPSession OPTIONAL,
                data                  SEQUENCE OF TransportChannelInfo OPTIONAL,
                h245                  TransportChannelInfo,
                callSignalling        TransportChannelInfo,
                callType              CallType,
                bandWidth             BandWidth,
                callModel             CallModel,
                ...,
                callIdentifier        CallIdentifier,
                tokens                SEQUENCE OF ClearToken OPTIONAL,
                cryptoTokens          SEQUENCE OF CryptoH323Token OPTIONAL,
                substituteConfIDs     SEQUENCE OF ConferenceIdentifier,
                pdu
                  SEQUENCE OF
                    SEQUENCE {h323pdu  H323-UU-PDU,
                              sent     BOOLEAN -- TRUE is sent, FALSE is received
                    } OPTIONAL} OPTIONAL,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  needResponse            BOOLEAN
}

TransportChannelInfo ::= SEQUENCE {
  sendAddress  TransportAddress OPTIONAL,
  recvAddress  TransportAddress OPTIONAL,
  ...
}

RTPSession ::= SEQUENCE {
  rtpAddress            TransportChannelInfo,
  rtcpAddress           TransportChannelInfo,
  cname                 PrintableString,
  ssrc                  INTEGER(1..4294967295),
  sessionId             INTEGER(1..255),
  associatedSessionIds  SEQUENCE OF INTEGER(1..255),
  ...
}

InfoRequestAck ::= SEQUENCE --(IACK)
                    {
  requestSeqNum        RequestSeqNum,
  nonStandardData      NonStandardParameter OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  ...
}

InfoRequestNak ::= SEQUENCE --(INAK)
                    {
  requestSeqNum        RequestSeqNum,
  nonStandardData      NonStandardParameter OPTIONAL,
  nakReason            InfoRequestNakReason,
  altGKInfo            AltGKInfo OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  ...
}

InfoRequestNakReason ::= CHOICE {
  notRegistered    NULL, -- not registered with gatekeeper
  securityDenial   NULL,
  undefinedReason  NULL,
  ...
}

NonStandardMessage ::= SEQUENCE {
  requestSeqNum           RequestSeqNum,
  nonStandardData         NonStandardParameter,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

UnknownMessageResponse ::= SEQUENCE -- (XRS)
                            {
  requestSeqNum           RequestSeqNum,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL
}

RequestInProgress ::= SEQUENCE -- (RIP)
                       {
  requestSeqNum        RequestSeqNum,
  nonStandardData      NonStandardParameter OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  delay                INTEGER(1..65535),
  ...
}

ResourcesAvailableIndicate ::= SEQUENCE --(RAI)
                                {
  requestSeqNum         RequestSeqNum,
  protocolIdentifier    ProtocolIdentifier,
  nonStandardData       NonStandardParameter OPTIONAL,
  endpointIdentifier    EndpointIdentifier,
  protocols             SEQUENCE OF SupportedProtocols,
  almostOutOfResources  BOOLEAN,
  tokens                SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens          SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue   ICV OPTIONAL,
  ...
}

ResourcesAvailableConfirm ::= SEQUENCE --(RAC)
                               {
  requestSeqNum        RequestSeqNum,
  protocolIdentifier   ProtocolIdentifier,
  nonStandardData      NonStandardParameter OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  ...
}

END -- of ASN.1
-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D