include/linux/netfilter_ipv4/ip_conntrack_helper_h323_types.h

   1 /* Generated by Jing Min Zhao's ASN.1 parser, Apr 20 2006
   2  *
   3  * Copyright (c) 2006 Jing Min Zhao <zhaojingmin@users.sourceforge.net>
   4  *
   5  * This source code is licensed under General Public License version 2.
   6  */
   7
   8 typedef struct TransportAddress_ipAddress {     /* SEQUENCE */
   9         int options;            /* No use */
  10         unsigned ip;
  11 } TransportAddress_ipAddress;
  12
  13 typedef struct TransportAddress {       /* CHOICE */
  14         enum {
  15                 eTransportAddress_ipAddress,
  16                 eTransportAddress_ipSourceRoute,
  17                 eTransportAddress_ipxAddress,
  18                 eTransportAddress_ip6Address,
  19                 eTransportAddress_netBios,
  20                 eTransportAddress_nsap,
  21                 eTransportAddress_nonStandardAddress,
  22         } choice;
  23         union {
  24                 TransportAddress_ipAddress ipAddress;
  25         };
  26 } TransportAddress;
  27
  28 typedef struct DataProtocolCapability { /* CHOICE */
  29         enum {
  30                 eDataProtocolCapability_nonStandard,
  31                 eDataProtocolCapability_v14buffered,
  32                 eDataProtocolCapability_v42lapm,
  33                 eDataProtocolCapability_hdlcFrameTunnelling,
  34                 eDataProtocolCapability_h310SeparateVCStack,
  35                 eDataProtocolCapability_h310SingleVCStack,
  36                 eDataProtocolCapability_transparent,
  37                 eDataProtocolCapability_segmentationAndReassembly,
  38                 eDataProtocolCapability_hdlcFrameTunnelingwSAR,
  39                 eDataProtocolCapability_v120,
  40                 eDataProtocolCapability_separateLANStack,
  41                 eDataProtocolCapability_v76wCompression,
  42                 eDataProtocolCapability_tcp,
  43                 eDataProtocolCapability_udp,
  44         } choice;
  45 } DataProtocolCapability;
  46
  47 typedef struct DataApplicationCapability_application {  /* CHOICE */
  48         enum {
  49                 eDataApplicationCapability_application_nonStandard,
  50                 eDataApplicationCapability_application_t120,
  51                 eDataApplicationCapability_application_dsm_cc,
  52                 eDataApplicationCapability_application_userData,
  53                 eDataApplicationCapability_application_t84,
  54                 eDataApplicationCapability_application_t434,
  55                 eDataApplicationCapability_application_h224,
  56                 eDataApplicationCapability_application_nlpid,
  57                 eDataApplicationCapability_application_dsvdControl,
  58                 eDataApplicationCapability_application_h222DataPartitioning,
  59                 eDataApplicationCapability_application_t30fax,
  60                 eDataApplicationCapability_application_t140,
  61                 eDataApplicationCapability_application_t38fax,
  62                 eDataApplicationCapability_application_genericDataCapability,
  63         } choice;
  64         union {
  65                 DataProtocolCapability t120;
  66         };
  67 } DataApplicationCapability_application;
  68
  69 typedef struct DataApplicationCapability {      /* SEQUENCE */
  70         int options;            /* No use */
  71         DataApplicationCapability_application application;
  72 } DataApplicationCapability;
  73
  74 typedef struct DataType {       /* CHOICE */
  75         enum {
  76                 eDataType_nonStandard,
  77                 eDataType_nullData,
  78                 eDataType_videoData,
  79                 eDataType_audioData,
  80                 eDataType_data,
  81                 eDataType_encryptionData,
  82                 eDataType_h235Control,
  83                 eDataType_h235Media,
  84                 eDataType_multiplexedStream,
  85         } choice;
  86         union {
  87                 DataApplicationCapability data;
  88         };
  89 } DataType;
  90
  91 typedef struct UnicastAddress_iPAddress {       /* SEQUENCE */
  92         int options;            /* No use */
  93         unsigned network;
  94 } UnicastAddress_iPAddress;
  95
  96 typedef struct UnicastAddress { /* CHOICE */
  97         enum {
  98                 eUnicastAddress_iPAddress,
  99                 eUnicastAddress_iPXAddress,
 100                 eUnicastAddress_iP6Address,
 101                 eUnicastAddress_netBios,
 102                 eUnicastAddress_iPSourceRouteAddress,
 103                 eUnicastAddress_nsap,
 104                 eUnicastAddress_nonStandardAddress,
 105         } choice;
 106         union {
 107                 UnicastAddress_iPAddress iPAddress;
 108         };
 109 } UnicastAddress;
 110
 111 typedef struct H245_TransportAddress {  /* CHOICE */
 112         enum {
 113                 eH245_TransportAddress_unicastAddress,
 114                 eH245_TransportAddress_multicastAddress,
 115         } choice;
 116         union {
 117                 UnicastAddress unicastAddress;
 118         };
 119 } H245_TransportAddress;
 120
 121 typedef struct H2250LogicalChannelParameters {  /* SEQUENCE */
 122         enum {
 123                 eH2250LogicalChannelParameters_nonStandard = (1 << 31),
 124                 eH2250LogicalChannelParameters_associatedSessionID =
 125                     (1 << 30),
 126                 eH2250LogicalChannelParameters_mediaChannel = (1 << 29),
 127                 eH2250LogicalChannelParameters_mediaGuaranteedDelivery =
 128                     (1 << 28),
 129                 eH2250LogicalChannelParameters_mediaControlChannel =
 130                     (1 << 27),
 131                 eH2250LogicalChannelParameters_mediaControlGuaranteedDelivery
 132                     = (1 << 26),
 133                 eH2250LogicalChannelParameters_silenceSuppression = (1 << 25),
 134                 eH2250LogicalChannelParameters_destination = (1 << 24),
 135                 eH2250LogicalChannelParameters_dynamicRTPPayloadType =
 136                     (1 << 23),
 137                 eH2250LogicalChannelParameters_mediaPacketization = (1 << 22),
 138                 eH2250LogicalChannelParameters_transportCapability =
 139                     (1 << 21),
 140                 eH2250LogicalChannelParameters_redundancyEncoding = (1 << 20),
 141                 eH2250LogicalChannelParameters_source = (1 << 19),
 142         } options;
 143         H245_TransportAddress mediaChannel;
 144         H245_TransportAddress mediaControlChannel;
 145 } H2250LogicalChannelParameters;
 146
 147 typedef struct OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters { /* CHOICE */
 148         enum {
 149                 eOpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h222LogicalChannelParameters,
 150                 eOpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h223LogicalChannelParameters,
 151                 eOpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_v76LogicalChannelParameters,
 152                 eOpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters,
 153                 eOpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_none,
 154         } choice;
 155         union {
 156                 H2250LogicalChannelParameters h2250LogicalChannelParameters;
 157         };
 158 } OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters;
 159
 160 typedef struct OpenLogicalChannel_forwardLogicalChannelParameters {     /* SEQUENCE */
 161         enum {
 162                 eOpenLogicalChannel_forwardLogicalChannelParameters_portNumber
 163                     = (1 << 31),
 164                 eOpenLogicalChannel_forwardLogicalChannelParameters_forwardLogicalChannelDependency
 165                     = (1 << 30),
 166                 eOpenLogicalChannel_forwardLogicalChannelParameters_replacementFor
 167                     = (1 << 29),
 168         } options;
 169         DataType dataType;
 170         OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters
 171             multiplexParameters;
 172 } OpenLogicalChannel_forwardLogicalChannelParameters;
 173
 174 typedef struct OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters { /* CHOICE */
 175         enum {
 176                 eOpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h223LogicalChannelParameters,
 177                 eOpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_v76LogicalChannelParameters,
 178                 eOpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters,
 179         } choice;
 180         union {
 181                 H2250LogicalChannelParameters h2250LogicalChannelParameters;
 182         };
 183 } OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters;
 184
 185 typedef struct OpenLogicalChannel_reverseLogicalChannelParameters {     /* SEQUENCE */
 186         enum {
 187                 eOpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters
 188                     = (1 << 31),
 189                 eOpenLogicalChannel_reverseLogicalChannelParameters_reverseLogicalChannelDependency
 190                     = (1 << 30),
 191                 eOpenLogicalChannel_reverseLogicalChannelParameters_replacementFor
 192                     = (1 << 29),
 193         } options;
 194         OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters
 195             multiplexParameters;
 196 } OpenLogicalChannel_reverseLogicalChannelParameters;
 197
 198 typedef struct NetworkAccessParameters_networkAddress { /* CHOICE */
 199         enum {
 200                 eNetworkAccessParameters_networkAddress_q2931Address,
 201                 eNetworkAccessParameters_networkAddress_e164Address,
 202                 eNetworkAccessParameters_networkAddress_localAreaAddress,
 203         } choice;
 204         union {
 205                 H245_TransportAddress localAreaAddress;
 206         };
 207 } NetworkAccessParameters_networkAddress;
 208
 209 typedef struct NetworkAccessParameters {        /* SEQUENCE */
 210         enum {
 211                 eNetworkAccessParameters_distribution = (1 << 31),
 212                 eNetworkAccessParameters_externalReference = (1 << 30),
 213                 eNetworkAccessParameters_t120SetupProcedure = (1 << 29),
 214         } options;
 215         NetworkAccessParameters_networkAddress networkAddress;
 216 } NetworkAccessParameters;
 217
 218 typedef struct OpenLogicalChannel {     /* SEQUENCE */
 219         enum {
 220                 eOpenLogicalChannel_reverseLogicalChannelParameters =
 221                     (1 << 31),
 222                 eOpenLogicalChannel_separateStack = (1 << 30),
 223                 eOpenLogicalChannel_encryptionSync = (1 << 29),
 224         } options;
 225         OpenLogicalChannel_forwardLogicalChannelParameters
 226             forwardLogicalChannelParameters;
 227         OpenLogicalChannel_reverseLogicalChannelParameters
 228             reverseLogicalChannelParameters;
 229         NetworkAccessParameters separateStack;
 230 } OpenLogicalChannel;
 231
 232 typedef struct Setup_UUIE_fastStart {   /* SEQUENCE OF */
 233         int count;
 234         OpenLogicalChannel item[30];
 235 } Setup_UUIE_fastStart;
 236
 237 typedef struct Setup_UUIE {     /* SEQUENCE */
 238         enum {
 239                 eSetup_UUIE_h245Address = (1 << 31),
 240                 eSetup_UUIE_sourceAddress = (1 << 30),
 241                 eSetup_UUIE_destinationAddress = (1 << 29),
 242                 eSetup_UUIE_destCallSignalAddress = (1 << 28),
 243                 eSetup_UUIE_destExtraCallInfo = (1 << 27),
 244                 eSetup_UUIE_destExtraCRV = (1 << 26),
 245                 eSetup_UUIE_callServices = (1 << 25),
 246                 eSetup_UUIE_sourceCallSignalAddress = (1 << 24),
 247                 eSetup_UUIE_remoteExtensionAddress = (1 << 23),
 248                 eSetup_UUIE_callIdentifier = (1 << 22),
 249                 eSetup_UUIE_h245SecurityCapability = (1 << 21),
 250                 eSetup_UUIE_tokens = (1 << 20),
 251                 eSetup_UUIE_cryptoTokens = (1 << 19),
 252                 eSetup_UUIE_fastStart = (1 << 18),
 253                 eSetup_UUIE_mediaWaitForConnect = (1 << 17),
 254                 eSetup_UUIE_canOverlapSend = (1 << 16),
 255                 eSetup_UUIE_endpointIdentifier = (1 << 15),
 256                 eSetup_UUIE_multipleCalls = (1 << 14),
 257                 eSetup_UUIE_maintainConnection = (1 << 13),
 258                 eSetup_UUIE_connectionParameters = (1 << 12),
 259                 eSetup_UUIE_language = (1 << 11),
 260                 eSetup_UUIE_presentationIndicator = (1 << 10),
 261                 eSetup_UUIE_screeningIndicator = (1 << 9),
 262                 eSetup_UUIE_serviceControl = (1 << 8),
 263                 eSetup_UUIE_symmetricOperationRequired = (1 << 7),
 264                 eSetup_UUIE_capacity = (1 << 6),
 265                 eSetup_UUIE_circuitInfo = (1 << 5),
 266                 eSetup_UUIE_desiredProtocols = (1 << 4),
 267                 eSetup_UUIE_neededFeatures = (1 << 3),
 268                 eSetup_UUIE_desiredFeatures = (1 << 2),
 269                 eSetup_UUIE_supportedFeatures = (1 << 1),
 270                 eSetup_UUIE_parallelH245Control = (1 << 0),
 271         } options;
 272         TransportAddress h245Address;
 273         TransportAddress destCallSignalAddress;
 274         TransportAddress sourceCallSignalAddress;
 275         Setup_UUIE_fastStart fastStart;
 276 } Setup_UUIE;
 277
 278 typedef struct CallProceeding_UUIE_fastStart {  /* SEQUENCE OF */
 279         int count;
 280         OpenLogicalChannel item[30];
 281 } CallProceeding_UUIE_fastStart;
 282
 283 typedef struct CallProceeding_UUIE {    /* SEQUENCE */
 284         enum {
 285                 eCallProceeding_UUIE_h245Address = (1 << 31),
 286                 eCallProceeding_UUIE_callIdentifier = (1 << 30),
 287                 eCallProceeding_UUIE_h245SecurityMode = (1 << 29),
 288                 eCallProceeding_UUIE_tokens = (1 << 28),
 289                 eCallProceeding_UUIE_cryptoTokens = (1 << 27),
 290                 eCallProceeding_UUIE_fastStart = (1 << 26),
 291                 eCallProceeding_UUIE_multipleCalls = (1 << 25),
 292                 eCallProceeding_UUIE_maintainConnection = (1 << 24),
 293                 eCallProceeding_UUIE_fastConnectRefused = (1 << 23),
 294                 eCallProceeding_UUIE_featureSet = (1 << 22),
 295         } options;
 296         TransportAddress h245Address;
 297         CallProceeding_UUIE_fastStart fastStart;
 298 } CallProceeding_UUIE;
 299
 300 typedef struct Connect_UUIE_fastStart { /* SEQUENCE OF */
 301         int count;
 302         OpenLogicalChannel item[30];
 303 } Connect_UUIE_fastStart;
 304
 305 typedef struct Connect_UUIE {   /* SEQUENCE */
 306         enum {
 307                 eConnect_UUIE_h245Address = (1 << 31),
 308                 eConnect_UUIE_callIdentifier = (1 << 30),
 309                 eConnect_UUIE_h245SecurityMode = (1 << 29),
 310                 eConnect_UUIE_tokens = (1 << 28),
 311                 eConnect_UUIE_cryptoTokens = (1 << 27),
 312                 eConnect_UUIE_fastStart = (1 << 26),
 313                 eConnect_UUIE_multipleCalls = (1 << 25),
 314                 eConnect_UUIE_maintainConnection = (1 << 24),
 315                 eConnect_UUIE_language = (1 << 23),
 316                 eConnect_UUIE_connectedAddress = (1 << 22),
 317                 eConnect_UUIE_presentationIndicator = (1 << 21),
 318                 eConnect_UUIE_screeningIndicator = (1 << 20),
 319                 eConnect_UUIE_fastConnectRefused = (1 << 19),
 320                 eConnect_UUIE_serviceControl = (1 << 18),
 321                 eConnect_UUIE_capacity = (1 << 17),
 322                 eConnect_UUIE_featureSet = (1 << 16),
 323         } options;
 324         TransportAddress h245Address;
 325         Connect_UUIE_fastStart fastStart;
 326 } Connect_UUIE;
 327
 328 typedef struct Alerting_UUIE_fastStart {        /* SEQUENCE OF */
 329         int count;
 330         OpenLogicalChannel item[30];
 331 } Alerting_UUIE_fastStart;
 332
 333 typedef struct Alerting_UUIE {  /* SEQUENCE */
 334         enum {
 335                 eAlerting_UUIE_h245Address = (1 << 31),
 336                 eAlerting_UUIE_callIdentifier = (1 << 30),
 337                 eAlerting_UUIE_h245SecurityMode = (1 << 29),
 338                 eAlerting_UUIE_tokens = (1 << 28),
 339                 eAlerting_UUIE_cryptoTokens = (1 << 27),
 340                 eAlerting_UUIE_fastStart = (1 << 26),
 341                 eAlerting_UUIE_multipleCalls = (1 << 25),
 342                 eAlerting_UUIE_maintainConnection = (1 << 24),
 343                 eAlerting_UUIE_alertingAddress = (1 << 23),
 344                 eAlerting_UUIE_presentationIndicator = (1 << 22),
 345                 eAlerting_UUIE_screeningIndicator = (1 << 21),
 346                 eAlerting_UUIE_fastConnectRefused = (1 << 20),
 347                 eAlerting_UUIE_serviceControl = (1 << 19),
 348                 eAlerting_UUIE_capacity = (1 << 18),
 349                 eAlerting_UUIE_featureSet = (1 << 17),
 350         } options;
 351         TransportAddress h245Address;
 352         Alerting_UUIE_fastStart fastStart;
 353 } Alerting_UUIE;
 354
 355 typedef struct Information_UUIE_fastStart {     /* SEQUENCE OF */
 356         int count;
 357         OpenLogicalChannel item[30];
 358 } Information_UUIE_fastStart;
 359
 360 typedef struct Information_UUIE {       /* SEQUENCE */
 361         enum {
 362                 eInformation_UUIE_callIdentifier = (1 << 31),
 363                 eInformation_UUIE_tokens = (1 << 30),
 364                 eInformation_UUIE_cryptoTokens = (1 << 29),
 365                 eInformation_UUIE_fastStart = (1 << 28),
 366                 eInformation_UUIE_fastConnectRefused = (1 << 27),
 367                 eInformation_UUIE_circuitInfo = (1 << 26),
 368         } options;
 369         Information_UUIE_fastStart fastStart;
 370 } Information_UUIE;
 371
 372 typedef struct FacilityReason { /* CHOICE */
 373         enum {
 374                 eFacilityReason_routeCallToGatekeeper,
 375                 eFacilityReason_callForwarded,
 376                 eFacilityReason_routeCallToMC,
 377                 eFacilityReason_undefinedReason,
 378                 eFacilityReason_conferenceListChoice,
 379                 eFacilityReason_startH245,
 380                 eFacilityReason_noH245,
 381                 eFacilityReason_newTokens,
 382                 eFacilityReason_featureSetUpdate,
 383                 eFacilityReason_forwardedElements,
 384                 eFacilityReason_transportedInformation,
 385         } choice;
 386 } FacilityReason;
 387
 388 typedef struct Facility_UUIE_fastStart {        /* SEQUENCE OF */
 389         int count;
 390         OpenLogicalChannel item[30];
 391 } Facility_UUIE_fastStart;
 392
 393 typedef struct Facility_UUIE {  /* SEQUENCE */
 394         enum {
 395                 eFacility_UUIE_alternativeAddress = (1 << 31),
 396                 eFacility_UUIE_alternativeAliasAddress = (1 << 30),
 397                 eFacility_UUIE_conferenceID = (1 << 29),
 398                 eFacility_UUIE_callIdentifier = (1 << 28),
 399                 eFacility_UUIE_destExtraCallInfo = (1 << 27),
 400                 eFacility_UUIE_remoteExtensionAddress = (1 << 26),
 401                 eFacility_UUIE_tokens = (1 << 25),
 402                 eFacility_UUIE_cryptoTokens = (1 << 24),
 403                 eFacility_UUIE_conferences = (1 << 23),
 404                 eFacility_UUIE_h245Address = (1 << 22),
 405                 eFacility_UUIE_fastStart = (1 << 21),
 406                 eFacility_UUIE_multipleCalls = (1 << 20),
 407                 eFacility_UUIE_maintainConnection = (1 << 19),
 408                 eFacility_UUIE_fastConnectRefused = (1 << 18),
 409                 eFacility_UUIE_serviceControl = (1 << 17),
 410                 eFacility_UUIE_circuitInfo = (1 << 16),
 411                 eFacility_UUIE_featureSet = (1 << 15),
 412                 eFacility_UUIE_destinationInfo = (1 << 14),
 413                 eFacility_UUIE_h245SecurityMode = (1 << 13),
 414         } options;
 415         TransportAddress alternativeAddress;
 416         FacilityReason reason;
 417         TransportAddress h245Address;
 418         Facility_UUIE_fastStart fastStart;
 419 } Facility_UUIE;
 420
 421 typedef struct Progress_UUIE_fastStart {        /* SEQUENCE OF */
 422         int count;
 423         OpenLogicalChannel item[30];
 424 } Progress_UUIE_fastStart;
 425
 426 typedef struct Progress_UUIE {  /* SEQUENCE */
 427         enum {
 428                 eProgress_UUIE_h245Address = (1 << 31),
 429                 eProgress_UUIE_h245SecurityMode = (1 << 30),
 430                 eProgress_UUIE_tokens = (1 << 29),
 431                 eProgress_UUIE_cryptoTokens = (1 << 28),
 432                 eProgress_UUIE_fastStart = (1 << 27),
 433                 eProgress_UUIE_multipleCalls = (1 << 26),
 434                 eProgress_UUIE_maintainConnection = (1 << 25),
 435                 eProgress_UUIE_fastConnectRefused = (1 << 24),
 436         } options;
 437         TransportAddress h245Address;
 438         Progress_UUIE_fastStart fastStart;
 439 } Progress_UUIE;
 440
 441 typedef struct H323_UU_PDU_h323_message_body {  /* CHOICE */
 442         enum {
 443                 eH323_UU_PDU_h323_message_body_setup,
 444                 eH323_UU_PDU_h323_message_body_callProceeding,
 445                 eH323_UU_PDU_h323_message_body_connect,
 446                 eH323_UU_PDU_h323_message_body_alerting,
 447                 eH323_UU_PDU_h323_message_body_information,
 448                 eH323_UU_PDU_h323_message_body_releaseComplete,
 449                 eH323_UU_PDU_h323_message_body_facility,
 450                 eH323_UU_PDU_h323_message_body_progress,
 451                 eH323_UU_PDU_h323_message_body_empty,
 452                 eH323_UU_PDU_h323_message_body_status,
 453                 eH323_UU_PDU_h323_message_body_statusInquiry,
 454                 eH323_UU_PDU_h323_message_body_setupAcknowledge,
 455                 eH323_UU_PDU_h323_message_body_notify,
 456         } choice;
 457         union {
 458                 Setup_UUIE setup;
 459                 CallProceeding_UUIE callProceeding;
 460                 Connect_UUIE connect;
 461                 Alerting_UUIE alerting;
 462                 Information_UUIE information;
 463                 Facility_UUIE facility;
 464                 Progress_UUIE progress;
 465         };
 466 } H323_UU_PDU_h323_message_body;
 467
 468 typedef struct RequestMessage { /* CHOICE */
 469         enum {
 470                 eRequestMessage_nonStandard,
 471                 eRequestMessage_masterSlaveDetermination,
 472                 eRequestMessage_terminalCapabilitySet,
 473                 eRequestMessage_openLogicalChannel,
 474                 eRequestMessage_closeLogicalChannel,
 475                 eRequestMessage_requestChannelClose,
 476                 eRequestMessage_multiplexEntrySend,
 477                 eRequestMessage_requestMultiplexEntry,
 478                 eRequestMessage_requestMode,
 479                 eRequestMessage_roundTripDelayRequest,
 480                 eRequestMessage_maintenanceLoopRequest,
 481                 eRequestMessage_communicationModeRequest,
 482                 eRequestMessage_conferenceRequest,
 483                 eRequestMessage_multilinkRequest,
 484                 eRequestMessage_logicalChannelRateRequest,
 485         } choice;
 486         union {
 487                 OpenLogicalChannel openLogicalChannel;
 488         };
 489 } RequestMessage;
 490
 491 typedef struct OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters {      /* CHOICE */
 492         enum {
 493                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h222LogicalChannelParameters,
 494                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters,
 495         } choice;
 496         union {
 497                 H2250LogicalChannelParameters h2250LogicalChannelParameters;
 498         };
 499 } OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters;
 500
 501 typedef struct OpenLogicalChannelAck_reverseLogicalChannelParameters {  /* SEQUENCE */
 502         enum {
 503                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_portNumber
 504                     = (1 << 31),
 505                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters
 506                     = (1 << 30),
 507                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_replacementFor
 508                     = (1 << 29),
 509         } options;
 510         OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters
 511             multiplexParameters;
 512 } OpenLogicalChannelAck_reverseLogicalChannelParameters;
 513
 514 typedef struct H2250LogicalChannelAckParameters {       /* SEQUENCE */
 515         enum {
 516                 eH2250LogicalChannelAckParameters_nonStandard = (1 << 31),
 517                 eH2250LogicalChannelAckParameters_sessionID = (1 << 30),
 518                 eH2250LogicalChannelAckParameters_mediaChannel = (1 << 29),
 519                 eH2250LogicalChannelAckParameters_mediaControlChannel =
 520                     (1 << 28),
 521                 eH2250LogicalChannelAckParameters_dynamicRTPPayloadType =
 522                     (1 << 27),
 523                 eH2250LogicalChannelAckParameters_flowControlToZero =
 524                     (1 << 26),
 525                 eH2250LogicalChannelAckParameters_portNumber = (1 << 25),
 526         } options;
 527         H245_TransportAddress mediaChannel;
 528         H245_TransportAddress mediaControlChannel;
 529 } H2250LogicalChannelAckParameters;
 530
 531 typedef struct OpenLogicalChannelAck_forwardMultiplexAckParameters {    /* CHOICE */
 532         enum {
 533                 eOpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters,
 534         } choice;
 535         union {
 536                 H2250LogicalChannelAckParameters
 537                     h2250LogicalChannelAckParameters;
 538         };
 539 } OpenLogicalChannelAck_forwardMultiplexAckParameters;
 540
 541 typedef struct OpenLogicalChannelAck {  /* SEQUENCE */
 542         enum {
 543                 eOpenLogicalChannelAck_reverseLogicalChannelParameters =
 544                     (1 << 31),
 545                 eOpenLogicalChannelAck_separateStack = (1 << 30),
 546                 eOpenLogicalChannelAck_forwardMultiplexAckParameters =
 547                     (1 << 29),
 548                 eOpenLogicalChannelAck_encryptionSync = (1 << 28),
 549         } options;
 550         OpenLogicalChannelAck_reverseLogicalChannelParameters
 551             reverseLogicalChannelParameters;
 552         OpenLogicalChannelAck_forwardMultiplexAckParameters
 553             forwardMultiplexAckParameters;
 554 } OpenLogicalChannelAck;
 555
 556 typedef struct ResponseMessage {        /* CHOICE */
 557         enum {
 558                 eResponseMessage_nonStandard,
 559                 eResponseMessage_masterSlaveDeterminationAck,
 560                 eResponseMessage_masterSlaveDeterminationReject,
 561                 eResponseMessage_terminalCapabilitySetAck,
 562                 eResponseMessage_terminalCapabilitySetReject,
 563                 eResponseMessage_openLogicalChannelAck,
 564                 eResponseMessage_openLogicalChannelReject,
 565                 eResponseMessage_closeLogicalChannelAck,
 566                 eResponseMessage_requestChannelCloseAck,
 567                 eResponseMessage_requestChannelCloseReject,
 568                 eResponseMessage_multiplexEntrySendAck,
 569                 eResponseMessage_multiplexEntrySendReject,
 570                 eResponseMessage_requestMultiplexEntryAck,
 571                 eResponseMessage_requestMultiplexEntryReject,
 572                 eResponseMessage_requestModeAck,
 573                 eResponseMessage_requestModeReject,
 574                 eResponseMessage_roundTripDelayResponse,
 575                 eResponseMessage_maintenanceLoopAck,
 576                 eResponseMessage_maintenanceLoopReject,
 577                 eResponseMessage_communicationModeResponse,
 578                 eResponseMessage_conferenceResponse,
 579                 eResponseMessage_multilinkResponse,
 580                 eResponseMessage_logicalChannelRateAcknowledge,
 581                 eResponseMessage_logicalChannelRateReject,
 582         } choice;
 583         union {
 584                 OpenLogicalChannelAck openLogicalChannelAck;
 585         };
 586 } ResponseMessage;
 587
 588 typedef struct MultimediaSystemControlMessage { /* CHOICE */
 589         enum {
 590                 eMultimediaSystemControlMessage_request,
 591                 eMultimediaSystemControlMessage_response,
 592                 eMultimediaSystemControlMessage_command,
 593                 eMultimediaSystemControlMessage_indication,
 594         } choice;
 595         union {
 596                 RequestMessage request;
 597                 ResponseMessage response;
 598         };
 599 } MultimediaSystemControlMessage;
 600
 601 typedef struct H323_UU_PDU_h245Control {        /* SEQUENCE OF */
 602         int count;
 603         MultimediaSystemControlMessage item[4];
 604 } H323_UU_PDU_h245Control;
 605
 606 typedef struct H323_UU_PDU {    /* SEQUENCE */
 607         enum {
 608                 eH323_UU_PDU_nonStandardData = (1 << 31),
 609                 eH323_UU_PDU_h4501SupplementaryService = (1 << 30),
 610                 eH323_UU_PDU_h245Tunneling = (1 << 29),
 611                 eH323_UU_PDU_h245Control = (1 << 28),
 612                 eH323_UU_PDU_nonStandardControl = (1 << 27),
 613                 eH323_UU_PDU_callLinkage = (1 << 26),
 614                 eH323_UU_PDU_tunnelledSignallingMessage = (1 << 25),
 615                 eH323_UU_PDU_provisionalRespToH245Tunneling = (1 << 24),
 616                 eH323_UU_PDU_stimulusControl = (1 << 23),
 617                 eH323_UU_PDU_genericData = (1 << 22),
 618         } options;
 619         H323_UU_PDU_h323_message_body h323_message_body;
 620         H323_UU_PDU_h245Control h245Control;
 621 } H323_UU_PDU;
 622
 623 typedef struct H323_UserInformation {   /* SEQUENCE */
 624         enum {
 625                 eH323_UserInformation_user_data = (1 << 31),
 626         } options;
 627         H323_UU_PDU h323_uu_pdu;
 628 } H323_UserInformation;
 629
 630 typedef struct GatekeeperRequest {      /* SEQUENCE */
 631         enum {
 632                 eGatekeeperRequest_nonStandardData = (1 << 31),
 633                 eGatekeeperRequest_gatekeeperIdentifier = (1 << 30),
 634                 eGatekeeperRequest_callServices = (1 << 29),
 635                 eGatekeeperRequest_endpointAlias = (1 << 28),
 636                 eGatekeeperRequest_alternateEndpoints = (1 << 27),
 637                 eGatekeeperRequest_tokens = (1 << 26),
 638                 eGatekeeperRequest_cryptoTokens = (1 << 25),
 639                 eGatekeeperRequest_authenticationCapability = (1 << 24),
 640                 eGatekeeperRequest_algorithmOIDs = (1 << 23),
 641                 eGatekeeperRequest_integrity = (1 << 22),
 642                 eGatekeeperRequest_integrityCheckValue = (1 << 21),
 643                 eGatekeeperRequest_supportsAltGK = (1 << 20),
 644                 eGatekeeperRequest_featureSet = (1 << 19),
 645                 eGatekeeperRequest_genericData = (1 << 18),
 646         } options;
 647         TransportAddress rasAddress;
 648 } GatekeeperRequest;
 649
 650 typedef struct GatekeeperConfirm {      /* SEQUENCE */
 651         enum {
 652                 eGatekeeperConfirm_nonStandardData = (1 << 31),
 653                 eGatekeeperConfirm_gatekeeperIdentifier = (1 << 30),
 654                 eGatekeeperConfirm_alternateGatekeeper = (1 << 29),
 655                 eGatekeeperConfirm_authenticationMode = (1 << 28),
 656                 eGatekeeperConfirm_tokens = (1 << 27),
 657                 eGatekeeperConfirm_cryptoTokens = (1 << 26),
 658                 eGatekeeperConfirm_algorithmOID = (1 << 25),
 659                 eGatekeeperConfirm_integrity = (1 << 24),
 660                 eGatekeeperConfirm_integrityCheckValue = (1 << 23),
 661                 eGatekeeperConfirm_featureSet = (1 << 22),
 662                 eGatekeeperConfirm_genericData = (1 << 21),
 663         } options;
 664         TransportAddress rasAddress;
 665 } GatekeeperConfirm;
 666
 667 typedef struct RegistrationRequest_callSignalAddress {  /* SEQUENCE OF */
 668         int count;
 669         TransportAddress item[10];
 670 } RegistrationRequest_callSignalAddress;
 671
 672 typedef struct RegistrationRequest_rasAddress { /* SEQUENCE OF */
 673         int count;
 674         TransportAddress item[10];
 675 } RegistrationRequest_rasAddress;
 676
 677 typedef struct RegistrationRequest {    /* SEQUENCE */
 678         enum {
 679                 eRegistrationRequest_nonStandardData = (1 << 31),
 680                 eRegistrationRequest_terminalAlias = (1 << 30),
 681                 eRegistrationRequest_gatekeeperIdentifier = (1 << 29),
 682                 eRegistrationRequest_alternateEndpoints = (1 << 28),
 683                 eRegistrationRequest_timeToLive = (1 << 27),
 684                 eRegistrationRequest_tokens = (1 << 26),
 685                 eRegistrationRequest_cryptoTokens = (1 << 25),
 686                 eRegistrationRequest_integrityCheckValue = (1 << 24),
 687                 eRegistrationRequest_keepAlive = (1 << 23),
 688                 eRegistrationRequest_endpointIdentifier = (1 << 22),
 689                 eRegistrationRequest_willSupplyUUIEs = (1 << 21),
 690                 eRegistrationRequest_maintainConnection = (1 << 20),
 691                 eRegistrationRequest_alternateTransportAddresses = (1 << 19),
 692                 eRegistrationRequest_additiveRegistration = (1 << 18),
 693                 eRegistrationRequest_terminalAliasPattern = (1 << 17),
 694                 eRegistrationRequest_supportsAltGK = (1 << 16),
 695                 eRegistrationRequest_usageReportingCapability = (1 << 15),
 696                 eRegistrationRequest_multipleCalls = (1 << 14),
 697                 eRegistrationRequest_supportedH248Packages = (1 << 13),
 698                 eRegistrationRequest_callCreditCapability = (1 << 12),
 699                 eRegistrationRequest_capacityReportingCapability = (1 << 11),
 700                 eRegistrationRequest_capacity = (1 << 10),
 701                 eRegistrationRequest_featureSet = (1 << 9),
 702                 eRegistrationRequest_genericData = (1 << 8),
 703         } options;
 704         RegistrationRequest_callSignalAddress callSignalAddress;
 705         RegistrationRequest_rasAddress rasAddress;
 706         unsigned timeToLive;
 707 } RegistrationRequest;
 708
 709 typedef struct RegistrationConfirm_callSignalAddress {  /* SEQUENCE OF */
 710         int count;
 711         TransportAddress item[10];
 712 } RegistrationConfirm_callSignalAddress;
 713
 714 typedef struct RegistrationConfirm {    /* SEQUENCE */
 715         enum {
 716                 eRegistrationConfirm_nonStandardData = (1 << 31),
 717                 eRegistrationConfirm_terminalAlias = (1 << 30),
 718                 eRegistrationConfirm_gatekeeperIdentifier = (1 << 29),
 719                 eRegistrationConfirm_alternateGatekeeper = (1 << 28),
 720                 eRegistrationConfirm_timeToLive = (1 << 27),
 721                 eRegistrationConfirm_tokens = (1 << 26),
 722                 eRegistrationConfirm_cryptoTokens = (1 << 25),
 723                 eRegistrationConfirm_integrityCheckValue = (1 << 24),
 724                 eRegistrationConfirm_willRespondToIRR = (1 << 23),
 725                 eRegistrationConfirm_preGrantedARQ = (1 << 22),
 726                 eRegistrationConfirm_maintainConnection = (1 << 21),
 727                 eRegistrationConfirm_serviceControl = (1 << 20),
 728                 eRegistrationConfirm_supportsAdditiveRegistration = (1 << 19),
 729                 eRegistrationConfirm_terminalAliasPattern = (1 << 18),
 730                 eRegistrationConfirm_supportedPrefixes = (1 << 17),
 731                 eRegistrationConfirm_usageSpec = (1 << 16),
 732                 eRegistrationConfirm_featureServerAlias = (1 << 15),
 733                 eRegistrationConfirm_capacityReportingSpec = (1 << 14),
 734                 eRegistrationConfirm_featureSet = (1 << 13),
 735                 eRegistrationConfirm_genericData = (1 << 12),
 736         } options;
 737         RegistrationConfirm_callSignalAddress callSignalAddress;
 738         unsigned timeToLive;
 739 } RegistrationConfirm;
 740
 741 typedef struct UnregistrationRequest_callSignalAddress {        /* SEQUENCE OF */
 742         int count;
 743         TransportAddress item[10];
 744 } UnregistrationRequest_callSignalAddress;
 745
 746 typedef struct UnregistrationRequest {  /* SEQUENCE */
 747         enum {
 748                 eUnregistrationRequest_endpointAlias = (1 << 31),
 749                 eUnregistrationRequest_nonStandardData = (1 << 30),
 750                 eUnregistrationRequest_endpointIdentifier = (1 << 29),
 751                 eUnregistrationRequest_alternateEndpoints = (1 << 28),
 752                 eUnregistrationRequest_gatekeeperIdentifier = (1 << 27),
 753                 eUnregistrationRequest_tokens = (1 << 26),
 754                 eUnregistrationRequest_cryptoTokens = (1 << 25),
 755                 eUnregistrationRequest_integrityCheckValue = (1 << 24),
 756                 eUnregistrationRequest_reason = (1 << 23),
 757                 eUnregistrationRequest_endpointAliasPattern = (1 << 22),
 758                 eUnregistrationRequest_supportedPrefixes = (1 << 21),
 759                 eUnregistrationRequest_alternateGatekeeper = (1 << 20),
 760                 eUnregistrationRequest_genericData = (1 << 19),
 761         } options;
 762         UnregistrationRequest_callSignalAddress callSignalAddress;
 763 } UnregistrationRequest;
 764
 765 typedef struct AdmissionRequest {       /* SEQUENCE */
 766         enum {
 767                 eAdmissionRequest_callModel = (1 << 31),
 768                 eAdmissionRequest_destinationInfo = (1 << 30),
 769                 eAdmissionRequest_destCallSignalAddress = (1 << 29),
 770                 eAdmissionRequest_destExtraCallInfo = (1 << 28),
 771                 eAdmissionRequest_srcCallSignalAddress = (1 << 27),
 772                 eAdmissionRequest_nonStandardData = (1 << 26),
 773                 eAdmissionRequest_callServices = (1 << 25),
 774                 eAdmissionRequest_canMapAlias = (1 << 24),
 775                 eAdmissionRequest_callIdentifier = (1 << 23),
 776                 eAdmissionRequest_srcAlternatives = (1 << 22),
 777                 eAdmissionRequest_destAlternatives = (1 << 21),
 778                 eAdmissionRequest_gatekeeperIdentifier = (1 << 20),
 779                 eAdmissionRequest_tokens = (1 << 19),
 780                 eAdmissionRequest_cryptoTokens = (1 << 18),
 781                 eAdmissionRequest_integrityCheckValue = (1 << 17),
 782                 eAdmissionRequest_transportQOS = (1 << 16),
 783                 eAdmissionRequest_willSupplyUUIEs = (1 << 15),
 784                 eAdmissionRequest_callLinkage = (1 << 14),
 785                 eAdmissionRequest_gatewayDataRate = (1 << 13),
 786                 eAdmissionRequest_capacity = (1 << 12),
 787                 eAdmissionRequest_circuitInfo = (1 << 11),
 788                 eAdmissionRequest_desiredProtocols = (1 << 10),
 789                 eAdmissionRequest_desiredTunnelledProtocol = (1 << 9),
 790                 eAdmissionRequest_featureSet = (1 << 8),
 791                 eAdmissionRequest_genericData = (1 << 7),
 792         } options;
 793         TransportAddress destCallSignalAddress;
 794         TransportAddress srcCallSignalAddress;
 795 } AdmissionRequest;
 796
 797 typedef struct AdmissionConfirm {       /* SEQUENCE */
 798         enum {
 799                 eAdmissionConfirm_irrFrequency = (1 << 31),
 800                 eAdmissionConfirm_nonStandardData = (1 << 30),
 801                 eAdmissionConfirm_destinationInfo = (1 << 29),
 802                 eAdmissionConfirm_destExtraCallInfo = (1 << 28),
 803                 eAdmissionConfirm_destinationType = (1 << 27),
 804                 eAdmissionConfirm_remoteExtensionAddress = (1 << 26),
 805                 eAdmissionConfirm_alternateEndpoints = (1 << 25),
 806                 eAdmissionConfirm_tokens = (1 << 24),
 807                 eAdmissionConfirm_cryptoTokens = (1 << 23),
 808                 eAdmissionConfirm_integrityCheckValue = (1 << 22),
 809                 eAdmissionConfirm_transportQOS = (1 << 21),
 810                 eAdmissionConfirm_willRespondToIRR = (1 << 20),
 811                 eAdmissionConfirm_uuiesRequested = (1 << 19),
 812                 eAdmissionConfirm_language = (1 << 18),
 813                 eAdmissionConfirm_alternateTransportAddresses = (1 << 17),
 814                 eAdmissionConfirm_useSpecifiedTransport = (1 << 16),
 815                 eAdmissionConfirm_circuitInfo = (1 << 15),
 816                 eAdmissionConfirm_usageSpec = (1 << 14),
 817                 eAdmissionConfirm_supportedProtocols = (1 << 13),
 818                 eAdmissionConfirm_serviceControl = (1 << 12),
 819                 eAdmissionConfirm_multipleCalls = (1 << 11),
 820                 eAdmissionConfirm_featureSet = (1 << 10),
 821                 eAdmissionConfirm_genericData = (1 << 9),
 822         } options;
 823         TransportAddress destCallSignalAddress;
 824 } AdmissionConfirm;
 825
 826 typedef struct LocationRequest {        /* SEQUENCE */
 827         enum {
 828                 eLocationRequest_endpointIdentifier = (1 << 31),
 829                 eLocationRequest_nonStandardData = (1 << 30),
 830                 eLocationRequest_sourceInfo = (1 << 29),
 831                 eLocationRequest_canMapAlias = (1 << 28),
 832                 eLocationRequest_gatekeeperIdentifier = (1 << 27),
 833                 eLocationRequest_tokens = (1 << 26),
 834                 eLocationRequest_cryptoTokens = (1 << 25),
 835                 eLocationRequest_integrityCheckValue = (1 << 24),
 836                 eLocationRequest_desiredProtocols = (1 << 23),
 837                 eLocationRequest_desiredTunnelledProtocol = (1 << 22),
 838                 eLocationRequest_featureSet = (1 << 21),
 839                 eLocationRequest_genericData = (1 << 20),
 840                 eLocationRequest_hopCount = (1 << 19),
 841                 eLocationRequest_circuitInfo = (1 << 18),
 842         } options;
 843         TransportAddress replyAddress;
 844 } LocationRequest;
 845
 846 typedef struct LocationConfirm {        /* SEQUENCE */
 847         enum {
 848                 eLocationConfirm_nonStandardData = (1 << 31),
 849                 eLocationConfirm_destinationInfo = (1 << 30),
 850                 eLocationConfirm_destExtraCallInfo = (1 << 29),
 851                 eLocationConfirm_destinationType = (1 << 28),
 852                 eLocationConfirm_remoteExtensionAddress = (1 << 27),
 853                 eLocationConfirm_alternateEndpoints = (1 << 26),
 854                 eLocationConfirm_tokens = (1 << 25),
 855                 eLocationConfirm_cryptoTokens = (1 << 24),
 856                 eLocationConfirm_integrityCheckValue = (1 << 23),
 857                 eLocationConfirm_alternateTransportAddresses = (1 << 22),
 858                 eLocationConfirm_supportedProtocols = (1 << 21),
 859                 eLocationConfirm_multipleCalls = (1 << 20),
 860                 eLocationConfirm_featureSet = (1 << 19),
 861                 eLocationConfirm_genericData = (1 << 18),
 862                 eLocationConfirm_circuitInfo = (1 << 17),
 863                 eLocationConfirm_serviceControl = (1 << 16),
 864         } options;
 865         TransportAddress callSignalAddress;
 866         TransportAddress rasAddress;
 867 } LocationConfirm;
 868
 869 typedef struct InfoRequestResponse_callSignalAddress {  /* SEQUENCE OF */
 870         int count;
 871         TransportAddress item[10];
 872 } InfoRequestResponse_callSignalAddress;
 873
 874 typedef struct InfoRequestResponse {    /* SEQUENCE */
 875         enum {
 876                 eInfoRequestResponse_nonStandardData = (1 << 31),
 877                 eInfoRequestResponse_endpointAlias = (1 << 30),
 878                 eInfoRequestResponse_perCallInfo = (1 << 29),
 879                 eInfoRequestResponse_tokens = (1 << 28),
 880                 eInfoRequestResponse_cryptoTokens = (1 << 27),
 881                 eInfoRequestResponse_integrityCheckValue = (1 << 26),
 882                 eInfoRequestResponse_needResponse = (1 << 25),
 883                 eInfoRequestResponse_capacity = (1 << 24),
 884                 eInfoRequestResponse_irrStatus = (1 << 23),
 885                 eInfoRequestResponse_unsolicited = (1 << 22),
 886                 eInfoRequestResponse_genericData = (1 << 21),
 887         } options;
 888         TransportAddress rasAddress;
 889         InfoRequestResponse_callSignalAddress callSignalAddress;
 890 } InfoRequestResponse;
 891
 892 typedef struct RasMessage {     /* CHOICE */
 893         enum {
 894                 eRasMessage_gatekeeperRequest,
 895                 eRasMessage_gatekeeperConfirm,
 896                 eRasMessage_gatekeeperReject,
 897                 eRasMessage_registrationRequest,
 898                 eRasMessage_registrationConfirm,
 899                 eRasMessage_registrationReject,
 900                 eRasMessage_unregistrationRequest,
 901                 eRasMessage_unregistrationConfirm,
 902                 eRasMessage_unregistrationReject,
 903                 eRasMessage_admissionRequest,
 904                 eRasMessage_admissionConfirm,
 905                 eRasMessage_admissionReject,
 906                 eRasMessage_bandwidthRequest,
 907                 eRasMessage_bandwidthConfirm,
 908                 eRasMessage_bandwidthReject,
 909                 eRasMessage_disengageRequest,
 910                 eRasMessage_disengageConfirm,
 911                 eRasMessage_disengageReject,
 912                 eRasMessage_locationRequest,
 913                 eRasMessage_locationConfirm,
 914                 eRasMessage_locationReject,
 915                 eRasMessage_infoRequest,
 916                 eRasMessage_infoRequestResponse,
 917                 eRasMessage_nonStandardMessage,
 918                 eRasMessage_unknownMessageResponse,
 919                 eRasMessage_requestInProgress,
 920                 eRasMessage_resourcesAvailableIndicate,
 921                 eRasMessage_resourcesAvailableConfirm,
 922                 eRasMessage_infoRequestAck,
 923                 eRasMessage_infoRequestNak,
 924                 eRasMessage_serviceControlIndication,
 925                 eRasMessage_serviceControlResponse,
 926         } choice;
 927         union {
 928                 GatekeeperRequest gatekeeperRequest;
 929                 GatekeeperConfirm gatekeeperConfirm;
 930                 RegistrationRequest registrationRequest;
 931                 RegistrationConfirm registrationConfirm;
 932                 UnregistrationRequest unregistrationRequest;
 933                 AdmissionRequest admissionRequest;
 934                 AdmissionConfirm admissionConfirm;
 935                 LocationRequest locationRequest;
 936                 LocationConfirm locationConfirm;
 937                 InfoRequestResponse infoRequestResponse;
 938         };
 939 } RasMessage;