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