include/linux/netfilter_ipv4/ip_conntrack_helper_h323_types.h

   1 /* Generated by Jing Min Zhao's ASN.1 parser, Mar 15 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         FacilityReason reason;
 416         TransportAddress h245Address;
 417         Facility_UUIE_fastStart fastStart;
 418 } Facility_UUIE;
 419
 420 typedef struct Progress_UUIE_fastStart {        /* SEQUENCE OF */
 421         int count;
 422         OpenLogicalChannel item[30];
 423 } Progress_UUIE_fastStart;
 424
 425 typedef struct Progress_UUIE {  /* SEQUENCE */
 426         enum {
 427                 eProgress_UUIE_h245Address = (1 << 31),
 428                 eProgress_UUIE_h245SecurityMode = (1 << 30),
 429                 eProgress_UUIE_tokens = (1 << 29),
 430                 eProgress_UUIE_cryptoTokens = (1 << 28),
 431                 eProgress_UUIE_fastStart = (1 << 27),
 432                 eProgress_UUIE_multipleCalls = (1 << 26),
 433                 eProgress_UUIE_maintainConnection = (1 << 25),
 434                 eProgress_UUIE_fastConnectRefused = (1 << 24),
 435         } options;
 436         TransportAddress h245Address;
 437         Progress_UUIE_fastStart fastStart;
 438 } Progress_UUIE;
 439
 440 typedef struct H323_UU_PDU_h323_message_body {  /* CHOICE */
 441         enum {
 442                 eH323_UU_PDU_h323_message_body_setup,
 443                 eH323_UU_PDU_h323_message_body_callProceeding,
 444                 eH323_UU_PDU_h323_message_body_connect,
 445                 eH323_UU_PDU_h323_message_body_alerting,
 446                 eH323_UU_PDU_h323_message_body_information,
 447                 eH323_UU_PDU_h323_message_body_releaseComplete,
 448                 eH323_UU_PDU_h323_message_body_facility,
 449                 eH323_UU_PDU_h323_message_body_progress,
 450                 eH323_UU_PDU_h323_message_body_empty,
 451                 eH323_UU_PDU_h323_message_body_status,
 452                 eH323_UU_PDU_h323_message_body_statusInquiry,
 453                 eH323_UU_PDU_h323_message_body_setupAcknowledge,
 454                 eH323_UU_PDU_h323_message_body_notify,
 455         } choice;
 456         union {
 457                 Setup_UUIE setup;
 458                 CallProceeding_UUIE callProceeding;
 459                 Connect_UUIE connect;
 460                 Alerting_UUIE alerting;
 461                 Information_UUIE information;
 462                 Facility_UUIE facility;
 463                 Progress_UUIE progress;
 464         };
 465 } H323_UU_PDU_h323_message_body;
 466
 467 typedef struct RequestMessage { /* CHOICE */
 468         enum {
 469                 eRequestMessage_nonStandard,
 470                 eRequestMessage_masterSlaveDetermination,
 471                 eRequestMessage_terminalCapabilitySet,
 472                 eRequestMessage_openLogicalChannel,
 473                 eRequestMessage_closeLogicalChannel,
 474                 eRequestMessage_requestChannelClose,
 475                 eRequestMessage_multiplexEntrySend,
 476                 eRequestMessage_requestMultiplexEntry,
 477                 eRequestMessage_requestMode,
 478                 eRequestMessage_roundTripDelayRequest,
 479                 eRequestMessage_maintenanceLoopRequest,
 480                 eRequestMessage_communicationModeRequest,
 481                 eRequestMessage_conferenceRequest,
 482                 eRequestMessage_multilinkRequest,
 483                 eRequestMessage_logicalChannelRateRequest,
 484         } choice;
 485         union {
 486                 OpenLogicalChannel openLogicalChannel;
 487         };
 488 } RequestMessage;
 489
 490 typedef struct OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters {      /* CHOICE */
 491         enum {
 492                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h222LogicalChannelParameters,
 493                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters,
 494         } choice;
 495         union {
 496                 H2250LogicalChannelParameters h2250LogicalChannelParameters;
 497         };
 498 } OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters;
 499
 500 typedef struct OpenLogicalChannelAck_reverseLogicalChannelParameters {  /* SEQUENCE */
 501         enum {
 502                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_portNumber
 503                     = (1 << 31),
 504                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters
 505                     = (1 << 30),
 506                 eOpenLogicalChannelAck_reverseLogicalChannelParameters_replacementFor
 507                     = (1 << 29),
 508         } options;
 509         OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters
 510             multiplexParameters;
 511 } OpenLogicalChannelAck_reverseLogicalChannelParameters;
 512
 513 typedef struct H2250LogicalChannelAckParameters {       /* SEQUENCE */
 514         enum {
 515                 eH2250LogicalChannelAckParameters_nonStandard = (1 << 31),
 516                 eH2250LogicalChannelAckParameters_sessionID = (1 << 30),
 517                 eH2250LogicalChannelAckParameters_mediaChannel = (1 << 29),
 518                 eH2250LogicalChannelAckParameters_mediaControlChannel =
 519                     (1 << 28),
 520                 eH2250LogicalChannelAckParameters_dynamicRTPPayloadType =
 521                     (1 << 27),
 522                 eH2250LogicalChannelAckParameters_flowControlToZero =
 523                     (1 << 26),
 524                 eH2250LogicalChannelAckParameters_portNumber = (1 << 25),
 525         } options;
 526         H245_TransportAddress mediaChannel;
 527         H245_TransportAddress mediaControlChannel;
 528 } H2250LogicalChannelAckParameters;
 529
 530 typedef struct OpenLogicalChannelAck_forwardMultiplexAckParameters {    /* CHOICE */
 531         enum {
 532                 eOpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters,
 533         } choice;
 534         union {
 535                 H2250LogicalChannelAckParameters
 536                     h2250LogicalChannelAckParameters;
 537         };
 538 } OpenLogicalChannelAck_forwardMultiplexAckParameters;
 539
 540 typedef struct OpenLogicalChannelAck {  /* SEQUENCE */
 541         enum {
 542                 eOpenLogicalChannelAck_reverseLogicalChannelParameters =
 543                     (1 << 31),
 544                 eOpenLogicalChannelAck_separateStack = (1 << 30),
 545                 eOpenLogicalChannelAck_forwardMultiplexAckParameters =
 546                     (1 << 29),
 547                 eOpenLogicalChannelAck_encryptionSync = (1 << 28),
 548         } options;
 549         OpenLogicalChannelAck_reverseLogicalChannelParameters
 550             reverseLogicalChannelParameters;
 551         OpenLogicalChannelAck_forwardMultiplexAckParameters
 552             forwardMultiplexAckParameters;
 553 } OpenLogicalChannelAck;
 554
 555 typedef struct ResponseMessage {        /* CHOICE */
 556         enum {
 557                 eResponseMessage_nonStandard,
 558                 eResponseMessage_masterSlaveDeterminationAck,
 559                 eResponseMessage_masterSlaveDeterminationReject,
 560                 eResponseMessage_terminalCapabilitySetAck,
 561                 eResponseMessage_terminalCapabilitySetReject,
 562                 eResponseMessage_openLogicalChannelAck,
 563                 eResponseMessage_openLogicalChannelReject,
 564                 eResponseMessage_closeLogicalChannelAck,
 565                 eResponseMessage_requestChannelCloseAck,
 566                 eResponseMessage_requestChannelCloseReject,
 567                 eResponseMessage_multiplexEntrySendAck,
 568                 eResponseMessage_multiplexEntrySendReject,
 569                 eResponseMessage_requestMultiplexEntryAck,
 570                 eResponseMessage_requestMultiplexEntryReject,
 571                 eResponseMessage_requestModeAck,
 572                 eResponseMessage_requestModeReject,
 573                 eResponseMessage_roundTripDelayResponse,
 574                 eResponseMessage_maintenanceLoopAck,
 575                 eResponseMessage_maintenanceLoopReject,
 576                 eResponseMessage_communicationModeResponse,
 577                 eResponseMessage_conferenceResponse,
 578                 eResponseMessage_multilinkResponse,
 579                 eResponseMessage_logicalChannelRateAcknowledge,
 580                 eResponseMessage_logicalChannelRateReject,
 581         } choice;
 582         union {
 583                 OpenLogicalChannelAck openLogicalChannelAck;
 584         };
 585 } ResponseMessage;
 586
 587 typedef struct MultimediaSystemControlMessage { /* CHOICE */
 588         enum {
 589                 eMultimediaSystemControlMessage_request,
 590                 eMultimediaSystemControlMessage_response,
 591                 eMultimediaSystemControlMessage_command,
 592                 eMultimediaSystemControlMessage_indication,
 593         } choice;
 594         union {
 595                 RequestMessage request;
 596                 ResponseMessage response;
 597         };
 598 } MultimediaSystemControlMessage;
 599
 600 typedef struct H323_UU_PDU_h245Control {        /* SEQUENCE OF */
 601         int count;
 602         MultimediaSystemControlMessage item[4];
 603 } H323_UU_PDU_h245Control;
 604
 605 typedef struct H323_UU_PDU {    /* SEQUENCE */
 606         enum {
 607                 eH323_UU_PDU_nonStandardData = (1 << 31),
 608                 eH323_UU_PDU_h4501SupplementaryService = (1 << 30),
 609                 eH323_UU_PDU_h245Tunneling = (1 << 29),
 610                 eH323_UU_PDU_h245Control = (1 << 28),
 611                 eH323_UU_PDU_nonStandardControl = (1 << 27),
 612                 eH323_UU_PDU_callLinkage = (1 << 26),
 613                 eH323_UU_PDU_tunnelledSignallingMessage = (1 << 25),
 614                 eH323_UU_PDU_provisionalRespToH245Tunneling = (1 << 24),
 615                 eH323_UU_PDU_stimulusControl = (1 << 23),
 616                 eH323_UU_PDU_genericData = (1 << 22),
 617         } options;
 618         H323_UU_PDU_h323_message_body h323_message_body;
 619         H323_UU_PDU_h245Control h245Control;
 620 } H323_UU_PDU;
 621
 622 typedef struct H323_UserInformation {   /* SEQUENCE */
 623         enum {
 624                 eH323_UserInformation_user_data = (1 << 31),
 625         } options;
 626         H323_UU_PDU h323_uu_pdu;
 627 } H323_UserInformation;
 628
 629 typedef struct GatekeeperRequest {      /* SEQUENCE */
 630         enum {
 631                 eGatekeeperRequest_nonStandardData = (1 << 31),
 632                 eGatekeeperRequest_gatekeeperIdentifier = (1 << 30),
 633                 eGatekeeperRequest_callServices = (1 << 29),
 634                 eGatekeeperRequest_endpointAlias = (1 << 28),
 635                 eGatekeeperRequest_alternateEndpoints = (1 << 27),
 636                 eGatekeeperRequest_tokens = (1 << 26),
 637                 eGatekeeperRequest_cryptoTokens = (1 << 25),
 638                 eGatekeeperRequest_authenticationCapability = (1 << 24),
 639                 eGatekeeperRequest_algorithmOIDs = (1 << 23),
 640                 eGatekeeperRequest_integrity = (1 << 22),
 641                 eGatekeeperRequest_integrityCheckValue = (1 << 21),
 642                 eGatekeeperRequest_supportsAltGK = (1 << 20),
 643                 eGatekeeperRequest_featureSet = (1 << 19),
 644                 eGatekeeperRequest_genericData = (1 << 18),
 645         } options;
 646         TransportAddress rasAddress;
 647 } GatekeeperRequest;
 648
 649 typedef struct GatekeeperConfirm {      /* SEQUENCE */
 650         enum {
 651                 eGatekeeperConfirm_nonStandardData = (1 << 31),
 652                 eGatekeeperConfirm_gatekeeperIdentifier = (1 << 30),
 653                 eGatekeeperConfirm_alternateGatekeeper = (1 << 29),
 654                 eGatekeeperConfirm_authenticationMode = (1 << 28),
 655                 eGatekeeperConfirm_tokens = (1 << 27),
 656                 eGatekeeperConfirm_cryptoTokens = (1 << 26),
 657                 eGatekeeperConfirm_algorithmOID = (1 << 25),
 658                 eGatekeeperConfirm_integrity = (1 << 24),
 659                 eGatekeeperConfirm_integrityCheckValue = (1 << 23),
 660                 eGatekeeperConfirm_featureSet = (1 << 22),
 661                 eGatekeeperConfirm_genericData = (1 << 21),
 662         } options;
 663         TransportAddress rasAddress;
 664 } GatekeeperConfirm;
 665
 666 typedef struct RegistrationRequest_callSignalAddress {  /* SEQUENCE OF */
 667         int count;
 668         TransportAddress item[10];
 669 } RegistrationRequest_callSignalAddress;
 670
 671 typedef struct RegistrationRequest_rasAddress { /* SEQUENCE OF */
 672         int count;
 673         TransportAddress item[10];
 674 } RegistrationRequest_rasAddress;
 675
 676 typedef struct RegistrationRequest {    /* SEQUENCE */
 677         enum {
 678                 eRegistrationRequest_nonStandardData = (1 << 31),
 679                 eRegistrationRequest_terminalAlias = (1 << 30),
 680                 eRegistrationRequest_gatekeeperIdentifier = (1 << 29),
 681                 eRegistrationRequest_alternateEndpoints = (1 << 28),
 682                 eRegistrationRequest_timeToLive = (1 << 27),
 683                 eRegistrationRequest_tokens = (1 << 26),
 684                 eRegistrationRequest_cryptoTokens = (1 << 25),
 685                 eRegistrationRequest_integrityCheckValue = (1 << 24),
 686                 eRegistrationRequest_keepAlive = (1 << 23),
 687                 eRegistrationRequest_endpointIdentifier = (1 << 22),
 688                 eRegistrationRequest_willSupplyUUIEs = (1 << 21),
 689                 eRegistrationRequest_maintainConnection = (1 << 20),
 690                 eRegistrationRequest_alternateTransportAddresses = (1 << 19),
 691                 eRegistrationRequest_additiveRegistration = (1 << 18),
 692                 eRegistrationRequest_terminalAliasPattern = (1 << 17),
 693                 eRegistrationRequest_supportsAltGK = (1 << 16),
 694                 eRegistrationRequest_usageReportingCapability = (1 << 15),
 695                 eRegistrationRequest_multipleCalls = (1 << 14),
 696                 eRegistrationRequest_supportedH248Packages = (1 << 13),
 697                 eRegistrationRequest_callCreditCapability = (1 << 12),
 698                 eRegistrationRequest_capacityReportingCapability = (1 << 11),
 699                 eRegistrationRequest_capacity = (1 << 10),
 700                 eRegistrationRequest_featureSet = (1 << 9),
 701                 eRegistrationRequest_genericData = (1 << 8),
 702         } options;
 703         RegistrationRequest_callSignalAddress callSignalAddress;
 704         RegistrationRequest_rasAddress rasAddress;
 705         unsigned timeToLive;
 706 } RegistrationRequest;
 707
 708 typedef struct RegistrationConfirm_callSignalAddress {  /* SEQUENCE OF */
 709         int count;
 710         TransportAddress item[10];
 711 } RegistrationConfirm_callSignalAddress;
 712
 713 typedef struct RegistrationConfirm {    /* SEQUENCE */
 714         enum {
 715                 eRegistrationConfirm_nonStandardData = (1 << 31),
 716                 eRegistrationConfirm_terminalAlias = (1 << 30),
 717                 eRegistrationConfirm_gatekeeperIdentifier = (1 << 29),
 718                 eRegistrationConfirm_alternateGatekeeper = (1 << 28),
 719                 eRegistrationConfirm_timeToLive = (1 << 27),
 720                 eRegistrationConfirm_tokens = (1 << 26),
 721                 eRegistrationConfirm_cryptoTokens = (1 << 25),
 722                 eRegistrationConfirm_integrityCheckValue = (1 << 24),
 723                 eRegistrationConfirm_willRespondToIRR = (1 << 23),
 724                 eRegistrationConfirm_preGrantedARQ = (1 << 22),
 725                 eRegistrationConfirm_maintainConnection = (1 << 21),
 726                 eRegistrationConfirm_serviceControl = (1 << 20),
 727                 eRegistrationConfirm_supportsAdditiveRegistration = (1 << 19),
 728                 eRegistrationConfirm_terminalAliasPattern = (1 << 18),
 729                 eRegistrationConfirm_supportedPrefixes = (1 << 17),
 730                 eRegistrationConfirm_usageSpec = (1 << 16),
 731                 eRegistrationConfirm_featureServerAlias = (1 << 15),
 732                 eRegistrationConfirm_capacityReportingSpec = (1 << 14),
 733                 eRegistrationConfirm_featureSet = (1 << 13),
 734                 eRegistrationConfirm_genericData = (1 << 12),
 735         } options;
 736         RegistrationConfirm_callSignalAddress callSignalAddress;
 737         unsigned timeToLive;
 738 } RegistrationConfirm;
 739
 740 typedef struct UnregistrationRequest_callSignalAddress {        /* SEQUENCE OF */
 741         int count;
 742         TransportAddress item[10];
 743 } UnregistrationRequest_callSignalAddress;
 744
 745 typedef struct UnregistrationRequest {  /* SEQUENCE */
 746         enum {
 747                 eUnregistrationRequest_endpointAlias = (1 << 31),
 748                 eUnregistrationRequest_nonStandardData = (1 << 30),
 749                 eUnregistrationRequest_endpointIdentifier = (1 << 29),
 750                 eUnregistrationRequest_alternateEndpoints = (1 << 28),
 751                 eUnregistrationRequest_gatekeeperIdentifier = (1 << 27),
 752                 eUnregistrationRequest_tokens = (1 << 26),
 753                 eUnregistrationRequest_cryptoTokens = (1 << 25),
 754                 eUnregistrationRequest_integrityCheckValue = (1 << 24),
 755                 eUnregistrationRequest_reason = (1 << 23),
 756                 eUnregistrationRequest_endpointAliasPattern = (1 << 22),
 757                 eUnregistrationRequest_supportedPrefixes = (1 << 21),
 758                 eUnregistrationRequest_alternateGatekeeper = (1 << 20),
 759                 eUnregistrationRequest_genericData = (1 << 19),
 760         } options;
 761         UnregistrationRequest_callSignalAddress callSignalAddress;
 762 } UnregistrationRequest;
 763
 764 typedef struct AdmissionRequest {       /* SEQUENCE */
 765         enum {
 766                 eAdmissionRequest_callModel = (1 << 31),
 767                 eAdmissionRequest_destinationInfo = (1 << 30),
 768                 eAdmissionRequest_destCallSignalAddress = (1 << 29),
 769                 eAdmissionRequest_destExtraCallInfo = (1 << 28),
 770                 eAdmissionRequest_srcCallSignalAddress = (1 << 27),
 771                 eAdmissionRequest_nonStandardData = (1 << 26),
 772                 eAdmissionRequest_callServices = (1 << 25),
 773                 eAdmissionRequest_canMapAlias = (1 << 24),
 774                 eAdmissionRequest_callIdentifier = (1 << 23),
 775                 eAdmissionRequest_srcAlternatives = (1 << 22),
 776                 eAdmissionRequest_destAlternatives = (1 << 21),
 777                 eAdmissionRequest_gatekeeperIdentifier = (1 << 20),
 778                 eAdmissionRequest_tokens = (1 << 19),
 779                 eAdmissionRequest_cryptoTokens = (1 << 18),
 780                 eAdmissionRequest_integrityCheckValue = (1 << 17),
 781                 eAdmissionRequest_transportQOS = (1 << 16),
 782                 eAdmissionRequest_willSupplyUUIEs = (1 << 15),
 783                 eAdmissionRequest_callLinkage = (1 << 14),
 784                 eAdmissionRequest_gatewayDataRate = (1 << 13),
 785                 eAdmissionRequest_capacity = (1 << 12),
 786                 eAdmissionRequest_circuitInfo = (1 << 11),
 787                 eAdmissionRequest_desiredProtocols = (1 << 10),
 788                 eAdmissionRequest_desiredTunnelledProtocol = (1 << 9),
 789                 eAdmissionRequest_featureSet = (1 << 8),
 790                 eAdmissionRequest_genericData = (1 << 7),
 791         } options;
 792         TransportAddress destCallSignalAddress;
 793         TransportAddress srcCallSignalAddress;
 794 } AdmissionRequest;
 795
 796 typedef struct AdmissionConfirm {       /* SEQUENCE */
 797         enum {
 798                 eAdmissionConfirm_irrFrequency = (1 << 31),
 799                 eAdmissionConfirm_nonStandardData = (1 << 30),
 800                 eAdmissionConfirm_destinationInfo = (1 << 29),
 801                 eAdmissionConfirm_destExtraCallInfo = (1 << 28),
 802                 eAdmissionConfirm_destinationType = (1 << 27),
 803                 eAdmissionConfirm_remoteExtensionAddress = (1 << 26),
 804                 eAdmissionConfirm_alternateEndpoints = (1 << 25),
 805                 eAdmissionConfirm_tokens = (1 << 24),
 806                 eAdmissionConfirm_cryptoTokens = (1 << 23),
 807                 eAdmissionConfirm_integrityCheckValue = (1 << 22),
 808                 eAdmissionConfirm_transportQOS = (1 << 21),
 809                 eAdmissionConfirm_willRespondToIRR = (1 << 20),
 810                 eAdmissionConfirm_uuiesRequested = (1 << 19),
 811                 eAdmissionConfirm_language = (1 << 18),
 812                 eAdmissionConfirm_alternateTransportAddresses = (1 << 17),
 813                 eAdmissionConfirm_useSpecifiedTransport = (1 << 16),
 814                 eAdmissionConfirm_circuitInfo = (1 << 15),
 815                 eAdmissionConfirm_usageSpec = (1 << 14),
 816                 eAdmissionConfirm_supportedProtocols = (1 << 13),
 817                 eAdmissionConfirm_serviceControl = (1 << 12),
 818                 eAdmissionConfirm_multipleCalls = (1 << 11),
 819                 eAdmissionConfirm_featureSet = (1 << 10),
 820                 eAdmissionConfirm_genericData = (1 << 9),
 821         } options;
 822         TransportAddress destCallSignalAddress;
 823 } AdmissionConfirm;
 824
 825 typedef struct LocationRequest {        /* SEQUENCE */
 826         enum {
 827                 eLocationRequest_endpointIdentifier = (1 << 31),
 828                 eLocationRequest_nonStandardData = (1 << 30),
 829                 eLocationRequest_sourceInfo = (1 << 29),
 830                 eLocationRequest_canMapAlias = (1 << 28),
 831                 eLocationRequest_gatekeeperIdentifier = (1 << 27),
 832                 eLocationRequest_tokens = (1 << 26),
 833                 eLocationRequest_cryptoTokens = (1 << 25),
 834                 eLocationRequest_integrityCheckValue = (1 << 24),
 835                 eLocationRequest_desiredProtocols = (1 << 23),
 836                 eLocationRequest_desiredTunnelledProtocol = (1 << 22),
 837                 eLocationRequest_featureSet = (1 << 21),
 838                 eLocationRequest_genericData = (1 << 20),
 839                 eLocationRequest_hopCount = (1 << 19),
 840                 eLocationRequest_circuitInfo = (1 << 18),
 841         } options;
 842         TransportAddress replyAddress;
 843 } LocationRequest;
 844
 845 typedef struct LocationConfirm {        /* SEQUENCE */
 846         enum {
 847                 eLocationConfirm_nonStandardData = (1 << 31),
 848                 eLocationConfirm_destinationInfo = (1 << 30),
 849                 eLocationConfirm_destExtraCallInfo = (1 << 29),
 850                 eLocationConfirm_destinationType = (1 << 28),
 851                 eLocationConfirm_remoteExtensionAddress = (1 << 27),
 852                 eLocationConfirm_alternateEndpoints = (1 << 26),
 853                 eLocationConfirm_tokens = (1 << 25),
 854                 eLocationConfirm_cryptoTokens = (1 << 24),
 855                 eLocationConfirm_integrityCheckValue = (1 << 23),
 856                 eLocationConfirm_alternateTransportAddresses = (1 << 22),
 857                 eLocationConfirm_supportedProtocols = (1 << 21),
 858                 eLocationConfirm_multipleCalls = (1 << 20),
 859                 eLocationConfirm_featureSet = (1 << 19),
 860                 eLocationConfirm_genericData = (1 << 18),
 861                 eLocationConfirm_circuitInfo = (1 << 17),
 862                 eLocationConfirm_serviceControl = (1 << 16),
 863         } options;
 864         TransportAddress callSignalAddress;
 865         TransportAddress rasAddress;
 866 } LocationConfirm;
 867
 868 typedef struct InfoRequestResponse_callSignalAddress {  /* SEQUENCE OF */
 869         int count;
 870         TransportAddress item[10];
 871 } InfoRequestResponse_callSignalAddress;
 872
 873 typedef struct InfoRequestResponse {    /* SEQUENCE */
 874         enum {
 875                 eInfoRequestResponse_nonStandardData = (1 << 31),
 876                 eInfoRequestResponse_endpointAlias = (1 << 30),
 877                 eInfoRequestResponse_perCallInfo = (1 << 29),
 878                 eInfoRequestResponse_tokens = (1 << 28),
 879                 eInfoRequestResponse_cryptoTokens = (1 << 27),
 880                 eInfoRequestResponse_integrityCheckValue = (1 << 26),
 881                 eInfoRequestResponse_needResponse = (1 << 25),
 882                 eInfoRequestResponse_capacity = (1 << 24),
 883                 eInfoRequestResponse_irrStatus = (1 << 23),
 884                 eInfoRequestResponse_unsolicited = (1 << 22),
 885                 eInfoRequestResponse_genericData = (1 << 21),
 886         } options;
 887         TransportAddress rasAddress;
 888         InfoRequestResponse_callSignalAddress callSignalAddress;
 889 } InfoRequestResponse;
 890
 891 typedef struct RasMessage {     /* CHOICE */
 892         enum {
 893                 eRasMessage_gatekeeperRequest,
 894                 eRasMessage_gatekeeperConfirm,
 895                 eRasMessage_gatekeeperReject,
 896                 eRasMessage_registrationRequest,
 897                 eRasMessage_registrationConfirm,
 898                 eRasMessage_registrationReject,
 899                 eRasMessage_unregistrationRequest,
 900                 eRasMessage_unregistrationConfirm,
 901                 eRasMessage_unregistrationReject,
 902                 eRasMessage_admissionRequest,
 903                 eRasMessage_admissionConfirm,
 904                 eRasMessage_admissionReject,
 905                 eRasMessage_bandwidthRequest,
 906                 eRasMessage_bandwidthConfirm,
 907                 eRasMessage_bandwidthReject,
 908                 eRasMessage_disengageRequest,
 909                 eRasMessage_disengageConfirm,
 910                 eRasMessage_disengageReject,
 911                 eRasMessage_locationRequest,
 912                 eRasMessage_locationConfirm,
 913                 eRasMessage_locationReject,
 914                 eRasMessage_infoRequest,
 915                 eRasMessage_infoRequestResponse,
 916                 eRasMessage_nonStandardMessage,
 917                 eRasMessage_unknownMessageResponse,
 918                 eRasMessage_requestInProgress,
 919                 eRasMessage_resourcesAvailableIndicate,
 920                 eRasMessage_resourcesAvailableConfirm,
 921                 eRasMessage_infoRequestAck,
 922                 eRasMessage_infoRequestNak,
 923                 eRasMessage_serviceControlIndication,
 924                 eRasMessage_serviceControlResponse,
 925         } choice;
 926         union {
 927                 GatekeeperRequest gatekeeperRequest;
 928                 GatekeeperConfirm gatekeeperConfirm;
 929                 RegistrationRequest registrationRequest;
 930                 RegistrationConfirm registrationConfirm;
 931                 UnregistrationRequest unregistrationRequest;
 932                 AdmissionRequest admissionRequest;
 933                 AdmissionConfirm admissionConfirm;
 934                 LocationRequest locationRequest;
 935                 LocationConfirm locationConfirm;
 936                 InfoRequestResponse infoRequestResponse;
 937         };
 938 } RasMessage;