include/linux/netfilter/nf_conntrack_h323_types.h

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