summaryrefslogtreecommitdiffstats
path: root/epan/dissectors/asn1/h225
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-10 20:34:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-10 20:34:10 +0000
commite4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc (patch)
tree68cb5ef9081156392f1dd62a00c6ccc1451b93df /epan/dissectors/asn1/h225
parentInitial commit. (diff)
downloadwireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.tar.xz
wireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.zip
Adding upstream version 4.2.2.upstream/4.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--epan/dissectors/asn1/h225/CMakeLists.txt44
-rw-r--r--epan/dissectors/asn1/h225/H323-MESSAGES.asn2221
-rw-r--r--epan/dissectors/asn1/h225/h225.cnf961
-rw-r--r--epan/dissectors/asn1/h225/packet-h225-template.c1146
-rw-r--r--epan/dissectors/asn1/h225/packet-h225-template.h83
5 files changed, 4455 insertions, 0 deletions
diff --git a/epan/dissectors/asn1/h225/CMakeLists.txt b/epan/dissectors/asn1/h225/CMakeLists.txt
new file mode 100644
index 00000000..f1028240
--- /dev/null
+++ b/epan/dissectors/asn1/h225/CMakeLists.txt
@@ -0,0 +1,44 @@
+# CMakeLists.txt
+#
+# Wireshark - Network traffic analyzer
+# By Gerald Combs <gerald@wireshark.org>
+# Copyright 1998 Gerald Combs
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+
+set( PROTOCOL_NAME h225 )
+
+set( PROTO_OPT )
+
+set( EXPORT_FILES
+ ${PROTOCOL_NAME}-exp.cnf
+)
+
+set( EXT_ASN_FILE_LIST
+)
+
+set( ASN_FILE_LIST
+ H323-MESSAGES.asn
+)
+
+set( EXTRA_DIST
+ ${ASN_FILE_LIST}
+ packet-${PROTOCOL_NAME}-template.c
+ packet-${PROTOCOL_NAME}-template.h
+ ${PROTOCOL_NAME}.cnf
+)
+
+set( SRC_FILES
+ ${EXTRA_DIST}
+ ${EXT_ASN_FILE_LIST}
+)
+
+set( A2W_FLAGS )
+
+set( EXTRA_CNF
+ "${CMAKE_CURRENT_BINARY_DIR}/../h235/h235-exp.cnf"
+ "${CMAKE_CURRENT_BINARY_DIR}/../h245/h245-exp.cnf"
+)
+
+ASN2WRS()
diff --git a/epan/dissectors/asn1/h225/H323-MESSAGES.asn b/epan/dissectors/asn1/h225/H323-MESSAGES.asn
new file mode 100644
index 00000000..0beb98d4
--- /dev/null
+++ b/epan/dissectors/asn1/h225/H323-MESSAGES.asn
@@ -0,0 +1,2221 @@
+-- H323-MESSAGES.asn
+--
+-- Taken from ITU ASN.1 database
+-- http://www.itu.int/ITU-T/formal-language/itu-t/h/h225-0/2009/H323-MESSAGES.asn
+--
+
+-- Module H323-MESSAGES (H.225.0:12/2009)
+H323-MESSAGES {itu-t(0) recommendation(0) h(8) h225-0(2250) version(0)
+ 7 h323-messages(0)} DEFINITIONS AUTOMATIC TAGS ::=
+BEGIN
+
+IMPORTS
+ SIGNED{}, ENCRYPTED{}, HASHED{}, ChallengeString, TimeStamp, RandomVal,
+ Password, EncodedPwdCertToken, ClearToken, CryptoToken,
+ AuthenticationMechanism
+ FROM H235-SECURITY-MESSAGES
+ DataProtocolCapability, T38FaxProfile, QOSCapability
+ FROM MULTIMEDIA-SYSTEM-CONTROL {itu-t(0) recommendation(0) h(8) h245(245)
+ version(0) 15 multimedia-system-control(0)};
+
+H323-UserInformation ::=
+ SEQUENCE -- root for all H.225.0 call signalling messages
+ {
+ h323-uu-pdu H323-UU-PDU,
+ user-data
+ SEQUENCE {protocol-discriminator INTEGER(0..255),
+ user-information OCTET STRING(SIZE (1..131)),
+ ...} OPTIONAL,
+ ...
+}
+
+H323-UU-PDU ::= SEQUENCE {
+ h323-message-body
+ CHOICE {setup Setup-UUIE,
+ callProceeding CallProceeding-UUIE,
+ connect Connect-UUIE,
+ alerting Alerting-UUIE,
+ information Information-UUIE,
+ releaseComplete ReleaseComplete-UUIE,
+ facility Facility-UUIE,
+ ...,
+ progress Progress-UUIE,
+ empty NULL, -- used when a Facility message is sent,--
+ -- but the Facility-UUIE is not to be invoked
+ -- (possible when transporting supplementary
+ -- services messages in versions prior to
+ -- H.225.0 version 4)
+ status Status-UUIE,
+ statusInquiry StatusInquiry-UUIE,
+ setupAcknowledge SetupAcknowledge-UUIE,
+ notify Notify-UUIE},
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ h4501SupplementaryService SEQUENCE OF OCTET STRING OPTIONAL,
+ -- each sequence of octet string is defined as one
+ -- H4501SupplementaryService APDU as defined in
+ -- Table 3/H.450.1
+ h245Tunnelling BOOLEAN,
+ -- if TRUE, tunnelling of H.245 messages is enabled
+ h245Control SEQUENCE OF OCTET STRING OPTIONAL,
+ nonStandardControl SEQUENCE OF NonStandardParameter OPTIONAL,
+ callLinkage CallLinkage OPTIONAL,
+ tunnelledSignallingMessage
+ SEQUENCE {tunnelledProtocolID TunnelledProtocol, -- tunnelled signalling--
+ -- protocol ID
+ messageContent SEQUENCE OF OCTET STRING, -- sequence of entire --
+ -- message(s)
+ tunnellingRequired NULL OPTIONAL,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...} OPTIONAL,
+ provisionalRespToH245Tunnelling NULL OPTIONAL,
+ stimulusControl StimulusControl OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+StimulusControl ::= SEQUENCE {
+ nonStandard NonStandardParameter OPTIONAL,
+ isText NULL OPTIONAL,
+ h248Message OCTET STRING OPTIONAL,
+ ...
+}
+
+Alerting-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ destinationInfo EndpointType,
+ h245Address TransportAddress OPTIONAL,
+ ...,
+ callIdentifier CallIdentifier,
+ h245SecurityMode H245Security OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ fastStart SEQUENCE OF OCTET STRING OPTIONAL,
+ multipleCalls BOOLEAN,
+ maintainConnection BOOLEAN,
+ alertingAddress SEQUENCE OF AliasAddress OPTIONAL,
+ presentationIndicator PresentationIndicator OPTIONAL,
+ screeningIndicator ScreeningIndicator OPTIONAL,
+ fastConnectRefused NULL OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ displayName SEQUENCE OF DisplayName OPTIONAL
+}
+
+CallProceeding-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ destinationInfo EndpointType,
+ h245Address TransportAddress OPTIONAL,
+ ...,
+ callIdentifier CallIdentifier,
+ h245SecurityMode H245Security OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ fastStart SEQUENCE OF OCTET STRING OPTIONAL,
+ multipleCalls BOOLEAN,
+ maintainConnection BOOLEAN,
+ fastConnectRefused NULL OPTIONAL,
+ featureSet FeatureSet OPTIONAL
+}
+
+Connect-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ h245Address TransportAddress OPTIONAL,
+ destinationInfo EndpointType,
+ conferenceID ConferenceIdentifier,
+ ...,
+ callIdentifier CallIdentifier,
+ h245SecurityMode H245Security OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ fastStart SEQUENCE OF OCTET STRING OPTIONAL,
+ multipleCalls BOOLEAN,
+ maintainConnection BOOLEAN,
+ language SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL, -- RFC 1766 language tag
+ connectedAddress SEQUENCE OF AliasAddress OPTIONAL,
+ presentationIndicator PresentationIndicator OPTIONAL,
+ screeningIndicator ScreeningIndicator OPTIONAL,
+ fastConnectRefused NULL OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ displayName SEQUENCE OF DisplayName OPTIONAL
+}
+
+Information-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ ...,
+ callIdentifier CallIdentifier,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ fastStart SEQUENCE OF OCTET STRING OPTIONAL,
+ fastConnectRefused NULL OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL
+}
+
+ReleaseComplete-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ reason ReleaseCompleteReason OPTIONAL,
+ ...,
+ callIdentifier CallIdentifier,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ busyAddress SEQUENCE OF AliasAddress OPTIONAL,
+ presentationIndicator PresentationIndicator OPTIONAL,
+ screeningIndicator ScreeningIndicator OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ destinationInfo EndpointType OPTIONAL,
+ displayName SEQUENCE OF DisplayName OPTIONAL
+}
+
+ReleaseCompleteReason ::= CHOICE {
+ noBandwidth NULL, -- bandwidth taken away or ARQ denied
+ gatekeeperResources NULL, -- exhausted
+ unreachableDestination NULL, -- no transport path to the destination
+ destinationRejection NULL, -- rejected at destination
+ invalidRevision NULL,
+ noPermission NULL, -- called party's gatekeeper rejects
+ unreachableGatekeeper NULL, -- terminal cannot reach gatekeeper
+
+ -- for ARQ
+ gatewayResources NULL,
+ badFormatAddress NULL,
+ adaptiveBusy NULL, -- call is dropping due to LAN crowding
+ inConf NULL, -- called party busy
+ undefinedReason NULL,
+ ...,
+ facilityCallDeflection NULL, -- call was deflected using a Facility
+
+ -- message
+ securityDenied NULL, -- incompatible security settings
+ calledPartyNotRegistered NULL, -- used by gatekeeper when endpoint has
+
+ -- preGrantedARQ to bypass ARQ/ACF
+ callerNotRegistered NULL, -- used by gatekeeper when endpoint has
+
+ -- preGrantedARQ to bypass ARQ/ACF
+ newConnectionNeeded NULL, -- indicates that the Setup was not
+
+ -- accepted on this connection, but that
+ -- the Setup may be accepted on
+ -- a new connection
+ nonStandardReason NonStandardParameter,
+ replaceWithConferenceInvite ConferenceIdentifier, -- call dropped due to
+
+ -- subsequent invitation
+ -- to a conference
+ -- (see 8.4.3.8/H.323)
+ genericDataReason NULL,
+ neededFeatureNotSupported NULL,
+ tunnelledSignallingRejected NULL,
+ invalidCID NULL,
+ securityError SecurityErrors,
+ hopCountExceeded NULL
+}
+
+Setup-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ h245Address TransportAddress OPTIONAL,
+ sourceAddress SEQUENCE OF AliasAddress OPTIONAL,
+ sourceInfo EndpointType,
+ destinationAddress SEQUENCE OF AliasAddress OPTIONAL,
+ destCallSignalAddress TransportAddress OPTIONAL,
+ destExtraCallInfo SEQUENCE OF AliasAddress OPTIONAL,
+ destExtraCRV SEQUENCE OF CallReferenceValue OPTIONAL,
+ activeMC BOOLEAN,
+ conferenceID ConferenceIdentifier,
+ conferenceGoal
+ CHOICE {create NULL,
+ join NULL,
+ invite NULL,
+ ...,
+ capability-negotiation NULL,
+ callIndependentSupplementaryService NULL},
+ callServices QseriesOptions OPTIONAL,
+ callType CallType,
+ ...,
+ sourceCallSignalAddress TransportAddress OPTIONAL,
+ remoteExtensionAddress AliasAddress OPTIONAL,
+ callIdentifier CallIdentifier,
+ h245SecurityCapability SEQUENCE OF H245Security OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ fastStart SEQUENCE OF OCTET STRING OPTIONAL,
+ mediaWaitForConnect BOOLEAN,
+ canOverlapSend BOOLEAN,
+ endpointIdentifier EndpointIdentifier OPTIONAL,
+ multipleCalls BOOLEAN,
+ maintainConnection BOOLEAN,
+ connectionParameters
+ SEQUENCE-- additional gateway parameters-- {connectionType
+ ScnConnectionType,
+ numberOfScnConnections
+ INTEGER(0..65535),
+ connectionAggregation
+ ScnConnectionAggregation,
+ ...} OPTIONAL,
+ language SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL,
+ -- RFC 1766 language tag
+ presentationIndicator PresentationIndicator OPTIONAL,
+ screeningIndicator ScreeningIndicator OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ symmetricOperationRequired NULL OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ desiredProtocols SEQUENCE OF SupportedProtocols OPTIONAL,
+ neededFeatures SEQUENCE OF FeatureDescriptor OPTIONAL,
+ desiredFeatures SEQUENCE OF FeatureDescriptor OPTIONAL,
+ supportedFeatures SEQUENCE OF FeatureDescriptor OPTIONAL,
+ parallelH245Control SEQUENCE OF OCTET STRING OPTIONAL,
+ additionalSourceAddresses SEQUENCE OF ExtendedAliasAddress OPTIONAL,
+ hopCount INTEGER(1..31) OPTIONAL,
+ displayName SEQUENCE OF DisplayName OPTIONAL
+}
+
+ScnConnectionType ::= CHOICE {
+ unknown NULL, -- should be selected when connection type is unknown
+ bChannel NULL, -- each individual connection on the SCN is 64 kbit/s.
+
+ -- Note that where SCN delivers 56 kbit/s usable data,
+ -- the actual bandwidth allocated on SCN is still
+ -- 64 kbit/s.
+ hybrid2x64 NULL, -- each connection is a 128 kbit/s hybrid call
+ hybrid384 NULL, -- each connection is an H0 (384 kbit/s) hybrid call
+ hybrid1536 NULL, -- each connection is an H11 (1536 kbit/s) hybrid call
+ hybrid1920 NULL, -- each connection is an H12 (1920 kbit/s) hybrid call
+ multirate NULL, -- bandwidth supplied by SCN using multirate.
+
+ -- In this case, the information transfer rate octet
+ -- in the bearer capability shall be set to multirate
+ -- and the rate multiplier octet shall denote the
+ -- number of B channels.
+ ...
+}
+
+ScnConnectionAggregation ::= CHOICE {
+ auto NULL, -- aggregation mechanism is unknown
+ none NULL, -- call produced using a single SCN connection
+ h221 NULL, -- use H.221 framing to aggregate the connections
+ bonded-mode1 NULL, -- use ISO/IEC 13871 bonding mode 1.
+
+ -- Use bonded-mode1 to signal a bonded call if the
+ -- precise bonding mode to be used is unknown.
+ bonded-mode2 NULL, -- use ISO/IEC 13871 bonding mode 2
+ bonded-mode3 NULL, -- use ISO/IEC 13871 bonding mode 3
+ ...
+}
+
+PresentationIndicator ::= CHOICE {
+ presentationAllowed NULL,
+ presentationRestricted NULL,
+ addressNotAvailable NULL,
+ ...
+}
+
+ScreeningIndicator ::= ENUMERATED {
+ userProvidedNotScreened(0),
+ -- number was provided by a remote user
+ -- and has not been screened by a gatekeeper
+ userProvidedVerifiedAndPassed(1),
+ -- number was provided by user
+ -- equipment (or by a remote network), and has
+ -- been screened by a gatekeeper
+ userProvidedVerifiedAndFailed(2),
+ -- number was provided by user
+ -- equipment (or by a remote network), and the
+ -- gatekeeper has determined that the
+ -- information is incorrect
+ networkProvided(3),
+ -- number was provided by a gatekeeper
+ ...
+ }
+
+Facility-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ alternativeAddress TransportAddress OPTIONAL,
+ alternativeAliasAddress SEQUENCE OF AliasAddress OPTIONAL,
+ conferenceID ConferenceIdentifier OPTIONAL,
+ reason FacilityReason,
+ ...,
+ callIdentifier CallIdentifier,
+ destExtraCallInfo SEQUENCE OF AliasAddress OPTIONAL,
+ remoteExtensionAddress AliasAddress OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ conferences SEQUENCE OF ConferenceList OPTIONAL,
+ h245Address TransportAddress OPTIONAL,
+ fastStart SEQUENCE OF OCTET STRING OPTIONAL,
+ multipleCalls BOOLEAN,
+ maintainConnection BOOLEAN,
+ fastConnectRefused NULL OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ destinationInfo EndpointType OPTIONAL,
+ h245SecurityMode H245Security OPTIONAL
+}
+
+ConferenceList ::= SEQUENCE {
+ conferenceID ConferenceIdentifier OPTIONAL,
+ conferenceAlias AliasAddress OPTIONAL,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...
+}
+
+FacilityReason ::= CHOICE {
+ routeCallToGatekeeper NULL, -- call must use gatekeeper model
+
+ -- gatekeeper is alternativeAddress
+ callForwarded NULL,
+ routeCallToMC NULL,
+ undefinedReason NULL,
+ ...,
+ conferenceListChoice NULL,
+ startH245 NULL, -- recipient should connect to h245Address
+ noH245 NULL, -- endpoint does not support H.245
+ newTokens NULL,
+ featureSetUpdate NULL,
+ forwardedElements NULL,
+ transportedInformation NULL
+}
+
+Progress-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ destinationInfo EndpointType,
+ h245Address TransportAddress OPTIONAL,
+ callIdentifier CallIdentifier,
+ h245SecurityMode H245Security OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ fastStart SEQUENCE OF OCTET STRING OPTIONAL,
+ ...,
+ multipleCalls BOOLEAN,
+ maintainConnection BOOLEAN,
+ fastConnectRefused NULL OPTIONAL
+}
+
+TransportAddress ::= CHOICE {
+ ipAddress
+ SEQUENCE {ip OCTET STRING(SIZE (4)),
+ port INTEGER(0..65535)},
+ ipSourceRoute
+ SEQUENCE {ip OCTET STRING(SIZE (4)),
+ port INTEGER(0..65535),
+ route SEQUENCE OF OCTET STRING(SIZE (4)),
+ routing CHOICE {strict NULL,
+ loose NULL,
+ ...},
+ ...},
+ ipxAddress
+ SEQUENCE {node OCTET STRING(SIZE (6)),
+ netnum OCTET STRING(SIZE (4)),
+ port OCTET STRING(SIZE (2))},
+ ip6Address
+ SEQUENCE {ip OCTET STRING(SIZE (16)),
+ port INTEGER(0..65535),
+ ...},
+ netBios OCTET STRING(SIZE (16)),
+ nsap OCTET STRING(SIZE (1..20)),
+ nonStandardAddress NonStandardParameter,
+ ...
+}
+
+Status-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ callIdentifier CallIdentifier,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ ...
+}
+
+StatusInquiry-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ callIdentifier CallIdentifier,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ ...
+}
+
+SetupAcknowledge-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ callIdentifier CallIdentifier,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ ...
+}
+
+Notify-UUIE ::= SEQUENCE {
+ protocolIdentifier ProtocolIdentifier,
+ callIdentifier CallIdentifier,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ ...,
+ connectedAddress SEQUENCE OF AliasAddress OPTIONAL,
+ presentationIndicator PresentationIndicator OPTIONAL,
+ screeningIndicator ScreeningIndicator OPTIONAL,
+ destinationInfo EndpointType OPTIONAL,
+ displayName SEQUENCE OF DisplayName OPTIONAL
+}
+
+-- Beginning of common message elements section
+EndpointType ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ vendor VendorIdentifier OPTIONAL,
+ gatekeeper GatekeeperInfo OPTIONAL,
+ gateway GatewayInfo OPTIONAL,
+ mcu McuInfo OPTIONAL, -- mc must be set as well
+ terminal TerminalInfo OPTIONAL,
+ mc BOOLEAN, -- shall not be set by itself
+ undefinedNode BOOLEAN,
+ ...,
+ set BIT STRING(SIZE (32)) OPTIONAL,
+ -- shall not be used with mc, gatekeeper
+ -- code points for the various SET devices
+ -- are defined in the respective SET Annexes
+ supportedTunnelledProtocols SEQUENCE OF TunnelledProtocol OPTIONAL
+ -- list of supported tunnelled protocols
+}
+
+GatewayInfo ::= SEQUENCE {
+ protocol SEQUENCE OF SupportedProtocols OPTIONAL,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...
+}
+
+SupportedProtocols ::= CHOICE {
+ nonStandardData NonStandardParameter,
+ h310 H310Caps,
+ h320 H320Caps,
+ h321 H321Caps,
+ h322 H322Caps,
+ h323 H323Caps,
+ h324 H324Caps,
+ voice VoiceCaps,
+ t120-only T120OnlyCaps,
+ ...,
+ nonStandardProtocol NonStandardProtocol,
+ t38FaxAnnexbOnly T38FaxAnnexbOnlyCaps,
+ sip SIPCaps
+}
+
+H310Caps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix
+}
+
+H320Caps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix
+}
+
+H321Caps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix
+}
+
+H322Caps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix
+}
+
+H323Caps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix
+}
+
+H324Caps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix
+}
+
+VoiceCaps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix
+}
+
+T120OnlyCaps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix
+}
+
+NonStandardProtocol ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix,
+ ...
+}
+
+T38FaxAnnexbOnlyCaps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix,
+ t38FaxProtocol DataProtocolCapability,
+ t38FaxProfile T38FaxProfile,
+ ...
+}
+
+SIPCaps ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ dataRatesSupported SEQUENCE OF DataRate OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix OPTIONAL,
+ ...
+}
+
+McuInfo ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ protocol SEQUENCE OF SupportedProtocols OPTIONAL
+}
+
+TerminalInfo ::= SEQUENCE {nonStandardData NonStandardParameter OPTIONAL,
+ ...
+}
+
+GatekeeperInfo ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...
+}
+
+VendorIdentifier ::= SEQUENCE {
+ vendor H221NonStandard,
+ productId OCTET STRING(SIZE (1..256)) OPTIONAL, -- per vendor
+ versionId OCTET STRING(SIZE (1..256)) OPTIONAL, -- per product
+ ...,
+ enterpriseNumber OBJECT IDENTIFIER OPTIONAL
+}
+
+H221NonStandard ::= SEQUENCE {
+ t35CountryCode INTEGER(0..255),
+ t35Extension INTEGER(0..255),
+ manufacturerCode INTEGER(0..65535),
+ ...
+}
+
+TunnelledProtocol ::= SEQUENCE {
+ id
+ CHOICE {tunnelledProtocolObjectID OBJECT IDENTIFIER,
+ tunnelledProtocolAlternateID TunnelledProtocolAlternateIdentifier,
+ ...},
+ subIdentifier IA5String(SIZE (1..64)) OPTIONAL,
+ ...
+}
+
+TunnelledProtocolAlternateIdentifier ::= SEQUENCE {
+ protocolType IA5String(SIZE (1..64)),
+ protocolVariant IA5String(SIZE (1..64)) OPTIONAL,
+ ...
+}
+
+NonStandardParameter ::= SEQUENCE {
+ nonStandardIdentifier NonStandardIdentifier,
+ data OCTET STRING
+}
+
+NonStandardIdentifier ::= CHOICE {
+ object OBJECT IDENTIFIER,
+ h221NonStandard H221NonStandard,
+ ...
+}
+
+AliasAddress ::= CHOICE {
+ dialledDigits IA5String(SIZE (1..128))(FROM ("0123456789#*,")),
+ h323-ID BMPString(SIZE (1..256)), -- Basic ISO/IEC 10646 (Unicode)
+ ...,
+ url-ID IA5String(SIZE (1..512)), -- URL style address
+ transportID TransportAddress,
+ email-ID IA5String(SIZE (1..512)), -- rfc822-compliant email address
+ partyNumber PartyNumber,
+ mobileUIM MobileUIM,
+ isupNumber IsupNumber
+}
+
+AddressPattern ::= CHOICE {
+ wildcard AliasAddress,
+ range SEQUENCE {startOfRange PartyNumber,
+ endOfRange PartyNumber},
+ ...
+}
+
+PartyNumber ::= CHOICE {
+ e164Number PublicPartyNumber,
+ -- the numbering plan is according to
+ -- ITUT Recs E.163 and E.164.
+ dataPartyNumber NumberDigits,
+ -- not used, value reserved.
+ telexPartyNumber NumberDigits,
+ -- not used, value reserved.
+ privateNumber PrivatePartyNumber,
+ -- the numbering plan is according to
+ -- ISO/IEC 11571.
+ nationalStandardPartyNumber NumberDigits,
+ -- not used, value reserved.
+ ...
+}
+
+PublicPartyNumber ::= SEQUENCE {
+ publicTypeOfNumber PublicTypeOfNumber,
+ publicNumberDigits NumberDigits
+}
+
+PrivatePartyNumber ::= SEQUENCE {
+ privateTypeOfNumber PrivateTypeOfNumber,
+ privateNumberDigits NumberDigits
+}
+
+NumberDigits ::= IA5String(SIZE (1..128))(FROM ("0123456789#*,"))
+
+DisplayName ::= SEQUENCE {
+ language IA5String OPTIONAL, -- RFC4646 language tag
+ name BMPString(SIZE (1..80))
+}
+
+PublicTypeOfNumber ::= CHOICE {
+ unknown NULL,
+ -- if used number digits carry prefix
+ -- indicating type
+ -- of number according to national
+ -- recommendations.
+ internationalNumber NULL,
+ nationalNumber NULL,
+ networkSpecificNumber NULL,
+ -- not used, value reserved
+ subscriberNumber NULL,
+ abbreviatedNumber NULL,
+ -- valid only for called party number at
+ -- the outgoing access, network
+ -- substitutes
+ -- appropriate number.
+ ...
+}
+
+PrivateTypeOfNumber ::= CHOICE {
+ unknown NULL,
+ level2RegionalNumber NULL,
+ level1RegionalNumber NULL,
+ pISNSpecificNumber NULL,
+ localNumber NULL,
+ abbreviatedNumber NULL,
+ ...
+}
+
+MobileUIM ::= CHOICE {
+ ansi-41-uim ANSI-41-UIM, -- Americas standards Wireless Networks
+ gsm-uim GSM-UIM, -- European standards Wireless Networks
+ ...
+}
+
+TBCD-STRING ::= IA5String(FROM ("0123456789#*abc"))
+
+ANSI-41-UIM ::= SEQUENCE {
+ imsi TBCD-STRING(SIZE (3..16)) OPTIONAL,
+ min TBCD-STRING(SIZE (3..16)) OPTIONAL,
+ mdn TBCD-STRING(SIZE (3..16)) OPTIONAL,
+ msisdn TBCD-STRING(SIZE (3..16)) OPTIONAL,
+ esn TBCD-STRING(SIZE (16)) OPTIONAL,
+ mscid TBCD-STRING(SIZE (3..16)) OPTIONAL,
+ system-id
+ CHOICE {sid TBCD-STRING(SIZE (1..4)),
+ mid TBCD-STRING(SIZE (1..4)),
+ ...},
+ systemMyTypeCode OCTET STRING(SIZE (1)) OPTIONAL,
+ systemAccessType OCTET STRING(SIZE (1)) OPTIONAL,
+ qualificationInformationCode OCTET STRING(SIZE (1)) OPTIONAL,
+ sesn TBCD-STRING(SIZE (16)) OPTIONAL,
+ soc TBCD-STRING(SIZE (3..16)) OPTIONAL,
+ ...
+ -- IMSI refers to International Mobile Station Identification
+ -- MIN refers to Mobile Identification Number
+ -- MDN refers to Mobile Directory Number
+ -- MSISDN refers to Mobile Station ISDN number
+ -- ESN Refers to Electronic Serial Number
+ -- MSCID refers to Mobile Switching Center number + Market ID or System ID
+ -- SID refers to System Identification and MID refers to Market
+ -- Identification
+ -- SystemMyTypeCode refers to vendor identification number
+ -- SystemAccessType refers to the system access type like power down
+ -- registration or call
+ -- origination or Short Message response etc.
+ -- Qualification Information Code refers to the validity
+ -- SESN Refers to SIM Electronic Serial Number for Security purposes of
+ -- User Identification
+ -- SOC refers to System Operator Code
+}
+
+GSM-UIM ::= SEQUENCE {
+ imsi TBCD-STRING(SIZE (3..16)) OPTIONAL,
+ tmsi OCTET STRING(SIZE (1..4)) OPTIONAL,
+ msisdn TBCD-STRING(SIZE (3..16)) OPTIONAL,
+ imei TBCD-STRING(SIZE (15..16)) OPTIONAL,
+ hplmn TBCD-STRING(SIZE (1..4)) OPTIONAL,
+ vplmn TBCD-STRING(SIZE (1..4)) OPTIONAL,
+ -- IMSI refers to International Mobile Station Identification
+ -- MSISDN refers to Mobile Station ISDN number
+ -- IMEI Refers to International Mobile Equipment Identification
+ -- VPLMN or HPLMN refers to Visiting or Home Public Land Mobile Network
+ -- number
+ ...
+}
+
+IsupNumber ::= CHOICE {
+ e164Number IsupPublicPartyNumber,
+ -- the numbering plan is according to
+ -- ITUT Recs E.163 and E.164.
+ dataPartyNumber IsupDigits, -- not used, value reserved.
+ telexPartyNumber IsupDigits, -- not used, value reserved.
+ privateNumber IsupPrivatePartyNumber,
+ -- the numbering plan is according to
+ -- ISO/IEC 11571.
+ nationalStandardPartyNumber IsupDigits, -- not used, value reserved.
+ ...
+}
+
+IsupPublicPartyNumber ::= SEQUENCE {
+ natureOfAddress NatureOfAddress,
+ address IsupDigits,
+ ...
+}
+
+IsupPrivatePartyNumber ::= SEQUENCE {
+ privateTypeOfNumber PrivateTypeOfNumber,
+ address IsupDigits,
+ ...
+}
+
+NatureOfAddress ::= CHOICE {
+ unknown NULL,
+ subscriberNumber NULL,
+ nationalNumber NULL,
+ internationalNumber NULL,
+ networkSpecificNumber NULL,
+ routingNumberNationalFormat NULL,
+ routingNumberNetworkSpecificFormat NULL,
+ routingNumberWithCalledDirectoryNumber NULL,
+ ...
+}
+
+IsupDigits ::= IA5String(SIZE (1..128))(FROM ("0123456789ABCDE"))
+
+ExtendedAliasAddress ::= SEQUENCE {
+ address AliasAddress,
+ presentationIndicator PresentationIndicator OPTIONAL,
+ screeningIndicator ScreeningIndicator OPTIONAL,
+ ...
+}
+
+Endpoint ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ aliasAddress SEQUENCE OF AliasAddress OPTIONAL,
+ callSignalAddress SEQUENCE OF TransportAddress OPTIONAL,
+ rasAddress SEQUENCE OF TransportAddress OPTIONAL,
+ endpointType EndpointType OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ priority INTEGER(0..127) OPTIONAL,
+ remoteExtensionAddress SEQUENCE OF AliasAddress OPTIONAL,
+ destExtraCallInfo SEQUENCE OF AliasAddress OPTIONAL,
+ ...,
+ alternateTransportAddresses AlternateTransportAddresses OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ featureSet FeatureSet OPTIONAL
+}
+
+AlternateTransportAddresses ::= SEQUENCE {
+ annexE SEQUENCE OF TransportAddress OPTIONAL,
+ ...,
+ sctp SEQUENCE OF TransportAddress OPTIONAL
+}
+
+UseSpecifiedTransport ::= CHOICE {tcp NULL,
+ annexE NULL,
+ ...,
+ sctp NULL
+}
+
+AlternateGK ::= SEQUENCE {
+ rasAddress TransportAddress,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ needToRegister BOOLEAN,
+ priority INTEGER(0..127),
+ ...
+}
+
+AltGKInfo ::= SEQUENCE {
+ alternateGatekeeper SEQUENCE OF AlternateGK,
+ altGKisPermanent BOOLEAN,
+ ...
+}
+
+SecurityServiceMode ::= CHOICE {
+ nonStandard NonStandardParameter,
+ none NULL,
+ default NULL,
+ ... -- can be extended with other specific modes
+}
+
+SecurityCapabilities ::= SEQUENCE {
+ nonStandard NonStandardParameter OPTIONAL,
+ encryption SecurityServiceMode,
+ authenticaton SecurityServiceMode,
+ integrity SecurityServiceMode,
+ ...
+}
+
+SecurityErrors ::= CHOICE {
+ securityWrongSyncTime NULL, -- either time server
+
+ -- problem or network delay
+ securityReplay NULL, -- replay attack encountered
+ securityWrongGeneralID NULL, -- wrong general ID
+ securityWrongSendersID NULL, -- wrong senders ID
+ securityIntegrityFailed NULL, -- integrity check failed
+ securityWrongOID NULL, -- wrong token OIDs or crypto alg
+
+ -- OIDs
+ securityDHmismatch NULL, -- mismatch of DH parameters
+ securityCertificateExpired NULL, -- certificate has expired
+ securityCertificateDateInvalid NULL, -- certificate is not yet valid
+ securityCertificateRevoked NULL, -- certificate was found revoked
+ securityCertificateNotReadable NULL, -- decoding error
+ securityCertificateSignatureInvalid NULL, -- wrong signature in the
+
+ -- certificate
+ securityCertificateMissing NULL, -- no certificate available
+ securityCertificateIncomplete NULL, -- missing expected certificate
+
+ -- extensions
+ securityUnsupportedCertificateAlgOID NULL, -- crypto algs not understood
+ securityUnknownCA NULL, -- CA/root certificate could not
+
+ -- be found
+ ...
+}
+
+SecurityErrors2 ::= CHOICE {
+ securityWrongSyncTime NULL, -- either time server problem or network
+
+ -- delay
+ securityReplay NULL, -- replay attack encountered
+ securityWrongGeneralID NULL, -- wrong general ID
+ securityWrongSendersID NULL, -- wrong senders ID
+ securityIntegrityFailed NULL, -- integrity check failed
+ securityWrongOID NULL, -- wrong token OIDs or crypto alg OIDs
+ ...
+}
+
+H245Security ::= CHOICE {
+ nonStandard NonStandardParameter,
+ noSecurity NULL,
+ tls SecurityCapabilities,
+ ipsec SecurityCapabilities,
+ ...
+}
+
+QseriesOptions ::= SEQUENCE {
+ q932Full BOOLEAN, -- if true, indicates full support for Q.932
+ q951Full BOOLEAN, -- if true, indicates full support for Q.951
+ q952Full BOOLEAN, -- if true, indicates full support for Q.952
+ q953Full BOOLEAN, -- if true, indicates full support for Q.953
+ q955Full BOOLEAN, -- if true, indicates full support for Q.955
+ q956Full BOOLEAN, -- if true, indicates full support for Q.956
+ q957Full BOOLEAN, -- if true, indicates full support for Q.957
+ q954Info Q954Details,
+ ...
+}
+
+Q954Details ::= SEQUENCE {
+ conferenceCalling BOOLEAN,
+ threePartyService BOOLEAN,
+ ...
+}
+
+GloballyUniqueID ::= OCTET STRING(SIZE (16))
+
+ConferenceIdentifier ::= GloballyUniqueID
+
+RequestSeqNum ::= INTEGER(1..65535)
+
+GatekeeperIdentifier ::= BMPString(SIZE (1..128))
+
+BandWidth ::= INTEGER(0..4294967295) -- in 100s of bits
+
+
+CallReferenceValue ::= INTEGER(0..65535)
+
+EndpointIdentifier ::= BMPString(SIZE (1..128))
+
+ProtocolIdentifier ::= OBJECT IDENTIFIER
+
+TimeToLive ::= INTEGER(1..4294967295) -- in seconds
+
+
+H248PackagesDescriptor ::= OCTET STRING -- This octet string contains ASN.1
+
+-- PER encoded H.248
+-- PackagesDescriptor
+H248SignalsDescriptor ::= OCTET STRING -- This octet string contains
+
+-- ASN.1 PER encoded H.248
+-- SignalsDescriptor.
+FeatureDescriptor ::=
+ GenericData
+
+CallIdentifier ::= SEQUENCE {guid GloballyUniqueID,
+ ...
+}
+
+EncryptIntAlg ::=
+ CHOICE { -- core encryption algorithms for RAS message integrity
+ nonStandard NonStandardParameter,
+ isoAlgorithm OBJECT IDENTIFIER, -- defined in ISO/IEC 9979
+ ...
+}
+
+NonIsoIntegrityMechanism ::=
+ CHOICE { -- HMAC mechanism used, no truncation, tagging may be necessary!
+ hMAC-MD5 NULL,
+ hMAC-iso10118-2-s EncryptIntAlg, -- according to ISO/IEC 10118-2 using
+
+ -- EncryptIntAlg as core block
+ -- encryption algorithm (short MAC)
+ hMAC-iso10118-2-l EncryptIntAlg, -- according to ISO/IEC 10118-2 using
+
+ -- EncryptIntAlg as core block
+ -- encryption algorithm (long MAC)
+ hMAC-iso10118-3 OBJECT IDENTIFIER, -- according to ISO/IEC 10118-3 using
+
+ -- OID as hash function (OID is
+ -- SHA-1,
+ -- RIPE-MD160,
+ -- RIPE-MD128)
+ ...
+}
+
+IntegrityMechanism ::= CHOICE { -- for RAS message integrity
+ nonStandard NonStandardParameter,
+ digSig NULL, -- indicates to apply a digital signature
+ iso9797 OBJECT IDENTIFIER, -- according to ISO/IEC 9797 using OID as
+
+ -- core encryption algorithm (X-CBC MAC)
+ nonIsoIM NonIsoIntegrityMechanism,
+ ...
+}
+
+ICV ::= SEQUENCE {
+ algorithmOID OBJECT IDENTIFIER, -- the algorithm used to compute the
+
+ -- signature
+ icv BIT STRING-- the computed cryptographic --
+ -- integrity check value or signature
+}
+
+FastStartToken ::=
+ ClearToken
+ (WITH COMPONENTS {
+ ...,
+ timeStamp PRESENT,
+ dhkey PRESENT,
+ generalID PRESENT
+
+ -- set to "alias" --})
+
+EncodedFastStartToken ::= TYPE-IDENTIFIER.&Type(FastStartToken)
+
+CryptoH323Token ::= CHOICE {
+ cryptoEPPwdHash
+ SEQUENCE {alias AliasAddress, -- alias of entity generating hash--
+ timeStamp TimeStamp, -- timestamp used in hash--
+ token
+ HASHED{EncodedPwdCertToken-- generalID set to --
+ -- "alias" -- }},
+ cryptoGKPwdHash
+ SEQUENCE {gatekeeperId GatekeeperIdentifier, -- GatekeeperID of GK generating --
+ -- hash
+ timeStamp TimeStamp, -- timestamp used in hash--
+ token
+ HASHED{EncodedPwdCertToken-- generalID set to --
+ -- Gatekeeperid -- }},
+ cryptoEPPwdEncr
+ ENCRYPTED{EncodedPwdCertToken-- generalID set to --
+ -- Gatekeeperid -- },
+ cryptoGKPwdEncr
+ ENCRYPTED{EncodedPwdCertToken-- generalID set to --
+ -- Gatekeeperid -- },
+ cryptoEPCert
+ SIGNED{EncodedPwdCertToken-- generalID set to --
+ -- Gatekeeperid -- },
+ cryptoGKCert SIGNED{EncodedPwdCertToken-- generalID set to alias -- },
+ cryptoFastStart SIGNED{EncodedFastStartToken},
+ nestedcryptoToken CryptoToken,
+ ...
+}
+
+DataRate ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ channelRate BandWidth,
+ channelMultiplier INTEGER(1..256) OPTIONAL,
+ ...
+}
+
+CallLinkage ::= SEQUENCE {
+ globalCallId GloballyUniqueID OPTIONAL,
+ threadId GloballyUniqueID OPTIONAL,
+ ...
+}
+
+SupportedPrefix ::= SEQUENCE {
+ nonStandardData NonStandardParameter OPTIONAL,
+ prefix AliasAddress,
+ ...
+}
+
+CapacityReportingCapability ::= SEQUENCE {canReportCallCapacity BOOLEAN,
+ ...
+}
+
+CapacityReportingSpecification ::= SEQUENCE {
+ when SEQUENCE {callStart NULL OPTIONAL,
+ callEnd NULL OPTIONAL,
+ ...},
+ ...
+}
+
+CallCapacity ::= SEQUENCE {
+ maximumCallCapacity CallCapacityInfo OPTIONAL,
+ currentCallCapacity CallCapacityInfo OPTIONAL,
+ ...
+}
+
+CallCapacityInfo ::= SEQUENCE {
+ voiceGwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ h310GwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ h320GwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ h321GwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ h322GwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ h323GwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ h324GwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ t120OnlyGwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ t38FaxAnnexbOnlyGwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ terminalCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ mcuCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL,
+ ...,
+ sipGwCallsAvailable SEQUENCE OF CallsAvailable OPTIONAL
+}
+
+CallsAvailable ::= SEQUENCE {
+ calls INTEGER(0..4294967295),
+ group IA5String(SIZE (1..128)) OPTIONAL,
+ ...,
+ carrier CarrierInfo OPTIONAL
+}
+
+CircuitInfo ::= SEQUENCE {
+ sourceCircuitID CircuitIdentifier OPTIONAL,
+ destinationCircuitID CircuitIdentifier OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ ...
+}
+
+CircuitIdentifier ::= SEQUENCE {
+ cic CicInfo OPTIONAL,
+ group GroupID OPTIONAL,
+ ...,
+ carrier CarrierInfo OPTIONAL
+}
+
+CicInfo ::= SEQUENCE {
+ cic SEQUENCE OF OCTET STRING(SIZE (2..4)),
+ pointCode OCTET STRING(SIZE (2..5)),
+ ...
+}
+
+GroupID ::= SEQUENCE {
+ member SEQUENCE OF INTEGER(0..65535) OPTIONAL,
+ group IA5String(SIZE (1..128)),
+ ...
+}
+
+CarrierInfo ::= SEQUENCE {
+ carrierIdentificationCode OCTET STRING(SIZE (3..4)) OPTIONAL,
+ carrierName IA5String(SIZE (1..128)) OPTIONAL,
+ ...
+}
+
+ServiceControlDescriptor ::= CHOICE {
+ url IA5String(SIZE (0..512)), -- indicates a URL-
+
+ -- referenced
+ -- protocol/resource
+ signal H248SignalsDescriptor,
+ nonStandard NonStandardParameter,
+ callCreditServiceControl CallCreditServiceControl,
+ ...
+}
+
+ServiceControlSession ::= SEQUENCE {
+ sessionId INTEGER(0..255),
+ contents ServiceControlDescriptor OPTIONAL,
+ reason CHOICE {open NULL,
+ refresh NULL,
+ close NULL,
+ ...},
+ ...
+}
+
+RasUsageInfoTypes ::= SEQUENCE {
+ nonStandardUsageTypes SEQUENCE OF NonStandardParameter,
+ startTime NULL OPTIONAL,
+ endTime NULL OPTIONAL,
+ terminationCause NULL OPTIONAL,
+ ...
+}
+
+RasUsageSpecification ::= SEQUENCE {
+ when
+ SEQUENCE {start NULL OPTIONAL,
+ end NULL OPTIONAL,
+ inIrr NULL OPTIONAL,
+ ...},
+ callStartingPoint
+ SEQUENCE {alerting NULL OPTIONAL,
+ connect NULL OPTIONAL,
+ ...} OPTIONAL,
+ required RasUsageInfoTypes,
+ ...
+}
+
+RasUsageInformation ::= SEQUENCE {
+ nonStandardUsageFields SEQUENCE OF NonStandardParameter,
+ alertingTime TimeStamp OPTIONAL,
+ connectTime TimeStamp OPTIONAL,
+ endTime TimeStamp OPTIONAL,
+ ...
+}
+
+CallTerminationCause ::= CHOICE {
+ releaseCompleteReason ReleaseCompleteReason,
+ releaseCompleteCauseIE OCTET STRING(SIZE (2..32)),
+ ...
+}
+
+BandwidthDetails ::= SEQUENCE {
+ sender BOOLEAN, -- TRUE=sender, FALSE=receiver
+ multicast BOOLEAN, -- TRUE if stream is multicast
+ bandwidth BandWidth, -- Bandwidth used for stream
+ rtcpAddresses TransportChannelInfo, -- RTCP addresses for media stream
+ ...
+}
+
+CallCreditCapability ::= SEQUENCE {
+ canDisplayAmountString BOOLEAN OPTIONAL,
+ canEnforceDurationLimit BOOLEAN OPTIONAL,
+ ...
+}
+
+CallCreditServiceControl ::= SEQUENCE {
+ amountString BMPString(SIZE (1..512)) OPTIONAL, -- (Unicode)
+ billingMode CHOICE {credit NULL,
+ debit NULL,
+ ...} OPTIONAL,
+ callDurationLimit INTEGER(1..4294967295) OPTIONAL, -- in seconds
+ enforceCallDurationLimit BOOLEAN OPTIONAL,
+ callStartingPoint CHOICE {alerting NULL,
+ connect NULL,
+ ...} OPTIONAL,
+ ...
+}
+
+GenericData ::= SEQUENCE {
+ id GenericIdentifier,
+ parameters SEQUENCE (SIZE (1..512)) OF EnumeratedParameter OPTIONAL,
+ ...
+}
+
+GenericIdentifier ::= CHOICE {
+ standard INTEGER(0..16383, ...),
+ oid OBJECT IDENTIFIER,
+ nonStandard GloballyUniqueID,
+ ...
+}
+
+EnumeratedParameter ::= SEQUENCE {
+ id GenericIdentifier,
+ content Content OPTIONAL,
+ ...
+}
+
+Content ::= CHOICE {
+ raw OCTET STRING,
+ text IA5String,
+ unicode BMPString,
+ bool BOOLEAN,
+ number8 INTEGER(0..255),
+ number16 INTEGER(0..65535),
+ number32 INTEGER(0..4294967295),
+ id GenericIdentifier,
+ alias AliasAddress,
+ transport TransportAddress,
+ compound SEQUENCE (SIZE (1..512)) OF EnumeratedParameter,
+ nested SEQUENCE (SIZE (1..16)) OF GenericData,
+ ...
+}
+
+FeatureSet ::= SEQUENCE {
+ replacementFeatureSet BOOLEAN,
+ neededFeatures SEQUENCE OF FeatureDescriptor OPTIONAL,
+ desiredFeatures SEQUENCE OF FeatureDescriptor OPTIONAL,
+ supportedFeatures SEQUENCE OF FeatureDescriptor OPTIONAL,
+ ...
+}
+
+TransportChannelInfo ::= SEQUENCE {
+ sendAddress TransportAddress OPTIONAL,
+ recvAddress TransportAddress OPTIONAL,
+ ...
+}
+
+RTPSession ::= SEQUENCE {
+ rtpAddress TransportChannelInfo,
+ rtcpAddress TransportChannelInfo,
+ cname PrintableString,
+ ssrc INTEGER(1..4294967295),
+ sessionId INTEGER(1..255),
+ associatedSessionIds SEQUENCE OF INTEGER(1..255),
+ ...,
+ multicast NULL OPTIONAL,
+ bandwidth BandWidth OPTIONAL
+}
+
+RehomingModel ::= CHOICE {gatekeeperBased NULL,
+ endpointBased NULL
+}
+
+RasMessage ::= CHOICE {
+ gatekeeperRequest GatekeeperRequest,
+ gatekeeperConfirm GatekeeperConfirm,
+ gatekeeperReject GatekeeperReject,
+ registrationRequest RegistrationRequest,
+ registrationConfirm RegistrationConfirm,
+ registrationReject RegistrationReject,
+ unregistrationRequest UnregistrationRequest,
+ unregistrationConfirm UnregistrationConfirm,
+ unregistrationReject UnregistrationReject,
+ admissionRequest AdmissionRequest,
+ admissionConfirm AdmissionConfirm,
+ admissionReject AdmissionReject,
+ bandwidthRequest BandwidthRequest,
+ bandwidthConfirm BandwidthConfirm,
+ bandwidthReject BandwidthReject,
+ disengageRequest DisengageRequest,
+ disengageConfirm DisengageConfirm,
+ disengageReject DisengageReject,
+ locationRequest LocationRequest,
+ locationConfirm LocationConfirm,
+ locationReject LocationReject,
+ infoRequest InfoRequest,
+ infoRequestResponse InfoRequestResponse,
+ nonStandardMessage NonStandardMessage,
+ unknownMessageResponse UnknownMessageResponse,
+ ...,
+ requestInProgress RequestInProgress,
+ resourcesAvailableIndicate ResourcesAvailableIndicate,
+ resourcesAvailableConfirm ResourcesAvailableConfirm,
+ infoRequestAck InfoRequestAck,
+ infoRequestNak InfoRequestNak,
+ serviceControlIndication ServiceControlIndication,
+ serviceControlResponse ServiceControlResponse,
+ admissionConfirmSequence SEQUENCE OF AdmissionConfirm
+}
+
+GatekeeperRequest ::= SEQUENCE --(GRQ)
+ {
+ requestSeqNum RequestSeqNum,
+ protocolIdentifier ProtocolIdentifier,
+ nonStandardData NonStandardParameter OPTIONAL,
+ rasAddress TransportAddress,
+ endpointType EndpointType,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ callServices QseriesOptions OPTIONAL,
+ endpointAlias SEQUENCE OF AliasAddress OPTIONAL,
+ ...,
+ alternateEndpoints SEQUENCE OF Endpoint OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ authenticationCapability SEQUENCE OF AuthenticationMechanism OPTIONAL,
+ algorithmOIDs SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
+ integrity SEQUENCE OF IntegrityMechanism OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ supportsAltGK NULL OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ supportsAssignedGK BOOLEAN,
+ assignedGatekeeper AlternateGK OPTIONAL
+}
+
+GatekeeperConfirm ::= SEQUENCE --(GCF)
+ {
+ requestSeqNum RequestSeqNum,
+ protocolIdentifier ProtocolIdentifier,
+ nonStandardData NonStandardParameter OPTIONAL,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ rasAddress TransportAddress,
+ ...,
+ alternateGatekeeper SEQUENCE OF AlternateGK OPTIONAL,
+ authenticationMode AuthenticationMechanism OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ algorithmOID OBJECT IDENTIFIER OPTIONAL,
+ integrity SEQUENCE OF IntegrityMechanism OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL,
+ rehomingModel RehomingModel OPTIONAL
+}
+
+GatekeeperReject ::= SEQUENCE --(GRJ)
+ {
+ requestSeqNum RequestSeqNum,
+ protocolIdentifier ProtocolIdentifier,
+ nonStandardData NonStandardParameter OPTIONAL,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ rejectReason GatekeeperRejectReason,
+ ...,
+ altGKInfo AltGKInfo OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+GatekeeperRejectReason ::= CHOICE {
+ resourceUnavailable NULL,
+ terminalExcluded NULL, -- permission failure, not a resource
+
+ -- failure
+ invalidRevision NULL,
+ undefinedReason NULL,
+ ...,
+ securityDenial NULL,
+ genericDataReason NULL,
+ neededFeatureNotSupported NULL,
+ securityError SecurityErrors
+}
+
+RegistrationRequest ::= SEQUENCE --(RRQ)
+ {
+ requestSeqNum RequestSeqNum,
+ protocolIdentifier ProtocolIdentifier,
+ nonStandardData NonStandardParameter OPTIONAL,
+ discoveryComplete BOOLEAN,
+ callSignalAddress SEQUENCE OF TransportAddress,
+ rasAddress SEQUENCE OF TransportAddress,
+ terminalType EndpointType,
+ terminalAlias SEQUENCE OF AliasAddress OPTIONAL,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ endpointVendor VendorIdentifier,
+ ...,
+ alternateEndpoints SEQUENCE OF Endpoint OPTIONAL,
+ timeToLive TimeToLive OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ keepAlive BOOLEAN,
+ endpointIdentifier EndpointIdentifier OPTIONAL,
+ willSupplyUUIEs BOOLEAN,
+ maintainConnection BOOLEAN,
+ alternateTransportAddresses AlternateTransportAddresses OPTIONAL,
+ additiveRegistration NULL OPTIONAL,
+ terminalAliasPattern SEQUENCE OF AddressPattern OPTIONAL,
+ supportsAltGK NULL OPTIONAL,
+ usageReportingCapability RasUsageInfoTypes OPTIONAL,
+ multipleCalls BOOLEAN OPTIONAL,
+ supportedH248Packages SEQUENCE OF H248PackagesDescriptor OPTIONAL,
+ callCreditCapability CallCreditCapability OPTIONAL,
+ capacityReportingCapability CapacityReportingCapability OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ restart NULL OPTIONAL,
+ supportsACFSequences NULL OPTIONAL,
+ supportsAssignedGK BOOLEAN,
+ assignedGatekeeper AlternateGK OPTIONAL,
+ transportQOS TransportQOS OPTIONAL,
+ language SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL
+}
+
+RegistrationConfirm ::= SEQUENCE --(RCF)
+ {
+ requestSeqNum RequestSeqNum,
+ protocolIdentifier ProtocolIdentifier,
+ nonStandardData NonStandardParameter OPTIONAL,
+ callSignalAddress SEQUENCE OF TransportAddress,
+ terminalAlias SEQUENCE OF AliasAddress OPTIONAL,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ endpointIdentifier EndpointIdentifier,
+ ...,
+ alternateGatekeeper SEQUENCE OF AlternateGK OPTIONAL,
+ timeToLive TimeToLive OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ willRespondToIRR BOOLEAN,
+ preGrantedARQ
+ SEQUENCE {makeCall BOOLEAN,
+ useGKCallSignalAddressToMakeCall BOOLEAN,
+ answerCall BOOLEAN,
+ useGKCallSignalAddressToAnswer BOOLEAN,
+ ...,
+ irrFrequencyInCall INTEGER(1..65535) OPTIONAL, -- in seconds; --
+ -- not present
+ -- if GK does
+ -- not want IRRs
+ totalBandwidthRestriction BandWidth OPTIONAL, -- total limit --
+ -- for all
+ -- concurrent
+ -- calls
+ alternateTransportAddresses
+ AlternateTransportAddresses OPTIONAL,
+ useSpecifiedTransport UseSpecifiedTransport OPTIONAL
+ } OPTIONAL,
+ maintainConnection BOOLEAN,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ supportsAdditiveRegistration NULL OPTIONAL,
+ terminalAliasPattern SEQUENCE OF AddressPattern OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix OPTIONAL,
+ usageSpec SEQUENCE OF RasUsageSpecification OPTIONAL,
+ featureServerAlias AliasAddress OPTIONAL,
+ capacityReportingSpec CapacityReportingSpecification OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL,
+ rehomingModel RehomingModel OPTIONAL,
+ transportQOS TransportQOS OPTIONAL
+}
+
+RegistrationReject ::= SEQUENCE --(RRJ)
+ {
+ requestSeqNum RequestSeqNum,
+ protocolIdentifier ProtocolIdentifier,
+ nonStandardData NonStandardParameter OPTIONAL,
+ rejectReason RegistrationRejectReason,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ ...,
+ altGKInfo AltGKInfo OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL
+}
+
+RegistrationRejectReason ::= CHOICE {
+ discoveryRequired NULL,
+ invalidRevision NULL,
+ invalidCallSignalAddress NULL,
+ invalidRASAddress NULL, -- supplied address is invalid
+ duplicateAlias SEQUENCE OF AliasAddress,
+ -- alias registered to another
+ -- endpoint
+ invalidTerminalType NULL,
+ undefinedReason NULL,
+ transportNotSupported NULL, -- one or more of the transports
+ ...,
+ transportQOSNotSupported NULL, -- endpoint QoS not supported
+ resourceUnavailable NULL, -- gatekeeper resources exhausted
+ invalidAlias NULL, -- alias not consistent with
+
+ -- gatekeeper rules
+ securityDenial NULL,
+ fullRegistrationRequired NULL, -- registration permission has
+
+ -- expired
+ additiveRegistrationNotSupported NULL,
+ invalidTerminalAliases
+ SEQUENCE {terminalAlias SEQUENCE OF AliasAddress OPTIONAL,
+ terminalAliasPattern SEQUENCE OF AddressPattern OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix OPTIONAL,
+ ...},
+ genericDataReason NULL,
+ neededFeatureNotSupported NULL,
+ securityError SecurityErrors,
+ registerWithAssignedGK NULL
+}
+
+UnregistrationRequest ::= SEQUENCE --(URQ)
+ {
+ requestSeqNum RequestSeqNum,
+ callSignalAddress SEQUENCE OF TransportAddress,
+ endpointAlias SEQUENCE OF AliasAddress OPTIONAL,
+ nonStandardData NonStandardParameter OPTIONAL,
+ endpointIdentifier EndpointIdentifier OPTIONAL,
+ ...,
+ alternateEndpoints SEQUENCE OF Endpoint OPTIONAL,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ reason UnregRequestReason OPTIONAL,
+ endpointAliasPattern SEQUENCE OF AddressPattern OPTIONAL,
+ supportedPrefixes SEQUENCE OF SupportedPrefix OPTIONAL,
+ alternateGatekeeper SEQUENCE OF AlternateGK OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL
+}
+
+UnregRequestReason ::= CHOICE {
+ reregistrationRequired NULL,
+ ttlExpired NULL,
+ securityDenial NULL,
+ undefinedReason NULL,
+ ...,
+ maintenance NULL,
+ securityError SecurityErrors2,
+ registerWithAssignedGK NULL
+}
+
+UnregistrationConfirm ::= SEQUENCE --(UCF)
+ {
+ requestSeqNum RequestSeqNum,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL
+}
+
+UnregistrationReject ::= SEQUENCE --(URJ)
+ {
+ requestSeqNum RequestSeqNum,
+ rejectReason UnregRejectReason,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ altGKInfo AltGKInfo OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+UnregRejectReason ::= CHOICE {
+ notCurrentlyRegistered NULL,
+ callInProgress NULL,
+ undefinedReason NULL,
+ ...,
+ permissionDenied NULL, -- requesting user not allowed to
+
+ -- unregister specified user
+ securityDenial NULL,
+ securityError SecurityErrors2
+}
+
+AdmissionRequest ::= SEQUENCE --(ARQ)
+ {
+ requestSeqNum RequestSeqNum,
+ callType CallType,
+ callModel CallModel OPTIONAL,
+ endpointIdentifier EndpointIdentifier,
+ destinationInfo SEQUENCE OF AliasAddress OPTIONAL,
+ destCallSignalAddress TransportAddress OPTIONAL,
+ destExtraCallInfo SEQUENCE OF AliasAddress OPTIONAL,
+ srcInfo SEQUENCE OF AliasAddress,
+ srcCallSignalAddress TransportAddress OPTIONAL,
+ bandWidth BandWidth,
+ callReferenceValue CallReferenceValue,
+ nonStandardData NonStandardParameter OPTIONAL,
+ callServices QseriesOptions OPTIONAL,
+ conferenceID ConferenceIdentifier,
+ activeMC BOOLEAN,
+ answerCall BOOLEAN, -- answering a call
+ ...,
+ canMapAlias BOOLEAN, -- can handle alias address
+ callIdentifier CallIdentifier,
+ srcAlternatives SEQUENCE OF Endpoint OPTIONAL,
+ destAlternatives SEQUENCE OF Endpoint OPTIONAL,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ transportQOS TransportQOS OPTIONAL,
+ willSupplyUUIEs BOOLEAN,
+ callLinkage CallLinkage OPTIONAL,
+ gatewayDataRate DataRate OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ desiredProtocols SEQUENCE OF SupportedProtocols OPTIONAL,
+ desiredTunnelledProtocol TunnelledProtocol OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ canMapSrcAlias BOOLEAN
+}
+
+CallType ::= CHOICE {
+ pointToPoint NULL, -- Point-to-point
+ oneToN NULL, -- no interaction (FFS)
+ nToOne NULL, -- no interaction (FFS)
+ nToN NULL, -- interactive (multipoint)
+ ...
+}
+
+CallModel ::= CHOICE {direct NULL,
+ gatekeeperRouted NULL,
+ ...
+}
+
+TransportQOS ::= CHOICE {
+ endpointControlled NULL,
+ gatekeeperControlled NULL,
+ noControl NULL,
+ ...,
+ qOSCapabilities SEQUENCE SIZE (1..256) OF QOSCapability
+}
+
+AdmissionConfirm ::= SEQUENCE --(ACF)
+ {
+ requestSeqNum RequestSeqNum,
+ bandWidth BandWidth,
+ callModel CallModel,
+ destCallSignalAddress TransportAddress,
+ irrFrequency INTEGER(1..65535) OPTIONAL,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ destinationInfo SEQUENCE OF AliasAddress OPTIONAL,
+ destExtraCallInfo SEQUENCE OF AliasAddress OPTIONAL,
+ destinationType EndpointType OPTIONAL,
+ remoteExtensionAddress SEQUENCE OF AliasAddress OPTIONAL,
+ alternateEndpoints SEQUENCE OF Endpoint OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ transportQOS TransportQOS OPTIONAL,
+ willRespondToIRR BOOLEAN,
+ uuiesRequested UUIEsRequested,
+ language SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL,
+ alternateTransportAddresses AlternateTransportAddresses OPTIONAL,
+ useSpecifiedTransport UseSpecifiedTransport OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ usageSpec SEQUENCE OF RasUsageSpecification OPTIONAL,
+ supportedProtocols SEQUENCE OF SupportedProtocols OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ multipleCalls BOOLEAN OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ modifiedSrcInfo SEQUENCE OF AliasAddress OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL
+}
+
+UUIEsRequested ::= SEQUENCE {
+ setup BOOLEAN,
+ callProceeding BOOLEAN,
+ connect BOOLEAN,
+ alerting BOOLEAN,
+ information BOOLEAN,
+ releaseComplete BOOLEAN,
+ facility BOOLEAN,
+ progress BOOLEAN,
+ empty BOOLEAN,
+ ...,
+ status BOOLEAN,
+ statusInquiry BOOLEAN,
+ setupAcknowledge BOOLEAN,
+ notify BOOLEAN
+}
+
+AdmissionReject ::= SEQUENCE --(ARJ)
+ {
+ requestSeqNum RequestSeqNum,
+ rejectReason AdmissionRejectReason,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ altGKInfo AltGKInfo OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ callSignalAddress SEQUENCE OF TransportAddress OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL
+}
+
+AdmissionRejectReason ::= CHOICE {
+ calledPartyNotRegistered NULL, -- cannot translate address
+ invalidPermission NULL, -- permission has expired
+ requestDenied NULL,
+ undefinedReason NULL,
+ callerNotRegistered NULL,
+ routeCallToGatekeeper NULL,
+ invalidEndpointIdentifier NULL,
+ resourceUnavailable NULL,
+ ...,
+ securityDenial NULL,
+ qosControlNotSupported NULL,
+ incompleteAddress NULL,
+ aliasesInconsistent NULL, -- multiple aliases in request
+
+ -- identify distinct people
+ routeCallToSCN SEQUENCE OF PartyNumber,
+ exceedsCallCapacity NULL, -- destination does not have the
+
+ -- capacity for this call
+ collectDestination NULL,
+ collectPIN NULL,
+ genericDataReason NULL,
+ neededFeatureNotSupported NULL,
+ securityError SecurityErrors2,
+ securityDHmismatch NULL, -- mismatch of DH parameters
+ noRouteToDestination NULL, -- destination unreachable
+ unallocatedNumber NULL, -- destination number unassigned
+ registerWithAssignedGK NULL
+}
+
+BandwidthRequest ::= SEQUENCE --(BRQ)
+ {
+ requestSeqNum RequestSeqNum,
+ endpointIdentifier EndpointIdentifier,
+ conferenceID ConferenceIdentifier,
+ callReferenceValue CallReferenceValue,
+ callType CallType OPTIONAL,
+ bandWidth BandWidth,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ callIdentifier CallIdentifier,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ answeredCall BOOLEAN,
+ callLinkage CallLinkage OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ usageInformation RasUsageInformation OPTIONAL,
+ bandwidthDetails SEQUENCE OF BandwidthDetails OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ transportQOS TransportQOS OPTIONAL
+}
+
+BandwidthConfirm ::= SEQUENCE --(BCF)
+ {
+ requestSeqNum RequestSeqNum,
+ bandWidth BandWidth,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ transportQOS TransportQOS OPTIONAL
+}
+
+BandwidthReject ::= SEQUENCE --(BRJ)
+ {
+ requestSeqNum RequestSeqNum,
+ rejectReason BandRejectReason,
+ allowedBandWidth BandWidth,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ altGKInfo AltGKInfo OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+BandRejectReason ::= CHOICE {
+ notBound NULL, -- discovery permission has aged
+ invalidConferenceID NULL, -- possible revision
+ invalidPermission NULL, -- true permission violation
+ insufficientResources NULL,
+ invalidRevision NULL,
+ undefinedReason NULL,
+ ...,
+ securityDenial NULL,
+ securityError SecurityErrors2
+}
+
+LocationRequest ::= SEQUENCE --(LRQ)
+ {
+ requestSeqNum RequestSeqNum,
+ endpointIdentifier EndpointIdentifier OPTIONAL,
+ destinationInfo SEQUENCE OF AliasAddress,
+ nonStandardData NonStandardParameter OPTIONAL,
+ replyAddress TransportAddress,
+ ...,
+ sourceInfo SEQUENCE OF AliasAddress OPTIONAL,
+ canMapAlias BOOLEAN, -- can handle alias address
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ desiredProtocols SEQUENCE OF SupportedProtocols OPTIONAL,
+ desiredTunnelledProtocol TunnelledProtocol OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ hopCount INTEGER(1..255) OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ callIdentifier CallIdentifier OPTIONAL,
+ bandWidth BandWidth OPTIONAL,
+ sourceEndpointInfo SEQUENCE OF AliasAddress OPTIONAL,
+ canMapSrcAlias BOOLEAN,
+ language SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL
+}
+
+LocationConfirm ::= SEQUENCE --(LCF)
+ {
+ requestSeqNum RequestSeqNum,
+ callSignalAddress TransportAddress,
+ rasAddress TransportAddress,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ destinationInfo SEQUENCE OF AliasAddress OPTIONAL,
+ destExtraCallInfo SEQUENCE OF AliasAddress OPTIONAL,
+ destinationType EndpointType OPTIONAL,
+ remoteExtensionAddress SEQUENCE OF AliasAddress OPTIONAL,
+ alternateEndpoints SEQUENCE OF Endpoint OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ alternateTransportAddresses AlternateTransportAddresses OPTIONAL,
+ supportedProtocols SEQUENCE OF SupportedProtocols OPTIONAL,
+ multipleCalls BOOLEAN OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ modifiedSrcInfo SEQUENCE OF AliasAddress OPTIONAL,
+ bandWidth BandWidth OPTIONAL
+}
+
+LocationReject ::= SEQUENCE --(LRJ)
+ {
+ requestSeqNum RequestSeqNum,
+ rejectReason LocationRejectReason,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ altGKInfo AltGKInfo OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL
+}
+
+LocationRejectReason ::= CHOICE {
+ notRegistered NULL,
+ invalidPermission NULL, -- exclusion by administrator or feature
+ requestDenied NULL,
+ undefinedReason NULL,
+ ...,
+ securityDenial NULL,
+ aliasesInconsistent NULL, -- multiple aliases in request
+
+ -- identify distinct people
+ routeCalltoSCN SEQUENCE OF PartyNumber,
+ resourceUnavailable NULL,
+ genericDataReason NULL,
+ neededFeatureNotSupported NULL,
+ hopCountExceeded NULL,
+ incompleteAddress NULL,
+ securityError SecurityErrors2,
+ securityDHmismatch NULL, -- mismatch of DH parameters
+ noRouteToDestination NULL, -- destination unreachable
+ unallocatedNumber NULL -- destination number unassigned
+}
+
+DisengageRequest ::= SEQUENCE --(DRQ)
+ {
+ requestSeqNum RequestSeqNum,
+ endpointIdentifier EndpointIdentifier,
+ conferenceID ConferenceIdentifier,
+ callReferenceValue CallReferenceValue,
+ disengageReason DisengageReason,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ callIdentifier CallIdentifier,
+ gatekeeperIdentifier GatekeeperIdentifier OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ answeredCall BOOLEAN,
+ callLinkage CallLinkage OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ usageInformation RasUsageInformation OPTIONAL,
+ terminationCause CallTerminationCause OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+DisengageReason ::= CHOICE {
+ forcedDrop NULL, -- gatekeeper is forcing the drop
+ normalDrop NULL, -- associated with normal drop
+ undefinedReason NULL,
+ ...
+}
+
+DisengageConfirm ::= SEQUENCE --(DCF)
+ {
+ requestSeqNum RequestSeqNum,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ capacity CallCapacity OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL,
+ usageInformation RasUsageInformation OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL
+}
+
+DisengageReject ::= SEQUENCE --(DRJ)
+ {
+ requestSeqNum RequestSeqNum,
+ rejectReason DisengageRejectReason,
+ nonStandardData NonStandardParameter OPTIONAL,
+ ...,
+ altGKInfo AltGKInfo OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+DisengageRejectReason ::= CHOICE {
+ notRegistered NULL, -- not registered with gatekeeper
+ requestToDropOther NULL, -- cannot request drop for others
+ ...,
+ securityDenial NULL,
+ securityError SecurityErrors2
+}
+
+InfoRequest ::= SEQUENCE --(IRQ)
+ {
+ requestSeqNum RequestSeqNum,
+ callReferenceValue CallReferenceValue,
+ nonStandardData NonStandardParameter OPTIONAL,
+ replyAddress TransportAddress OPTIONAL,
+ ...,
+ callIdentifier CallIdentifier,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ uuiesRequested UUIEsRequested OPTIONAL,
+ callLinkage CallLinkage OPTIONAL,
+ usageInfoRequested RasUsageInfoTypes OPTIONAL,
+ segmentedResponseSupported NULL OPTIONAL,
+ nextSegmentRequested INTEGER(0..65535) OPTIONAL,
+ capacityInfoRequested NULL OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ assignedGatekeeper AlternateGK OPTIONAL
+}
+
+InfoRequestResponse ::= SEQUENCE --(IRR)
+ {
+ nonStandardData NonStandardParameter OPTIONAL,
+ requestSeqNum RequestSeqNum,
+ endpointType EndpointType,
+ endpointIdentifier EndpointIdentifier,
+ rasAddress TransportAddress,
+ callSignalAddress SEQUENCE OF TransportAddress,
+ endpointAlias SEQUENCE OF AliasAddress OPTIONAL,
+ perCallInfo
+ SEQUENCE OF
+ SEQUENCE {nonStandardData NonStandardParameter OPTIONAL,
+ callReferenceValue CallReferenceValue,
+ conferenceID ConferenceIdentifier,
+ originator BOOLEAN OPTIONAL,
+ audio SEQUENCE OF RTPSession OPTIONAL,
+ video SEQUENCE OF RTPSession OPTIONAL,
+ data SEQUENCE OF TransportChannelInfo OPTIONAL,
+ h245 TransportChannelInfo,
+ callSignalling TransportChannelInfo,
+ callType CallType,
+ bandWidth BandWidth,
+ callModel CallModel,
+ ...,
+ callIdentifier CallIdentifier,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ substituteConfIDs SEQUENCE OF ConferenceIdentifier,
+ pdu
+ SEQUENCE OF
+ SEQUENCE {h323pdu H323-UU-PDU,
+ sent BOOLEAN -- TRUE is sent, FALSE is received
+ } OPTIONAL,
+ callLinkage CallLinkage OPTIONAL,
+ usageInformation RasUsageInformation OPTIONAL,
+ circuitInfo CircuitInfo OPTIONAL} OPTIONAL,
+ ...,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ needResponse BOOLEAN,
+ capacity CallCapacity OPTIONAL,
+ irrStatus InfoRequestResponseStatus OPTIONAL,
+ unsolicited BOOLEAN,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+InfoRequestResponseStatus ::= CHOICE {
+ complete NULL,
+ incomplete NULL,
+ segment INTEGER(0..65535),
+ invalidCall NULL,
+ ...
+}
+
+InfoRequestAck ::= SEQUENCE --(IACK)
+ {
+ requestSeqNum RequestSeqNum,
+ nonStandardData NonStandardParameter OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ ...
+}
+
+InfoRequestNak ::= SEQUENCE --(INAK)
+ {
+ requestSeqNum RequestSeqNum,
+ nonStandardData NonStandardParameter OPTIONAL,
+ nakReason InfoRequestNakReason,
+ altGKInfo AltGKInfo OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ ...
+}
+
+InfoRequestNakReason ::= CHOICE {
+ notRegistered NULL, -- not registered with gatekeeper
+ securityDenial NULL,
+ undefinedReason NULL,
+ ...,
+ securityError SecurityErrors2
+}
+
+NonStandardMessage ::= SEQUENCE {
+ requestSeqNum RequestSeqNum,
+ nonStandardData NonStandardParameter,
+ ...,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+UnknownMessageResponse ::= SEQUENCE -- (XRS)
+ {
+ requestSeqNum RequestSeqNum,
+ ...,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ messageNotUnderstood OCTET STRING
+}
+
+RequestInProgress ::= SEQUENCE -- (RIP)
+ {
+ requestSeqNum RequestSeqNum,
+ nonStandardData NonStandardParameter OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ delay INTEGER(1..65535),
+ ...
+}
+
+ResourcesAvailableIndicate ::= SEQUENCE --(RAI)
+ {
+ requestSeqNum RequestSeqNum,
+ protocolIdentifier ProtocolIdentifier,
+ nonStandardData NonStandardParameter OPTIONAL,
+ endpointIdentifier EndpointIdentifier,
+ protocols SEQUENCE OF SupportedProtocols,
+ almostOutOfResources BOOLEAN,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ ...,
+ capacity CallCapacity OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+ResourcesAvailableConfirm ::= SEQUENCE --(RAC)
+ {
+ requestSeqNum RequestSeqNum,
+ protocolIdentifier ProtocolIdentifier,
+ nonStandardData NonStandardParameter OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ ...,
+ genericData SEQUENCE OF GenericData OPTIONAL
+}
+
+ServiceControlIndication ::= SEQUENCE --(SCI)
+ {
+ requestSeqNum RequestSeqNum,
+ nonStandardData NonStandardParameter OPTIONAL,
+ serviceControl SEQUENCE OF ServiceControlSession,
+ endpointIdentifier EndpointIdentifier OPTIONAL,
+ callSpecific
+ SEQUENCE {callIdentifier CallIdentifier,
+ conferenceID ConferenceIdentifier,
+ answeredCall BOOLEAN,
+ ...} OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ ...
+}
+
+ServiceControlResponse ::= SEQUENCE --(SCR)
+ {
+ requestSeqNum RequestSeqNum,
+ result
+ CHOICE {started NULL,
+ failed NULL,
+ stopped NULL,
+ notAvailable NULL,
+ neededFeatureNotSupported NULL,
+ ...} OPTIONAL,
+ nonStandardData NonStandardParameter OPTIONAL,
+ tokens SEQUENCE OF ClearToken OPTIONAL,
+ cryptoTokens SEQUENCE OF CryptoH323Token OPTIONAL,
+ integrityCheckValue ICV OPTIONAL,
+ featureSet FeatureSet OPTIONAL,
+ genericData SEQUENCE OF GenericData OPTIONAL,
+ ...
+}
+
+END -- of ASN.1
+
+-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D
+
diff --git a/epan/dissectors/asn1/h225/h225.cnf b/epan/dissectors/asn1/h225/h225.cnf
new file mode 100644
index 00000000..28a22f83
--- /dev/null
+++ b/epan/dissectors/asn1/h225/h225.cnf
@@ -0,0 +1,961 @@
+# h225.cnf
+# H.225 conformation file
+# Copyright 2004 Anders Broman
+
+#.IMPORT ../h235/h235-exp.cnf
+
+
+
+
+
+
+#.IMPORT ../h245/h245-exp.cnf
+
+#----------------------------------------------------------------------------------------
+#.EXPORTS ONLY_VALS WS_DLL NO_PROT_PREFIX
+H323-UU-PDU/h323-message-body
+FacilityReason
+GatekeeperRejectReason
+UnregRequestReason
+UnregRejectReason
+BandRejectReason
+DisengageReason
+DisengageRejectReason
+InfoRequestNakReason
+AdmissionRejectReason
+LocationRejectReason
+RegistrationRejectReason
+
+#.MODULE_EXPORTS
+RasMessage EXTERN WS_DLL
+NonStandardParameter
+PublicTypeOfNumber
+PrivateTypeOfNumber
+AliasAddress NO_PROT_PREFIX
+PartyNumber
+PresentationIndicator
+ScreeningIndicator
+CallIdentifier
+ConferenceIdentifier
+CircuitIdentifier
+GenericIdentifier
+GenericData
+BandWidth
+TimeToLive
+TransportAddress
+AlternateTransportAddresses
+TransportChannelInfo
+CallReferenceValue
+GloballyUniqueID
+TunnelledProtocol
+IntegrityMechanism
+ICV
+CryptoH323Token
+TransportQOS
+FeatureSet
+CircuitInfo
+EndpointType
+SupportedProtocols
+GatekeeperIdentifier
+ServiceControlSession
+ReleaseCompleteReason EXTERN WS_DLL
+ExtendedAliasAddress_PDU
+#.END
+
+#.PDU
+H323-UserInformation
+RasMessage
+ExtendedAliasAddress
+#.END
+
+#----------------------------------------------------------------------------------------
+
+#.OMIT_ASSIGNMENT
+EncodedFastStartToken
+FastStartToken
+#.END
+
+#.VIRTUAL_ASSGN
+FastStart Setup-UUIE/fastStart
+#.SET_TYPE
+Setup-UUIE/fastStart FastStart
+CallProceeding-UUIE/fastStart FastStart
+Connect-UUIE/fastStart FastStart
+Alerting-UUIE/fastStart FastStart
+Information-UUIE/fastStart FastStart
+Facility-UUIE/fastStart FastStart
+Progress-UUIE/fastStart FastStart
+
+#.VIRTUAL_ASSGN
+H245Control H323-UU-PDU/h245Control
+ParallelH245Control Setup-UUIE/parallelH245Control
+DialedDigits AliasAddress/dialledDigits
+
+#.VIRTUAL_ASSGN
+DestinationInfo AdmissionRequest/destinationInfo
+#.SET_TYPE
+AdmissionRequest/destinationInfo DestinationInfo
+AdmissionConfirm/destinationInfo DestinationInfo
+LocationRequest/destinationInfo DestinationInfo
+LocationConfirm/destinationInfo DestinationInfo
+
+#.VIRTUAL_ASSGN
+H245TransportAddress TransportAddress
+#.SET_TYPE
+Setup-UUIE/h245Address H245TransportAddress
+CallProceeding-UUIE/h245Address H245TransportAddress
+Connect-UUIE/h245Address H245TransportAddress
+Alerting-UUIE/h245Address H245TransportAddress
+Facility-UUIE/h245Address H245TransportAddress
+Progress-UUIE/h245Address H245TransportAddress
+#.FIELD_RENAME
+H245TransportAddress/ipAddress h245IpAddress
+H245TransportAddress/ipAddress/ip h245Ip
+H245TransportAddress/ipAddress/port h245IpPort
+H245TransportAddress/ipSourceRoute h245IpSourceRoute
+H245TransportAddress/ipSourceRoute/route h245Route
+H245TransportAddress/ipSourceRoute/routing h245Routing
+H245TransportAddress/ipxAddress h245IpxAddress
+H245TransportAddress/ipxAddress/port h245IpxPort
+H245TransportAddress/ip6Address h245Ip6Address
+H245TransportAddress/ip6Address/ip h245Ip6
+H245TransportAddress/ip6Address/port h245Ip6port
+DisplayName/language displayName_language
+Endpoint/remoteExtensionAddress/_item ep_remoteExtensionAddress_item
+AdmissionConfirm/remoteExtensionAddress/_item ac_remoteExtensionAddress_item
+
+#.FIELD_ATTR
+H245TransportAddress/ipAddress/ip ABBREV=h245Ip
+H245TransportAddress/ipAddress/port ABBREV=h245IpPort
+H245TransportAddress/ip6Address/ip ABBREV=h245Ip6
+H245TransportAddress/ip6Address/port ABBREV=h245Ip6port
+H245TransportAddress/ipxAddress/port ABBREV=h245IpxPort
+TransportAddress/ipSourceRoute/ip ABBREV=src_route_ipV4
+TransportAddress/ipSourceRoute/port ABBREV=ipV4_src_port
+TransportAddress/ipAddress/ip ABBREV=ipV4
+TransportAddress/ipAddress/port ABBREV=ipV4_port
+TransportAddress/ip6Address/ip ABBREV=ipV6
+TransportAddress/ip6Address/port ABBREV=ipV6_port
+TransportAddress/ipxAddress/port ABBREV=ipx_port
+DisplayName/language ABBREV=displayName_language
+ExtendedAliasAddress/address ABBREV=extAliasAddress
+Endpoint/remoteExtensionAddress/_item ABBREV=remoteExtensionAddress.item
+AdmissionConfirm/remoteExtensionAddress/_item ABBREV=ac_remoteExtensionAddress_item
+
+#.VIRTUAL_ASSGN
+Language Setup-UUIE/language
+#.SET_TYPE
+Connect-UUIE/language Language
+Setup-UUIE/language Language
+RegistrationRequest/language Language
+AdmissionConfirm/language Language
+LocationRequest/language Language
+
+#----------------------------------------------------------------------------------------
+#.TYPE_RENAME
+CallCreditServiceControl/callStartingPoint CallCreditServiceControl_callStartingPoint
+TunnelledProtocol/id TunnelledProtocol_id
+ServiceControlSession/reason ServiceControlSession_reason
+RasUsageSpecification/callStartingPoint RasUsageSpecificationcallStartingPoint
+CapacityReportingSpecification/when CapacityReportingSpecification_when
+RasUsageSpecification/when RasUsageSpecification_when
+TransportAddress/ipAddress/ip IpV4
+#----------------------------------------------------------------------------------------
+#.FIELD_RENAME
+RasUsageSpecification/callStartingPoint/alerting alerting_flg
+CallCreditServiceControl/callStartingPoint/alerting alerting_flg
+UseSpecifiedTransport/annexE annexE_flg
+
+UUIEsRequested/callProceeding callProceeding_flg
+
+CicInfo/cic cic_2_4
+UUIEsRequested/connect connect_bool
+NonStandardIdentifier/object nsiOID
+NonStandardParameter/data nsp_data
+H323-UU-PDU/h323-message-body/empty empty_flg
+RasUsageInfoTypes/endTime endTime_flg
+UUIEsRequested/facility facility_bool
+CallsAvailable/group group_IA5String
+GroupID/group group_IA5String
+
+Setup-UUIE/hopCount hopCount_1_31
+UUIEsRequested/information information_bool
+TransportAddress/ip6Address/ip ipV6
+TransportAddress/ipAddress/ip ipV4
+TransportAddress/ipSourceRoute/ip src_route_ipV4
+RTPSession/multicast multicast_flg
+
+UUIEsRequested/notify notify_bool
+TransportAddress/ipxAddress/port ipx_port
+TransportAddress/ipAddress/port ipV4_port
+TransportAddress/ipSourceRoute/port ipV4_src_port
+TransportAddress/ip6Address/port ipV6_port
+UUIEsRequested/progress progress_bool
+
+Facility-UUIE/reason facilityReason
+UnregistrationRequest/reason unregRequestReason
+ReleaseComplete-UUIE/reason releaseCompleteReason
+BandwidthReject/rejectReason bandRejectReason
+UnregistrationReject/rejectReason unregRejectReason
+RegistrationReject/rejectReason registrationRejectReason
+LocationReject/rejectReason locationRejectReason
+DisengageReject/rejectReason disengageRejectReason
+GatekeeperReject/rejectReason gatekeeperRejectReason
+
+UUIEsRequested/releaseComplete releaseComplete_bool
+UseSpecifiedTransport/sctp sctp_flg
+ServiceControlSession/sessionId sessionId_0_255
+UUIEsRequested/setup setup_bool
+UUIEsRequested/setupAcknowledge setupAcknowledge_bool
+Setup-UUIE/sourceInfo setup-UUIE_sourceInfo
+
+UUIEsRequested/status status_bool
+UUIEsRequested/statusInquiry statusInquiry_bool
+RasUsageInfoTypes/terminationCause terminationCause_flg
+CapacityReportingSpecification/when capacityReportingSpecification_when
+UUIEsRequested/alerting alerting_bool
+
+LocationConfirm/callSignalAddress locationConfirm_callSignalAddress
+
+RasUsageSpecification/callStartingPoint/connect connect_flg
+CallCreditServiceControl/callStartingPoint/connect connect_flg
+
+Alerting-UUIE/destinationInfo uUIE_destinationInfo
+CallProceeding-UUIE/destinationInfo uUIE_destinationInfo
+Connect-UUIE/destinationInfo uUIE_destinationInfo
+Facility-UUIE/destinationInfo uUIE_destinationInfo
+Progress-UUIE/destinationInfo uUIE_destinationInfo
+
+TunnelledProtocol/id tunnelledProtocol_id
+SecurityCapabilities/integrity securityCapabilities_integrity
+
+GenericIdentifier/nonStandard genericIdentifier_nonStandard
+AlternateGK/rasAddress alternateGK_rasAddress
+GatekeeperRequest/rasAddress gatekeeperRequest_rasAddress
+GatekeeperConfirm/rasAddress gatekeeperConfirm_rasAddress
+LocationConfirm/rasAddress locationConfirm_rasAddress
+InfoRequestResponse/rasAddress infoRequestResponse_rasAddress
+
+
+Setup-UUIE/remoteExtensionAddress uUIE_remoteExtensionAddress
+Facility-UUIE/remoteExtensionAddress uUIE_remoteExtensionAddress
+
+VendorIdentifier/vendor vendorIdentifier_vendor
+
+RasUsageSpecification/callStartingPoint ras_callStartingPoint
+
+ReleaseCompleteReason/securityError rLC_securityError
+GatekeeperRejectReason/securityError gkRej_securityError
+RegistrationRejectReason/securityError reg_securityError
+
+CallIdentifier/guid guid
+
+ExtendedAliasAddress/address extAliasAddress
+
+IsupNumber/e164Number isupE164Number
+IsupNumber/dataPartyNumber isupDataPartyNumber
+IsupNumber/telexPartyNumber isupTelexPartyNumber
+IsupNumber/privateNumber isupPrivateNumber
+IsupNumber/nationalStandardPartyNumber isupNationalStandardPartyNumber
+
+#----------------------------------------------------------------------------------------
+#.FN_BODY H323-UU-PDU/h323-message-body VAL_PTR = &message_body_val
+ gint32 message_body_val;
+ h225_packet_info* h225_pi;
+
+ contains_faststart = FALSE;
+ call_id_guid = NULL;
+%(DEFAULT_BODY)s
+ col_append_fstr(actx->pinfo->cinfo, COL_INFO, "CS: %%s ",
+ val_to_str(message_body_val, T_h323_message_body_vals, "<unknown>"));
+
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ if (h225_pi->msg_type == H225_CS) {
+ /* Don't override msg_tag value from IRR */
+ h225_pi->msg_tag = message_body_val;
+ }
+
+ if (call_id_guid) {
+ h225_pi->guid = *call_id_guid;
+ }
+ }
+
+ if (contains_faststart == TRUE )
+ {
+ col_append_str(actx->pinfo->cinfo, COL_INFO, "OpenLogicalChannel " );
+ }
+
+ col_set_fence(actx->pinfo->cinfo,COL_INFO);
+
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY FastStart/_item VAL_PTR = &value_tvb
+ tvbuff_t *value_tvb = NULL;
+ char codec_str[50];
+ h225_packet_info* h225_pi;
+ codec_str[0] = '\0';
+
+%(DEFAULT_BODY)s
+ if (value_tvb && tvb_reported_length(value_tvb)) {
+ dissect_h245_FastStart_OLC(value_tvb, actx->pinfo, tree, codec_str);
+ }
+
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ char temp[50];
+ snprintf(temp, 50, "%%s %%s", h225_pi->frame_label, codec_str);
+ (void) g_strlcpy(h225_pi->frame_label, temp, 50);
+ h225_pi->is_faststart = TRUE;
+ }
+ contains_faststart = TRUE;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY RasMessage VAL_PTR = &rasmessage_value
+ gint32 rasmessage_value;
+ h225_packet_info* h225_pi;
+
+ call_id_guid = NULL;
+%(DEFAULT_BODY)s
+ col_add_fstr(actx->pinfo->cinfo, COL_INFO, "RAS: %%s ",
+ val_to_str(rasmessage_value, h225_RasMessage_vals, "<unknown>"));
+
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->msg_tag = rasmessage_value;
+ if (call_id_guid) {
+ h225_pi->guid = *call_id_guid;
+ }
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR DestinationInfo/_item
+ h225_packet_info* h225_pi;
+
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->is_destinationInfo = TRUE;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY DialedDigits VAL_PTR = &value_tvb
+ tvbuff_t *value_tvb = NULL;
+ guint len = 0;
+ h225_packet_info* h225_pi;
+
+%(DEFAULT_BODY)s
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi && h225_pi->is_destinationInfo == TRUE) {
+ if (value_tvb) {
+ len = tvb_reported_length(value_tvb);
+ /* XXX - should this be allocated as an ephemeral string? */
+ if (len > sizeof h225_pi->dialedDigits - 1)
+ len = sizeof h225_pi->dialedDigits - 1;
+ tvb_memcpy(value_tvb, (guint8*)h225_pi->dialedDigits, 0, len);
+ }
+ h225_pi->dialedDigits[len] = '\0';
+ h225_pi->is_destinationInfo = FALSE;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY H245TransportAddress/ipAddress/ip VAL_PTR = &value_tvb
+ tvbuff_t *value_tvb;
+
+ ipv4_address = 0;
+%(DEFAULT_BODY)s
+ if (value_tvb)
+ ipv4_address = tvb_get_ipv4(value_tvb, 0);
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY H245TransportAddress/ip6Address/ip VAL_PTR = &value_tvb
+ tvbuff_t *value_tvb;
+
+ ipv6_address = ipv6_address_zeros;
+%(DEFAULT_BODY)s
+ if (value_tvb)
+ tvb_get_ipv6(value_tvb, 0, &ipv6_address);
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_PARS H245TransportAddress/ipAddress/port VAL_PTR = &ip_port
+#----------------------------------------------------------------------------------------
+#.FN_PARS H245TransportAddress/ip6Address/port VAL_PTR = &ip_port
+#----------------------------------------------------------------------------------------
+#.FN_BODY ParallelH245Control/_item VAL_PTR = &h245_tvb
+ tvbuff_t *h245_tvb = NULL;
+
+%(DEFAULT_BODY)s
+ next_tvb_add_handle(h245_list, h245_tvb, (h225_h245_in_tree)?tree:NULL, h245dg_handle);
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY H245Control/_item VAL_PTR = &h245_tvb
+ tvbuff_t *h245_tvb = NULL;
+
+%(DEFAULT_BODY)s
+ next_tvb_add_handle(h245_list, h245_tvb, (h225_h245_in_tree)?tree:NULL, h245dg_handle);
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR H323-UU-PDU/h323-message-body/empty
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR H323-UU-PDU/h323-message-body/empty
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_EMPTY;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR Status-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR Status-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_STATUS;
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR Information-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR Information-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_INFORMATION;
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR Progress-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR Progress-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_PROGRESS;
+ if (contains_faststart) {
+ char temp[50];
+ snprintf(temp, 50, "%s OLC (%s)", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"), h225_pi->frame_label);
+ (void) g_strlcpy(h225_pi->frame_label, temp, 50);
+ } else
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR SetupAcknowledge-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR SetupAcknowledge-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_SETUP_ACK;
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR Facility-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR Facility-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_FACILITY;
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR H323-UU-PDU/h245Tunnelling
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_PARS H323-UU-PDU/h245Tunnelling VAL_PTR = &(h225_pi->is_h245Tunneling)
+#----------------------------------------------------------------------------------------
+#.FN_FTR H323-UU-PDU/h245Tunnelling
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR Setup-UUIE
+ h225_packet_info* h225_pi;
+ contains_faststart = FALSE;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR Setup-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_SETUP;
+ if (contains_faststart) {
+ char temp[50];
+ snprintf(temp, 50, "%s OLC (%s)", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"), h225_pi->frame_label);
+ (void) g_strlcpy(h225_pi->frame_label, temp, 50);
+ } else
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR CallProceeding-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR CallProceeding-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_CALL_PROCEDING;
+ if (contains_faststart) {
+ char temp[50];
+ snprintf(temp, 50, "%s OLC (%s)", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"), h225_pi->frame_label);
+ (void) g_strlcpy(h225_pi->frame_label, temp, 50);
+ } else
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR Alerting-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR Alerting-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_ALERTING;
+ if (contains_faststart) {
+ char temp[50];
+ snprintf(temp, 50, "%s OLC (%s)", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"), h225_pi->frame_label);
+ (void) g_strlcpy(h225_pi->frame_label, temp, 50);
+ } else
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR ReleaseComplete-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR ReleaseComplete-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_RELEASE_COMPLET;
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR Connect-UUIE
+ h225_packet_info* h225_pi;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR Connect-UUIE
+ /* Add to packet info */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+ h225_pi->cs_type = H225_CONNECT;
+ if (contains_faststart) {
+ char temp[50];
+ snprintf(temp, 50, "%s OLC (%s)", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"), h225_pi->frame_label);
+ (void) g_strlcpy(h225_pi->frame_label, temp, 50);
+ } else
+ snprintf(h225_pi->frame_label, 50, "%s", val_to_str(h225_pi->cs_type, T_h323_message_body_vals, "<unknown>"));
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_HDR H245TransportAddress
+ h225_packet_info* h225_pi;
+ ipv4_address=0;
+ ipv6_address = ipv6_address_zeros;
+ ip_port=0;
+
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_FTR H245TransportAddress
+ /* we need this info for TAPing */
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+ if (h225_pi) {
+ h225_pi->is_h245 = TRUE;
+ h225_pi->h245_address = ipv4_address;
+ h225_pi->h245_port = ip_port;
+ }
+ if ( !actx->pinfo->fd->visited && h245_handle && ip_port!=0 ) {
+ address src_addr;
+ conversation_t *conv=NULL;
+
+ if (ipv4_address!=0) {
+ set_address(&src_addr, AT_IPv4, 4, &ipv4_address);
+ } else if (memcmp(ipv6_address.bytes, ipv6_address_zeros.bytes, sizeof(ipv6_address.bytes))!=0) {
+ set_address(&src_addr, AT_IPv6, 16, ipv6_address.bytes);
+ } else {
+ return offset;
+ }
+
+ conv=find_conversation(actx->pinfo->num, &src_addr, &src_addr, CONVERSATION_TCP, ip_port, ip_port, NO_ADDR_B|NO_PORT_B);
+ if(!conv){
+ conv=conversation_new(actx->pinfo->num, &src_addr, &src_addr, CONVERSATION_TCP, ip_port, ip_port, NO_ADDR2|NO_PORT2);
+ conversation_set_dissector(conv, h245_handle);
+ }
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY FacilityReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY GatekeeperRejectReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY UnregRequestReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY UnregRejectReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY BandRejectReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY DisengageReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#----------------------------------------------------------------------------------------
+#.FN_BODY DisengageRejectReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY AdmissionRejectReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY LocationRejectReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY RegistrationRejectReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY InfoRequestNakReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY ReleaseCompleteReason VAL_PTR = &value
+ gint32 value;
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+
+%(DEFAULT_BODY)s
+ if (h225_pi != NULL) {
+ h225_pi->reason = value;
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY CallIdentifier/guid
+ tvbuff_t *guid_tvb = NULL;
+
+ actx->value_ptr = &guid_tvb;
+%(DEFAULT_BODY)s
+ if (guid_tvb)
+ tvb_get_ntohguid(guid_tvb, 0, call_id_guid = wmem_new(actx->pinfo->pool, e_guid_t));
+ actx->value_ptr = NULL;
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_PARS GloballyUniqueID VAL_PTR = (tvbuff_t **)actx->value_ptr
+#----------------------------------------------------------------------------------------
+#.FN_HDR RequestSeqNum
+ h225_packet_info* h225_pi;
+ h225_pi = (h225_packet_info*)p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_h225, 0);
+ if (h225_pi != NULL) {
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_PARS RequestSeqNum VAL_PTR = &(h225_pi->requestSeqNum)
+#----------------------------------------------------------------------------------------
+#.FN_FTR RequestSeqNum
+ }
+#.END
+#----------------------------------------------------------------------------------------
+#.FN_BODY H323-UU-PDU/h4501SupplementaryService/_item VAL_PTR = &h4501_tvb
+ tvbuff_t *h4501_tvb = NULL;
+
+%(DEFAULT_BODY)s
+ if (h4501_tvb && tvb_reported_length(h4501_tvb)) {
+ call_dissector(h4501_handle, h4501_tvb, actx->pinfo, tree);
+ }
+#.END
+#----------------------------------------------------------------------------------------
+
+#--- TunnelledProtocol ------------------------------------------------------------------
+
+#.FN_HDR TunnelledProtocol
+ tpOID = "";
+#.FN_FTR TunnelledProtocol
+ tp_handle = dissector_get_string_handle(tp_dissector_table, tpOID);
+#.FN_PARS TunnelledProtocol/id/tunnelledProtocolObjectID
+ FN_VARIANT = _str VAL_PTR = &tpOID
+#.END
+
+#.FN_HDR H323-UU-PDU/tunnelledSignallingMessage
+ tp_handle = NULL;
+#.FN_BODY H323-UU-PDU/tunnelledSignallingMessage/messageContent/_item VAL_PTR = &next_tvb
+ tvbuff_t *next_tvb = NULL;
+
+%(DEFAULT_BODY)s
+ next_tvb_add_handle(tp_list, next_tvb, (h225_tp_in_tree)?tree:NULL, tp_handle);
+#.END
+
+#--- NonStandardParameter ---------------------------------------------------------------
+
+#.FN_PARS
+NonStandardIdentifier/object FN_VARIANT = _str VAL_PTR = &nsiOID
+#.END
+
+#.FN_BODY NonStandardIdentifier VAL_PTR = &value
+ gint32 value;
+
+ nsiOID = "";
+ h221NonStandard = 0;
+
+%(DEFAULT_BODY)s
+ switch (value) {
+ case 0 : /* object */
+ nsp_handle = dissector_get_string_handle(nsp_object_dissector_table, nsiOID);
+ break;
+ case 1 : /* h221NonStandard */
+ nsp_handle = dissector_get_uint_handle(nsp_h221_dissector_table, h221NonStandard);
+ break;
+ default :
+ nsp_handle = NULL;
+ }
+#.END
+
+#.FN_HDR H221NonStandard
+ t35CountryCode = 0;
+ t35Extension = 0;
+ manufacturerCode = 0;
+#.FN_FTR H221NonStandard
+ h221NonStandard = ((t35CountryCode * 256) + t35Extension) * 65536 + manufacturerCode;
+ proto_tree_add_uint(tree, hf_h221Manufacturer, tvb, (offset>>3)-4, 4, h221NonStandard);
+#.FN_PARS
+H221NonStandard/t35CountryCode VAL_PTR = &t35CountryCode
+H221NonStandard/t35Extension VAL_PTR = &t35Extension
+H221NonStandard/manufacturerCode VAL_PTR = &manufacturerCode
+#.END
+
+#.FN_HDR NonStandardParameter
+ nsp_handle = NULL;
+#.FN_BODY NonStandardParameter/data VAL_PTR = &next_tvb
+ tvbuff_t *next_tvb = NULL;
+
+%(DEFAULT_BODY)s
+ if (next_tvb && tvb_reported_length(next_tvb)) {
+ call_dissector((nsp_handle)?nsp_handle:data_handle, next_tvb, actx->pinfo, tree);
+ }
+#.END
+
+#=== Generic Extensible Framework =======================================================
+
+#.FN_HDR GenericData
+ void *priv_data = actx->private_data;
+ gef_ctx_t *gefx;
+
+ /* check if not inherited from FeatureDescriptor */
+ gefx = gef_ctx_get(actx->private_data);
+ if (!gefx) {
+ gefx = gef_ctx_alloc(actx->pinfo->pool, NULL, "GenericData");
+ actx->private_data = gefx;
+ }
+#.FN_FTR
+ actx->private_data = priv_data;
+#.END
+
+#.FN_HDR EnumeratedParameter
+ gef_ctx_t *parent_gefx;
+
+ parent_gefx = gef_ctx_get(actx->private_data);
+ actx->private_data = gef_ctx_alloc(actx->pinfo->pool, parent_gefx, NULL);
+#.FN_FTR
+ actx->private_data = parent_gefx;
+#.END
+
+#----------------------------------------------------------------------------------------
+#.FN_HDR FeatureDescriptor
+ void *priv_data = actx->private_data;
+ actx->private_data = gef_ctx_alloc(actx->pinfo->pool, NULL, "FeatureDescriptor");
+#.FN_FTR
+ actx->private_data = priv_data;
+#.END
+#----------------------------------------------------------------------------------------
+
+#.FN_HDR GenericIdentifier
+ gef_ctx_t *gefx;
+ proto_item* ti;
+#.FN_FTR
+ gef_ctx_update_key(actx->pinfo->pool, gef_ctx_get(actx->private_data));
+ gefx = gef_ctx_get(actx->private_data);
+ if (gefx) {
+ ti = proto_tree_add_string(tree, hf_h225_debug_dissector_try_string, tvb, offset>>3, 0, gefx->key);
+ proto_item_set_hidden(ti);
+ dissector_try_string_new(gef_name_dissector_table, gefx->key, tvb_new_subset_length_caplen(tvb, offset>>3, 0, 0), actx->pinfo, tree, FALSE, actx);
+ }
+ actx->private_data = gefx; /* subdissector could overwrite it */
+#.END
+
+#.FN_BODY GenericIdentifier/standard VAL_PTR = &value_int
+ guint32 value_int = (guint32)-1;
+ gef_ctx_t *gefx;
+
+%(DEFAULT_BODY)s
+ gefx = gef_ctx_get(actx->private_data);
+ if (gefx) gefx->id = wmem_strdup_printf(actx->pinfo->pool, "%%u", value_int);
+#.END
+
+#.FN_BODY GenericIdentifier/oid FN_VARIANT = _str VAL_PTR = &oid_str
+ const gchar *oid_str = NULL;
+ gef_ctx_t *gefx;
+
+%(DEFAULT_BODY)s
+ gefx = gef_ctx_get(actx->private_data);
+ if (gefx) gefx->id = oid_str;
+#.END
+
+#----------------------------------------------------------------------------------------
+#.FN_BODY Content/raw VAL_PTR = &value_tvb
+ tvbuff_t *value_tvb;
+ gef_ctx_t *gefx;
+ proto_item* ti;
+
+%(DEFAULT_BODY)s
+ gefx = gef_ctx_get(actx->private_data);
+ if (gefx) {
+ ti = proto_tree_add_string(tree, hf_h225_debug_dissector_try_string, tvb, offset>>3, 0, gefx->key);
+ proto_item_set_hidden(ti);
+ dissector_try_string(gef_content_dissector_table, gefx->key, value_tvb, actx->pinfo, %(TREE)s, actx);
+ }
+#.END
+
+#=== end of GEF =========================================================================
+
+# TBCD-STRING is additionally constrained
+# parameter stack is used for passing this constraint
+
+#.FN_HDR TBCD-STRING
+ int min_len, max_len;
+ gboolean has_extension;
+
+ get_size_constraint_from_stack(actx, "TBCD_STRING", &min_len, &max_len, &has_extension);
+#.FN_PARS TBCD-STRING
+MIN_VAL = min_len
+MAX_VAL = max_len
+EXT = has_extension
+#.END
+
+
+#.TYPE_ATTR
+H221NonStandard/t35CountryCode TYPE = FT_UINT32 DISPLAY = BASE_DEC STRINGS = VALS(T35CountryCode_vals)
+TransportAddress/ipAddress/ip TYPE = FT_IPv4 DISPLAY = BASE_NONE STRINGS = NULL
+TransportAddress/ip6Address/ip TYPE = FT_IPv6 DISPLAY = BASE_NONE STRINGS = NULL
+H245TransportAddress/ipAddress/ip TYPE = FT_IPv4 DISPLAY = BASE_NONE STRINGS = NULL
+H245TransportAddress/ip6Address/ip TYPE = FT_IPv6 DISPLAY = BASE_NONE STRINGS = NULL
+VendorIdentifier/productId TYPE = FT_STRING DISPLAY = BASE_NONE STRINGS = NULL
+VendorIdentifier/versionId TYPE = FT_STRING DISPLAY = BASE_NONE STRINGS = NULL
+H323-UserInformation/user-data/protocol-discriminator TYPE = FT_UINT32 DISPLAY = BASE_DEC|BASE_EXT_STRING STRINGS = &q931_protocol_discriminator_vals_ext
+H323-UU-PDU/tunnelledSignallingMessage/messageContent/_item TYPE = FT_UINT32 DISPLAY = BASE_DEC
+NonStandardParameter/data TYPE = FT_UINT32 DISPLAY = BASE_DEC
+FastStart/_item TYPE = FT_UINT32 DISPLAY = BASE_DEC
+ParallelH245Control/_item TYPE = FT_UINT32 DISPLAY = BASE_DEC
+H245Control/_item TYPE = FT_UINT32 DISPLAY = BASE_DEC
+GloballyUniqueID TYPE = FT_GUID DISPLAY = BASE_NONE
+H323-UU-PDU/h4501SupplementaryService/_item TYPE = FT_UINT32 DISPLAY = BASE_DEC
+#.END
diff --git a/epan/dissectors/asn1/h225/packet-h225-template.c b/epan/dissectors/asn1/h225/packet-h225-template.c
new file mode 100644
index 00000000..ab85ddbf
--- /dev/null
+++ b/epan/dissectors/asn1/h225/packet-h225-template.c
@@ -0,0 +1,1146 @@
+/* packet-h225.c
+ * Routines for h225 packet dissection
+ * Copyright 2005, Anders Broman <anders.broman@ericsson.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * To quote the author of the previous H323/H225/H245 dissector:
+ * "This is a complete replacement of the previous limitied dissector
+ * that Ronnie was crazy enough to write by hand. It was a lot of time
+ * to hack it by hand, but it is incomplete and buggy and it is good when
+ * it will go away."
+ * Ronnie did a great job and all the VoIP users had made good use of it!
+ * Credit to Tomas Kukosa for developing the asn2wrs compiler.
+ *
+ */
+
+#include "config.h"
+
+#include <epan/packet.h>
+#include <epan/conversation.h>
+#include <epan/proto_data.h>
+
+#include <epan/prefs.h>
+#include <epan/oids.h>
+#include <epan/next_tvb.h>
+#include <epan/asn1.h>
+#include <epan/t35.h>
+#include <epan/tap.h>
+#include <epan/stat_tap_ui.h>
+#include <epan/rtd_table.h>
+#include "packet-frame.h"
+#include "packet-tpkt.h"
+#include "packet-per.h"
+#include "packet-h225.h"
+#include "packet-h235.h"
+#include "packet-h245.h"
+#include "packet-h323.h"
+#include "packet-q931.h"
+#include "packet-tls.h"
+
+#define PNAME "H323-MESSAGES"
+#define PSNAME "H.225.0"
+#define PFNAME "h225"
+
+#define UDP_PORT_RAS_RANGE "1718-1719"
+#define TCP_PORT_CS 1720
+#define TLS_PORT_CS 1300
+
+void proto_register_h225(void);
+static h225_packet_info* create_h225_packet_info(packet_info *pinfo);
+static void ras_call_matching(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, h225_packet_info *pi);
+
+/* Item of ras request list*/
+typedef struct _h225ras_call_t {
+ guint32 requestSeqNum;
+ e_guid_t guid;
+ guint32 req_num; /* frame number request seen */
+ guint32 rsp_num; /* frame number response seen */
+ nstime_t req_time; /* arrival time of request */
+ gboolean responded; /* true, if request has been responded */
+ struct _h225ras_call_t *next_call; /* pointer to next ras request with same SequenceNumber and conversation handle */
+} h225ras_call_t;
+
+
+/* Item of ras-request key list*/
+typedef struct _h225ras_call_info_key {
+ guint reqSeqNum;
+ conversation_t *conversation;
+} h225ras_call_info_key;
+
+/* Global Memory Chunks for lists and Global hash tables*/
+
+static wmem_map_t *ras_calls[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
+
+/* functions, needed using ras-request and halfcall matching*/
+static h225ras_call_t * find_h225ras_call(h225ras_call_info_key *h225ras_call_key ,int category);
+static h225ras_call_t * new_h225ras_call(h225ras_call_info_key *h225ras_call_key, packet_info *pinfo, e_guid_t *guid, int category);
+static h225ras_call_t * append_h225ras_call(h225ras_call_t *prev_call, packet_info *pinfo, e_guid_t *guid, int category);
+
+
+static dissector_handle_t h225ras_handle;
+static dissector_handle_t data_handle;
+/* Subdissector tables */
+static dissector_table_t nsp_object_dissector_table;
+static dissector_table_t nsp_h221_dissector_table;
+static dissector_table_t tp_dissector_table;
+static dissector_table_t gef_name_dissector_table;
+static dissector_table_t gef_content_dissector_table;
+
+
+static dissector_handle_t h245_handle=NULL;
+static dissector_handle_t h245dg_handle=NULL;
+static dissector_handle_t h4501_handle=NULL;
+
+static dissector_handle_t nsp_handle;
+static dissector_handle_t tp_handle;
+
+static next_tvb_list_t *h245_list;
+static next_tvb_list_t *tp_list;
+
+/* Initialize the protocol and registered fields */
+static int h225_tap = -1;
+static int proto_h225 = -1;
+
+static int hf_h221Manufacturer = -1;
+static int hf_h225_ras_req_frame = -1;
+static int hf_h225_ras_rsp_frame = -1;
+static int hf_h225_ras_dup = -1;
+static int hf_h225_ras_deltatime = -1;
+static int hf_h225_debug_dissector_try_string = -1;
+
+#include "packet-h225-hf.c"
+
+/* Initialize the subtree pointers */
+static gint ett_h225 = -1;
+#include "packet-h225-ett.c"
+
+/* Preferences */
+static guint h225_tls_port = TLS_PORT_CS;
+static gboolean h225_reassembly = TRUE;
+static gboolean h225_h245_in_tree = TRUE;
+static gboolean h225_tp_in_tree = TRUE;
+
+/* Global variables */
+static guint32 ipv4_address;
+static ws_in6_addr ipv6_address;
+static ws_in6_addr ipv6_address_zeros = {{0}};
+static guint32 ip_port;
+static gboolean contains_faststart = FALSE;
+static e_guid_t *call_id_guid;
+
+/* NonStandardParameter */
+static const char *nsiOID;
+static guint32 h221NonStandard;
+static guint32 t35CountryCode;
+static guint32 t35Extension;
+static guint32 manufacturerCode;
+
+/* TunnelledProtocol */
+static const char *tpOID;
+
+static const value_string ras_message_category[] = {
+ { 0, "Gatekeeper "},
+ { 1, "Registration "},
+ { 2, "UnRegistration"},
+ { 3, "Admission "},
+ { 4, "Bandwidth "},
+ { 5, "Disengage "},
+ { 6, "Location "},
+ { 0, NULL }
+};
+
+typedef enum _ras_type {
+ RAS_REQUEST,
+ RAS_CONFIRM,
+ RAS_REJECT,
+ RAS_OTHER
+}ras_type;
+
+typedef enum _ras_category {
+ RAS_GATEKEEPER,
+ RAS_REGISTRATION,
+ RAS_UNREGISTRATION,
+ RAS_ADMISSION,
+ RAS_BANDWIDTH,
+ RAS_DISENGAGE,
+ RAS_LOCATION,
+ RAS_OTHERS
+}ras_category;
+
+#define NUM_RAS_STATS 7
+
+static tap_packet_status
+h225rassrt_packet(void *phs, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *phi, tap_flags_t flags _U_)
+{
+ rtd_data_t* rtd_data = (rtd_data_t*)phs;
+ rtd_stat_table* rs = &rtd_data->stat_table;
+ const h225_packet_info *pi=(const h225_packet_info *)phi;
+
+ ras_type rasmsg_type = RAS_OTHER;
+ ras_category rascategory = RAS_OTHERS;
+
+ if (pi->msg_type != H225_RAS || pi->msg_tag == -1) {
+ /* No RAS Message or uninitialized msg_tag -> return */
+ return TAP_PACKET_DONT_REDRAW;
+ }
+
+ if (pi->msg_tag < 21) {
+ /* */
+ rascategory = (ras_category)(pi->msg_tag / 3);
+ rasmsg_type = (ras_type)(pi->msg_tag % 3);
+ }
+ else {
+ /* No SRT yet (ToDo) */
+ return TAP_PACKET_DONT_REDRAW;
+ }
+
+ switch(rasmsg_type) {
+
+ case RAS_REQUEST:
+ if(pi->is_duplicate){
+ rs->time_stats[rascategory].req_dup_num++;
+ }
+ else {
+ rs->time_stats[rascategory].open_req_num++;
+ }
+ break;
+
+ case RAS_CONFIRM:
+ /* no break - delay stats are identical for Confirm and Reject */
+ case RAS_REJECT:
+ if(pi->is_duplicate){
+ /* Duplicate is ignored */
+ rs->time_stats[rascategory].rsp_dup_num++;
+ }
+ else if (!pi->request_available) {
+ /* no request was seen, ignore response */
+ rs->time_stats[rascategory].disc_rsp_num++;
+ }
+ else {
+ rs->time_stats[rascategory].open_req_num--;
+ time_stat_update(&(rs->time_stats[rascategory].rtd[0]),&(pi->delta_time), pinfo);
+ }
+ break;
+
+ default:
+ return TAP_PACKET_DONT_REDRAW;
+ }
+ return TAP_PACKET_REDRAW;
+}
+
+#include "packet-h225-fn.c"
+
+/* Forward declaration we need below */
+void proto_reg_handoff_h225(void);
+
+/*
+ * Functions needed for Ras-Hash-Table
+ */
+
+/* compare 2 keys */
+static gint h225ras_call_equal(gconstpointer k1, gconstpointer k2)
+{
+ const h225ras_call_info_key* key1 = (const h225ras_call_info_key*) k1;
+ const h225ras_call_info_key* key2 = (const h225ras_call_info_key*) k2;
+
+ return (key1->reqSeqNum == key2->reqSeqNum &&
+ key1->conversation == key2->conversation);
+}
+
+/* calculate a hash key */
+static guint h225ras_call_hash(gconstpointer k)
+{
+ const h225ras_call_info_key* key = (const h225ras_call_info_key*) k;
+
+ return key->reqSeqNum + GPOINTER_TO_UINT(key->conversation);
+}
+
+
+h225ras_call_t * find_h225ras_call(h225ras_call_info_key *h225ras_call_key ,int category)
+{
+ h225ras_call_t *h225ras_call = (h225ras_call_t *)wmem_map_lookup(ras_calls[category], h225ras_call_key);
+
+ return h225ras_call;
+}
+
+h225ras_call_t * new_h225ras_call(h225ras_call_info_key *h225ras_call_key, packet_info *pinfo, e_guid_t *guid, int category)
+{
+ h225ras_call_info_key *new_h225ras_call_key;
+ h225ras_call_t *h225ras_call = NULL;
+
+
+ /* Prepare the value data.
+ "req_num" and "rsp_num" are frame numbers;
+ frame numbers are 1-origin, so we use 0
+ to mean "we don't yet know in which frame
+ the reply for this call appears". */
+ new_h225ras_call_key = wmem_new(wmem_file_scope(), h225ras_call_info_key);
+ new_h225ras_call_key->reqSeqNum = h225ras_call_key->reqSeqNum;
+ new_h225ras_call_key->conversation = h225ras_call_key->conversation;
+ h225ras_call = wmem_new(wmem_file_scope(), h225ras_call_t);
+ h225ras_call->req_num = pinfo->num;
+ h225ras_call->rsp_num = 0;
+ h225ras_call->requestSeqNum = h225ras_call_key->reqSeqNum;
+ h225ras_call->responded = FALSE;
+ h225ras_call->next_call = NULL;
+ h225ras_call->req_time=pinfo->abs_ts;
+ h225ras_call->guid=*guid;
+ /* store it */
+ wmem_map_insert(ras_calls[category], new_h225ras_call_key, h225ras_call);
+
+ return h225ras_call;
+}
+
+h225ras_call_t * append_h225ras_call(h225ras_call_t *prev_call, packet_info *pinfo, e_guid_t *guid, int category _U_)
+{
+ h225ras_call_t *h225ras_call = NULL;
+
+ /* Prepare the value data.
+ "req_num" and "rsp_num" are frame numbers;
+ frame numbers are 1-origin, so we use 0
+ to mean "we don't yet know in which frame
+ the reply for this call appears". */
+ h225ras_call = wmem_new(wmem_file_scope(), h225ras_call_t);
+ h225ras_call->req_num = pinfo->num;
+ h225ras_call->rsp_num = 0;
+ h225ras_call->requestSeqNum = prev_call->requestSeqNum;
+ h225ras_call->responded = FALSE;
+ h225ras_call->next_call = NULL;
+ h225ras_call->req_time=pinfo->abs_ts;
+ h225ras_call->guid=*guid;
+
+ prev_call->next_call = h225ras_call;
+ return h225ras_call;
+}
+
+static void
+h225_frame_end(void)
+{
+ /* next_tvb pointers are allocated in packet scope, clear it. */
+ h245_list = NULL;
+ tp_list = NULL;
+}
+
+static int
+dissect_h225_H323UserInformation(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+{
+ proto_item *it;
+ proto_tree *tr;
+ int offset = 0;
+ h225_packet_info* h225_pi;
+
+ /* Init struct for collecting h225_packet_info */
+ h225_pi = create_h225_packet_info(pinfo);
+ h225_pi->msg_type = H225_CS;
+ p_add_proto_data(pinfo->pool, pinfo, proto_h225, 0, h225_pi);
+
+ register_frame_end_routine(pinfo, h225_frame_end);
+ h245_list = next_tvb_list_new(pinfo->pool);
+ tp_list = next_tvb_list_new(pinfo->pool);
+
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
+ col_clear(pinfo->cinfo, COL_INFO);
+
+ it=proto_tree_add_protocol_format(tree, proto_h225, tvb, 0, -1, PSNAME" CS");
+ tr=proto_item_add_subtree(it, ett_h225);
+
+ offset = dissect_H323_UserInformation_PDU(tvb, pinfo, tr, NULL);
+
+ if (h245_list->count){
+ col_append_str(pinfo->cinfo, COL_PROTOCOL, "/");
+ col_set_fence(pinfo->cinfo, COL_PROTOCOL);
+ }
+
+ next_tvb_call(h245_list, pinfo, tree, h245dg_handle, data_handle);
+ next_tvb_call(tp_list, pinfo, tree, NULL, data_handle);
+
+ tap_queue_packet(h225_tap, pinfo, h225_pi);
+
+ return offset;
+}
+static int
+dissect_h225_h225_RasMessage(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_){
+ proto_item *it;
+ proto_tree *tr;
+ guint32 offset=0;
+ h225_packet_info* h225_pi;
+
+ /* Init struct for collecting h225_packet_info */
+ h225_pi = create_h225_packet_info(pinfo);
+ h225_pi->msg_type = H225_RAS;
+ p_add_proto_data(pinfo->pool, pinfo, proto_h225, 0, h225_pi);
+
+ register_frame_end_routine(pinfo, h225_frame_end);
+ h245_list = next_tvb_list_new(pinfo->pool);
+ tp_list = next_tvb_list_new(pinfo->pool);
+
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
+
+ it=proto_tree_add_protocol_format(tree, proto_h225, tvb, offset, -1, PSNAME" RAS");
+ tr=proto_item_add_subtree(it, ett_h225);
+
+ offset = dissect_RasMessage_PDU(tvb, pinfo, tr, NULL);
+
+ ras_call_matching(tvb, pinfo, tr, h225_pi);
+
+ next_tvb_call(h245_list, pinfo, tree, h245dg_handle, data_handle);
+ next_tvb_call(tp_list, pinfo, tree, NULL, data_handle);
+
+ tap_queue_packet(h225_tap, pinfo, h225_pi);
+
+ return offset;
+}
+
+
+/* The following values represent the size of their valuestring arrays */
+
+#define RAS_MSG_TYPES (sizeof(h225_RasMessage_vals) / sizeof(value_string))
+#define CS_MSG_TYPES (sizeof(T_h323_message_body_vals) / sizeof(value_string))
+
+#define GRJ_REASONS (sizeof(GatekeeperRejectReason_vals) / sizeof(value_string))
+#define RRJ_REASONS (sizeof(RegistrationRejectReason_vals) / sizeof(value_string))
+#define URQ_REASONS (sizeof(UnregRequestReason_vals) / sizeof(value_string))
+#define URJ_REASONS (sizeof(UnregRejectReason_vals) / sizeof(value_string))
+#define ARJ_REASONS (sizeof(AdmissionRejectReason_vals) / sizeof(value_string))
+#define BRJ_REASONS (sizeof(BandRejectReason_vals) / sizeof(value_string))
+#define DRQ_REASONS (sizeof(DisengageReason_vals) / sizeof(value_string))
+#define DRJ_REASONS (sizeof(DisengageRejectReason_vals) / sizeof(value_string))
+#define LRJ_REASONS (sizeof(LocationRejectReason_vals) / sizeof(value_string))
+#define IRQNAK_REASONS (sizeof(InfoRequestNakReason_vals) / sizeof(value_string))
+#define REL_CMP_REASONS (sizeof(h225_ReleaseCompleteReason_vals) / sizeof(value_string))
+#define FACILITY_REASONS (sizeof(FacilityReason_vals) / sizeof(value_string))
+
+/* TAP STAT INFO */
+typedef enum
+{
+ MESSAGE_TYPE_COLUMN = 0,
+ COUNT_COLUMN
+} h225_stat_columns;
+
+typedef struct _h225_table_item {
+ guint count; /* Message count */
+ guint table_idx; /* stat_table index */
+} h225_table_item_t;
+
+static stat_tap_table_item h225_stat_fields[] = {{TABLE_ITEM_STRING, TAP_ALIGN_LEFT, "Message Type or Reason", "%-25s"}, {TABLE_ITEM_UINT, TAP_ALIGN_RIGHT, "Count", "%d"}};
+
+static guint ras_msg_idx[RAS_MSG_TYPES];
+static guint cs_msg_idx[CS_MSG_TYPES];
+
+static guint grj_reason_idx[GRJ_REASONS];
+static guint rrj_reason_idx[RRJ_REASONS];
+static guint urq_reason_idx[URQ_REASONS];
+static guint urj_reason_idx[URJ_REASONS];
+static guint arj_reason_idx[ARJ_REASONS];
+static guint brj_reason_idx[BRJ_REASONS];
+static guint drq_reason_idx[DRQ_REASONS];
+static guint drj_reason_idx[DRJ_REASONS];
+static guint lrj_reason_idx[LRJ_REASONS];
+static guint irqnak_reason_idx[IRQNAK_REASONS];
+static guint rel_cmp_reason_idx[REL_CMP_REASONS];
+static guint facility_reason_idx[FACILITY_REASONS];
+
+static guint other_idx;
+
+static void h225_stat_init(stat_tap_table_ui* new_stat)
+{
+ const char *table_name = "H.225 Messages and Message Reasons";
+ int num_fields = sizeof(h225_stat_fields)/sizeof(stat_tap_table_item);
+ stat_tap_table *table;
+ int row_idx = 0, msg_idx;
+ stat_tap_table_item_type items[sizeof(h225_stat_fields)/sizeof(stat_tap_table_item)];
+
+ table = stat_tap_find_table(new_stat, table_name);
+ if (table) {
+ if (new_stat->stat_tap_reset_table_cb) {
+ new_stat->stat_tap_reset_table_cb(table);
+ }
+ return;
+ }
+
+ memset(items, 0x0, sizeof(items));
+ table = stat_tap_init_table(table_name, num_fields, 0, NULL);
+ stat_tap_add_table(new_stat, table);
+
+ items[MESSAGE_TYPE_COLUMN].type = TABLE_ITEM_STRING;
+ items[COUNT_COLUMN].type = TABLE_ITEM_UINT;
+ items[COUNT_COLUMN].value.uint_value = 0;
+
+ /* Add a row for each value type */
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ h225_RasMessage_vals[msg_idx].strptr
+ ? h225_RasMessage_vals[msg_idx].strptr
+ : "Unknown RAS message";
+ ras_msg_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (h225_RasMessage_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ T_h323_message_body_vals[msg_idx].strptr
+ ? T_h323_message_body_vals[msg_idx].strptr
+ : "Unknown CS message";
+ cs_msg_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (T_h323_message_body_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ GatekeeperRejectReason_vals[msg_idx].strptr
+ ? GatekeeperRejectReason_vals[msg_idx].strptr
+ : "Unknown gatekeeper reject reason";
+ grj_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (GatekeeperRejectReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ RegistrationRejectReason_vals[msg_idx].strptr
+ ? RegistrationRejectReason_vals[msg_idx].strptr
+ : "Unknown registration reject reason";
+ rrj_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (RegistrationRejectReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ UnregRequestReason_vals[msg_idx].strptr
+ ? UnregRequestReason_vals[msg_idx].strptr
+ : "Unknown unregistration request reason";
+ urq_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (UnregRequestReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ UnregRejectReason_vals[msg_idx].strptr
+ ? UnregRejectReason_vals[msg_idx].strptr
+ : "Unknown unregistration reject reason";
+ urj_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (UnregRejectReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ AdmissionRejectReason_vals[msg_idx].strptr
+ ? AdmissionRejectReason_vals[msg_idx].strptr
+ : "Unknown admission reject reason";
+ arj_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (AdmissionRejectReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ BandRejectReason_vals[msg_idx].strptr
+ ? BandRejectReason_vals[msg_idx].strptr
+ : "Unknown band reject reason";
+ brj_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (BandRejectReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ DisengageReason_vals[msg_idx].strptr
+ ? DisengageReason_vals[msg_idx].strptr
+ : "Unknown disengage reason";
+ drq_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (DisengageReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ DisengageRejectReason_vals[msg_idx].strptr
+ ? DisengageRejectReason_vals[msg_idx].strptr
+ : "Unknown disengage reject reason";
+ drj_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (DisengageRejectReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ LocationRejectReason_vals[msg_idx].strptr
+ ? LocationRejectReason_vals[msg_idx].strptr
+ : "Unknown location reject reason";
+ lrj_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (LocationRejectReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ InfoRequestNakReason_vals[msg_idx].strptr
+ ? InfoRequestNakReason_vals[msg_idx].strptr
+ : "Unknown info request nak reason";
+ irqnak_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (InfoRequestNakReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ h225_ReleaseCompleteReason_vals[msg_idx].strptr
+ ? h225_ReleaseCompleteReason_vals[msg_idx].strptr
+ : "Unknown release complete reason";
+ rel_cmp_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (h225_ReleaseCompleteReason_vals[msg_idx].strptr);
+
+ msg_idx = 0;
+ do
+ {
+ items[MESSAGE_TYPE_COLUMN].value.string_value =
+ FacilityReason_vals[msg_idx].strptr
+ ? FacilityReason_vals[msg_idx].strptr
+ : "Unknown facility reason";
+ facility_reason_idx[msg_idx] = row_idx;
+
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ row_idx++;
+ msg_idx++;
+ } while (FacilityReason_vals[msg_idx].strptr);
+
+
+ items[MESSAGE_TYPE_COLUMN].value.string_value = "Unknown H.225 message";
+ stat_tap_init_table_row(table, row_idx, num_fields, items);
+ other_idx = row_idx;
+}
+
+static tap_packet_status
+h225_stat_packet(void *tapdata, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *hpi_ptr, tap_flags_t flags _U_)
+{
+ stat_data_t* stat_data = (stat_data_t*)tapdata;
+ const h225_packet_info *hpi = (const h225_packet_info *)hpi_ptr;
+ int tag_idx = -1;
+ int reason_idx = -1;
+
+ if(hpi->msg_tag < 0) { /* uninitialized */
+ return TAP_PACKET_DONT_REDRAW;
+ }
+
+ switch (hpi->msg_type) {
+
+ case H225_RAS:
+ tag_idx = ras_msg_idx[MIN(hpi->msg_tag, (int)RAS_MSG_TYPES-1)];
+
+ /* Look for reason tag */
+ if(hpi->reason < 0) { /* uninitialized */
+ break;
+ }
+
+ switch(hpi->msg_tag) {
+
+ case 2: /* GRJ */
+ reason_idx = grj_reason_idx[MIN(hpi->reason, (int)GRJ_REASONS-1)];
+ break;
+ case 5: /* RRJ */
+ reason_idx = rrj_reason_idx[MIN(hpi->reason, (int)RRJ_REASONS-1)];
+ break;
+ case 6: /* URQ */
+ reason_idx = urq_reason_idx[MIN(hpi->reason, (int)URQ_REASONS-1)];
+ break;
+ case 8: /* URJ */
+ reason_idx = urj_reason_idx[MIN(hpi->reason, (int)URJ_REASONS-1)];
+ break;
+ case 11: /* ARJ */
+ reason_idx = arj_reason_idx[MIN(hpi->reason, (int)ARJ_REASONS-1)];
+ break;
+ case 14: /* BRJ */
+ reason_idx = brj_reason_idx[MIN(hpi->reason, (int)BRJ_REASONS-1)];
+ break;
+ case 15: /* DRQ */
+ reason_idx = drq_reason_idx[MIN(hpi->reason, (int)DRQ_REASONS-1)];
+ break;
+ case 17: /* DRJ */
+ reason_idx = drj_reason_idx[MIN(hpi->reason, (int)DRJ_REASONS-1)];
+ break;
+ case 20: /* LRJ */
+ reason_idx = lrj_reason_idx[MIN(hpi->reason, (int)LRJ_REASONS-1)];
+ break;
+ case 29: /* IRQ Nak */
+ reason_idx = irqnak_reason_idx[MIN(hpi->reason, (int)IRQNAK_REASONS-1)];
+ break;
+ default:
+ /* do nothing */
+ break;
+ }
+
+ break;
+
+ case H225_CS:
+ tag_idx = cs_msg_idx[MIN(hpi->msg_tag, (int)CS_MSG_TYPES-1)];
+
+ /* Look for reason tag */
+ if(hpi->reason < 0) { /* uninitialized */
+ break;
+ }
+
+ switch(hpi->msg_tag) {
+
+ case 5: /* ReleaseComplete */
+ reason_idx = rel_cmp_reason_idx[MIN(hpi->reason, (int)REL_CMP_REASONS-1)];
+ break;
+ case 6: /* Facility */
+ reason_idx = facility_reason_idx[MIN(hpi->reason, (int)FACILITY_REASONS-1)];
+ break;
+ default:
+ /* do nothing */
+ break;
+ }
+
+ break;
+
+ case H225_OTHERS:
+ default:
+ tag_idx = other_idx;
+ }
+
+ if (tag_idx >= 0) {
+ stat_tap_table*table = g_array_index(stat_data->stat_tap_data->tables, stat_tap_table*, 0);
+ stat_tap_table_item_type* msg_data = stat_tap_get_field_data(table, tag_idx, COUNT_COLUMN);;
+ msg_data->value.uint_value++;
+ stat_tap_set_field_data(table, tag_idx, COUNT_COLUMN, msg_data);
+
+ if (reason_idx >= 0) {
+ msg_data = stat_tap_get_field_data(table, reason_idx, COUNT_COLUMN);;
+ msg_data->value.uint_value++;
+ stat_tap_set_field_data(table, reason_idx, COUNT_COLUMN, msg_data);
+ }
+
+ return TAP_PACKET_REDRAW;
+ }
+ return TAP_PACKET_DONT_REDRAW;
+}
+
+static void
+h225_stat_reset(stat_tap_table* table)
+{
+ guint element;
+ stat_tap_table_item_type* item_data;
+
+ for (element = 0; element < table->num_elements; element++)
+ {
+ item_data = stat_tap_get_field_data(table, element, COUNT_COLUMN);
+ item_data->value.uint_value = 0;
+ stat_tap_set_field_data(table, element, COUNT_COLUMN, item_data);
+ }
+}
+
+/*--- proto_register_h225 -------------------------------------------*/
+void proto_register_h225(void) {
+
+ /* List of fields */
+ static hf_register_info hf[] = {
+ { &hf_h221Manufacturer,
+ { "H.225 Manufacturer", "h225.Manufacturer", FT_UINT32, BASE_HEX,
+ VALS(H221ManufacturerCode_vals), 0, "h225.H.221 Manufacturer", HFILL }},
+
+ { &hf_h225_ras_req_frame,
+ { "RAS Request Frame", "h225.ras.reqframe", FT_FRAMENUM, BASE_NONE,
+ NULL, 0, NULL, HFILL }},
+
+ { &hf_h225_ras_rsp_frame,
+ { "RAS Response Frame", "h225.ras.rspframe", FT_FRAMENUM, BASE_NONE,
+ NULL, 0, NULL, HFILL }},
+
+ { &hf_h225_ras_dup,
+ { "Duplicate RAS Message", "h225.ras.dup", FT_UINT32, BASE_DEC,
+ NULL, 0, NULL, HFILL }},
+
+ { &hf_h225_ras_deltatime,
+ { "RAS Service Response Time", "h225.ras.timedelta", FT_RELATIVE_TIME, BASE_NONE,
+ NULL, 0, "Timedelta between RAS-Request and RAS-Response", HFILL }},
+
+ { &hf_h225_debug_dissector_try_string,
+ { "*** DEBUG dissector_try_string", "h225.debug.dissector_try_string", FT_STRING, BASE_NONE,
+ NULL, 0, NULL, HFILL }},
+
+#include "packet-h225-hfarr.c"
+ };
+
+ /* List of subtrees */
+ static gint *ett[] = {
+ &ett_h225,
+#include "packet-h225-ettarr.c"
+ };
+
+ static tap_param h225_stat_params[] = {
+ { PARAM_FILTER, "filter", "Filter", NULL, TRUE }
+ };
+
+ static stat_tap_table_ui h225_stat_table = {
+ REGISTER_STAT_GROUP_TELEPHONY,
+ "H.225",
+ PFNAME,
+ "h225,counter",
+ h225_stat_init,
+ h225_stat_packet,
+ h225_stat_reset,
+ NULL,
+ NULL,
+ sizeof(h225_stat_fields)/sizeof(stat_tap_table_item), h225_stat_fields,
+ sizeof(h225_stat_params)/sizeof(tap_param), h225_stat_params,
+ NULL,
+ 0
+ };
+
+ module_t *h225_module;
+ int i, proto_h225_ras;
+
+ /* Register protocol */
+ proto_h225 = proto_register_protocol(PNAME, PSNAME, PFNAME);
+
+ /* Create a "fake" protocol to get proper display strings for SRT dialogs */
+ proto_h225_ras = proto_register_protocol("H.225 RAS", "H.225 RAS", "h225_ras");
+
+ /* Register fields and subtrees */
+ proto_register_field_array(proto_h225, hf, array_length(hf));
+ proto_register_subtree_array(ett, array_length(ett));
+
+ h225_module = prefs_register_protocol(proto_h225, proto_reg_handoff_h225);
+ prefs_register_uint_preference(h225_module, "tls.port",
+ "H.225 TLS Port",
+ "H.225 Server TLS Port",
+ 10, &h225_tls_port);
+ prefs_register_bool_preference(h225_module, "reassembly",
+ "Reassemble H.225 messages spanning multiple TCP segments",
+ "Whether the H.225 dissector should reassemble messages spanning multiple TCP segments."
+ " To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
+ &h225_reassembly);
+ prefs_register_bool_preference(h225_module, "h245_in_tree",
+ "Display tunnelled H.245 inside H.225.0 tree",
+ "ON - display tunnelled H.245 inside H.225.0 tree, OFF - display tunnelled H.245 in root tree after H.225.0",
+ &h225_h245_in_tree);
+ prefs_register_bool_preference(h225_module, "tp_in_tree",
+ "Display tunnelled protocols inside H.225.0 tree",
+ "ON - display tunnelled protocols inside H.225.0 tree, OFF - display tunnelled protocols in root tree after H.225.0",
+ &h225_tp_in_tree);
+
+ register_dissector(PFNAME, dissect_h225_H323UserInformation, proto_h225);
+ register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225);
+ h225ras_handle = register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225);
+
+ nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter Object", proto_h225, FT_STRING, STRING_CASE_SENSITIVE);
+ nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter h221", proto_h225, FT_UINT32, BASE_HEX);
+ tp_dissector_table = register_dissector_table("h225.tp", "H.225 Tunnelled Protocol", proto_h225, FT_STRING, STRING_CASE_SENSITIVE);
+ gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework Name", proto_h225, FT_STRING, STRING_CASE_SENSITIVE);
+ gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework Content", proto_h225, FT_STRING, STRING_CASE_SENSITIVE);
+
+ for(i=0;i<7;i++) {
+ ras_calls[i] = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), h225ras_call_hash, h225ras_call_equal);
+ }
+
+ h225_tap = register_tap(PFNAME);
+
+ register_rtd_table(proto_h225_ras, PFNAME, NUM_RAS_STATS, 1, ras_message_category, h225rassrt_packet, NULL);
+
+ register_stat_tap_table_ui(&h225_stat_table);
+
+ oid_add_from_string("Version 1","0.0.8.2250.0.1");
+ oid_add_from_string("Version 2","0.0.8.2250.0.2");
+ oid_add_from_string("Version 3","0.0.8.2250.0.3");
+ oid_add_from_string("Version 4","0.0.8.2250.0.4");
+ oid_add_from_string("Version 5","0.0.8.2250.0.5");
+ oid_add_from_string("Version 6","0.0.8.2250.0.6");
+}
+
+
+/*--- proto_reg_handoff_h225 ---------------------------------------*/
+void
+proto_reg_handoff_h225(void)
+{
+ static gboolean h225_prefs_initialized = FALSE;
+ static dissector_handle_t q931_tpkt_handle;
+ static guint saved_h225_tls_port;
+
+ if (!h225_prefs_initialized) {
+ dissector_add_uint_range_with_preference("udp.port", UDP_PORT_RAS_RANGE, h225ras_handle);
+
+ h245_handle = find_dissector("h245");
+ h245dg_handle = find_dissector("h245dg");
+ h4501_handle = find_dissector_add_dependency("h4501", proto_h225);
+ data_handle = find_dissector("data");
+ h225_prefs_initialized = TRUE;
+ q931_tpkt_handle = find_dissector("q931.tpkt");
+ } else {
+ ssl_dissector_delete(saved_h225_tls_port, q931_tpkt_handle);
+ }
+
+ saved_h225_tls_port = h225_tls_port;
+ ssl_dissector_add(saved_h225_tls_port, q931_tpkt_handle);
+}
+
+static h225_packet_info* create_h225_packet_info(packet_info *pinfo)
+{
+ h225_packet_info* pi = wmem_new0(pinfo->pool, h225_packet_info);
+
+ pi->msg_type = H225_OTHERS;
+ pi->cs_type = H225_OTHER;
+ pi->msg_tag = -1;
+ pi->reason = -1;
+
+ return pi;
+}
+
+/*
+ The following function contains the routines for RAS request/response matching.
+ A RAS response matches with a request, if both messages have the same
+ RequestSequenceNumber, belong to the same IP conversation and belong to the same
+ RAS "category" (e.g. Admission, Registration).
+
+ We use hashtables to access the lists of RAS calls (request/response pairs).
+ We have one hashtable for each RAS category. The hashkeys consist of the
+ non-unique 16-bit RequestSequenceNumber and values representing the conversation.
+
+ In big capture files, we might get different requests with identical keys.
+ These requests aren't necessarily duplicates. They might be valid new requests.
+ At the moment we just use the timedelta between the last valid and the new request
+ to decide if the new request is a duplicate or not. There might be better ways.
+ Two thresholds are defined below.
+
+ However the decision is made, another problem arises. We can't just add those
+ requests to our hashtables. Instead we create lists of RAS calls with identical keys.
+ The hashtables for RAS calls contain now pointers to the first RAS call in a list of
+ RAS calls with identical keys.
+ These lists aren't expected to contain more than 3 items and are usually single item
+ lists. So we don't need an expensive but intelligent way to access these lists
+ (e.g. hashtables). Just walk through such a list.
+*/
+
+#define THRESHOLD_REPEATED_RESPONDED_CALL 300
+#define THRESHOLD_REPEATED_NOT_RESPONDED_CALL 1800
+
+static void ras_call_matching(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, h225_packet_info *pi)
+{
+ proto_item *hidden_item;
+ conversation_t* conversation = NULL;
+ h225ras_call_info_key h225ras_call_key;
+ h225ras_call_t *h225ras_call = NULL;
+ nstime_t delta;
+ guint msg_category;
+
+ if(pi->msg_type == H225_RAS && pi->msg_tag < 21) {
+ /* make RAS request/response matching only for tags from 0 to 20 for now */
+
+ msg_category = pi->msg_tag / 3;
+ if(pi->msg_tag % 3 == 0) { /* Request Message */
+ conversation = find_or_create_conversation(pinfo);
+
+ /* prepare the key data */
+ h225ras_call_key.reqSeqNum = pi->requestSeqNum;
+ h225ras_call_key.conversation = conversation;
+
+ /* look up the request */
+ h225ras_call = find_h225ras_call(&h225ras_call_key ,msg_category);
+
+ if (h225ras_call != NULL) {
+ /* We've seen requests with this reqSeqNum, with the same
+ source and destination, before - do we have
+ *this* request already? */
+ /* Walk through list of ras requests with identical keys */
+ do {
+ if (pinfo->num == h225ras_call->req_num) {
+ /* We have seen this request before -> do nothing */
+ break;
+ }
+
+ /* if end of list is reached, exit loop and decide if request is duplicate or not. */
+ if (h225ras_call->next_call == NULL) {
+ if ( (pinfo->num > h225ras_call->rsp_num && h225ras_call->rsp_num != 0
+ && pinfo->abs_ts.secs > (h225ras_call->req_time.secs + THRESHOLD_REPEATED_RESPONDED_CALL) )
+ ||(pinfo->num > h225ras_call->req_num && h225ras_call->rsp_num == 0
+ && pinfo->abs_ts.secs > (h225ras_call->req_time.secs + THRESHOLD_REPEATED_NOT_RESPONDED_CALL) ) )
+ {
+ /* if last request has been responded
+ and this request appears after last response (has bigger frame number)
+ and last request occurred more than 300 seconds ago,
+ or if last request hasn't been responded
+ and this request appears after last request (has bigger frame number)
+ and last request occurred more than 1800 seconds ago,
+ we decide that we have a new request */
+ /* Append new ras call to list */
+ h225ras_call = append_h225ras_call(h225ras_call, pinfo, &pi->guid, msg_category);
+ } else {
+ /* No, so it's a duplicate request.
+ Mark it as such. */
+ pi->is_duplicate = TRUE;
+ hidden_item = proto_tree_add_uint(tree, hf_h225_ras_dup, tvb, 0,0, pi->requestSeqNum);
+ proto_item_set_hidden(hidden_item);
+ }
+ break;
+ }
+ h225ras_call = h225ras_call->next_call;
+ } while (h225ras_call != NULL );
+ }
+ else {
+ h225ras_call = new_h225ras_call(&h225ras_call_key, pinfo, &pi->guid, msg_category);
+ }
+
+ /* add link to response frame, if available */
+ if(h225ras_call && h225ras_call->rsp_num != 0){
+ proto_item *ti =
+ proto_tree_add_uint_format(tree, hf_h225_ras_rsp_frame, tvb, 0, 0, h225ras_call->rsp_num,
+ "The response to this request is in frame %u",
+ h225ras_call->rsp_num);
+ proto_item_set_generated(ti);
+ }
+
+ /* end of request message handling*/
+ }
+ else { /* Confirm or Reject Message */
+ conversation = find_conversation_pinfo(pinfo, 0);
+ if (conversation != NULL) {
+ /* look only for matching request, if
+ matching conversation is available. */
+ h225ras_call_key.reqSeqNum = pi->requestSeqNum;
+ h225ras_call_key.conversation = conversation;
+ h225ras_call = find_h225ras_call(&h225ras_call_key ,msg_category);
+ if(h225ras_call) {
+ /* find matching ras_call in list of ras calls with identical keys */
+ do {
+ if (pinfo->num == h225ras_call->rsp_num) {
+ /* We have seen this response before -> stop now with matching ras call */
+ break;
+ }
+
+ /* Break when list end is reached */
+ if(h225ras_call->next_call == NULL) {
+ break;
+ }
+ h225ras_call = h225ras_call->next_call;
+ } while (h225ras_call != NULL) ;
+
+ if (!h225ras_call) {
+ return;
+ }
+
+ /* if this is an ACF, ARJ or DCF, DRJ, give guid to tap and make it filterable */
+ if (msg_category == 3 || msg_category == 5) {
+ pi->guid = h225ras_call->guid;
+ hidden_item = proto_tree_add_guid(tree, hf_h225_guid, tvb, 0, GUID_LEN, &pi->guid);
+ proto_item_set_hidden(hidden_item);
+ }
+
+ if (h225ras_call->rsp_num == 0) {
+ /* We have not yet seen a response to that call, so
+ this must be the first response; remember its
+ frame number. */
+ h225ras_call->rsp_num = pinfo->num;
+ }
+ else {
+ /* We have seen a response to this call - but was it
+ *this* response? */
+ if (h225ras_call->rsp_num != pinfo->num) {
+ /* No, so it's a duplicate response.
+ Mark it as such. */
+ pi->is_duplicate = TRUE;
+ hidden_item = proto_tree_add_uint(tree, hf_h225_ras_dup, tvb, 0,0, pi->requestSeqNum);
+ proto_item_set_hidden(hidden_item);
+ }
+ }
+
+ if(h225ras_call->req_num != 0){
+ proto_item *ti;
+ h225ras_call->responded = TRUE;
+ pi->request_available = TRUE;
+
+ /* Indicate the frame to which this is a reply. */
+ ti = proto_tree_add_uint_format(tree, hf_h225_ras_req_frame, tvb, 0, 0, h225ras_call->req_num,
+ "This is a response to a request in frame %u", h225ras_call->req_num);
+ proto_item_set_generated(ti);
+
+ /* Calculate RAS Service Response Time */
+ nstime_delta(&delta, &pinfo->abs_ts, &h225ras_call->req_time);
+ pi->delta_time = delta; /* give it to tap */
+
+ /* display Ras Service Response Time and make it filterable */
+ ti = proto_tree_add_time(tree, hf_h225_ras_deltatime, tvb, 0, 0, &(pi->delta_time));
+ proto_item_set_generated(ti);
+ }
+ }
+ }
+ }
+ }
+}
+
+/*
+ * Editor modelines - https://www.wireshark.org/tools/modelines.html
+ *
+ * Local Variables:
+ * c-basic-offset: 2
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=2 tabstop=8 expandtab:
+ * :indentSize=2:tabSize=8:noTabs=true:
+ */
diff --git a/epan/dissectors/asn1/h225/packet-h225-template.h b/epan/dissectors/asn1/h225/packet-h225-template.h
new file mode 100644
index 00000000..6a5501d6
--- /dev/null
+++ b/epan/dissectors/asn1/h225/packet-h225-template.h
@@ -0,0 +1,83 @@
+/* packet-h225.h
+ * Routines for h225 packet dissection
+ * Copyright 2005, Anders Broman <anders.broman@ericsson.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef PACKET_H225_H
+#define PACKET_H225_H
+
+typedef enum _h225_msg_type {
+ H225_RAS,
+ H225_CS,
+ H225_OTHERS
+} h225_msg_type;
+
+typedef enum _h225_cs_type {
+ H225_SETUP,
+ H225_CALL_PROCEDING,
+ H225_CONNECT,
+ H225_ALERTING,
+ H225_INFORMATION,
+ H225_RELEASE_COMPLET,
+ H225_FACILITY,
+ H225_PROGRESS,
+ H225_EMPTY,
+ H225_STATUS,
+ H225_STATUS_INQUIRY,
+ H225_SETUP_ACK,
+ H225_NOTIFY,
+ H225_OTHER
+} h225_cs_type;
+
+typedef struct _h225_packet_info {
+ h225_msg_type msg_type; /* ras or cs message */
+ h225_cs_type cs_type; /* cs message type */
+ gint msg_tag; /* message tag*/
+ gint reason; /* reason tag, if available */
+ guint requestSeqNum; /* request sequence number of ras-message, if available */
+ e_guid_t guid; /* globally unique call id */
+ gboolean is_duplicate; /* true, if this is a repeated message */
+ gboolean request_available; /* true, if response matches to a request */
+ nstime_t delta_time; /* this is the RAS response time delay */
+ /* added for h225 conversations analysis */
+ gboolean is_faststart; /* true, if faststart field is included */
+ gboolean is_h245;
+ gboolean is_h245Tunneling;
+ guint32 h245_address;
+ guint16 h245_port;
+ gchar dialedDigits[129]; /* Dialed Digits in the LRQ and LCF used for voip analysis */
+ gboolean is_destinationInfo;
+ gchar frame_label[50]; /* the Frame label used by graph_analysis, what is a abreviation of cinfo */
+} h225_packet_info;
+
+/*
+ * the following allows TAP code access to the messages
+ * without having to duplicate it. With MSVC and a
+ * libwireshark.dll, we need a special declaration.
+ */
+
+#include <epan/asn1.h>
+#include "packet-per.h"
+
+#include "packet-h225-exp.h"
+
+#endif /* PACKET_H225_H */
+
+/*
+ * Editor modelines - https://www.wireshark.org/tools/modelines.html
+ *
+ * Local Variables:
+ * c-basic-offset: 2
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=2 tabstop=8 expandtab:
+ * :indentSize=2:tabSize=8:noTabs=true:
+ */
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-29 23:28:41 +0000