1102 lines
26 KiB
Groff
1102 lines
26 KiB
Groff
MEDIA-GATEWAY-CONTROL {itu-t(0) recommendation(0) h(8) h248(248) modules(0)
|
|
media-gateway-control(0) version3(3)}
|
|
--
|
|
-- Module MEDIA-GATEWAY-CONTROL (H.248.1:09/2005)
|
|
-- See also ITU-T H.248.1 v3 (2005) Amend. 1 (05/2008)
|
|
--
|
|
--DEFINITIONS AUTOMATIC TAGS ::=
|
|
--BEGIN
|
|
-- Has been modified to pass through the ASN2ETH compiler
|
|
-- (we dont support automatic tags yet so the tags had to be added by
|
|
-- hand)
|
|
DEFINITIONS IMPLICIT TAGS ::=
|
|
BEGIN
|
|
MegacoMessage ::= SEQUENCE
|
|
{
|
|
authHeader [0] AuthenticationHeader OPTIONAL,
|
|
mess [1] Message
|
|
}
|
|
|
|
AuthenticationHeader ::= SEQUENCE
|
|
{
|
|
secParmIndex [0] SecurityParmIndex,
|
|
seqNum [1] SequenceNum,
|
|
ad [2] AuthData
|
|
}
|
|
|
|
SecurityParmIndex ::= OCTET STRING(SIZE(4))
|
|
|
|
SequenceNum ::= OCTET STRING(SIZE(4))
|
|
|
|
AuthData ::= OCTET STRING (SIZE (12..32))
|
|
|
|
Message ::= SEQUENCE
|
|
{
|
|
version [0] INTEGER(0..99),
|
|
-- The version of the protocol defined here is equal to 3.
|
|
mId [1] MId, -- Name/address of message originator
|
|
messageBody [2] CHOICE
|
|
{
|
|
messageError [0] ErrorDescriptor,
|
|
transactions [1] SEQUENCE OF Transaction
|
|
},
|
|
...
|
|
}
|
|
|
|
MId ::= CHOICE
|
|
{
|
|
ip4Address [0] IP4Address,
|
|
ip6Address [1] IP6Address,
|
|
domainName [2] DomainName,
|
|
deviceName [3] PathName,
|
|
mtpAddress [4] MtpAddress,
|
|
-- Addressing structure of mtpAddress:
|
|
-- 25 - 15 0
|
|
-- | PC | NI |
|
|
-- 24 - 14 bits 2 bits
|
|
-- NOTE - 14 bits are defined for international use.
|
|
-- Two national options exist where the point code is 16 or 24 bits.
|
|
-- To octet align the mtpAddress, the MSBs shall be encoded as 0s.
|
|
...
|
|
}
|
|
-- Wireshark specific
|
|
MtpAddress ::= OCTET STRING(SIZE(2..4))
|
|
|
|
DomainName ::= SEQUENCE
|
|
{
|
|
name [0] IA5String,
|
|
-- The name starts with an alphanumeric digit followed by a sequence
|
|
-- of alphanumeric digits, hyphens and dots. No two dots shall occur
|
|
-- consecutively.
|
|
|
|
portNumber [1] INTEGER(0..65535) OPTIONAL
|
|
}
|
|
|
|
IP4Address ::= SEQUENCE
|
|
{
|
|
address [0] OCTET STRING (SIZE(4)),
|
|
portNumber [1] INTEGER(0..65535) OPTIONAL
|
|
}
|
|
|
|
IP6Address ::= SEQUENCE
|
|
{
|
|
address [0] OCTET STRING (SIZE(16)),
|
|
portNumber [1] INTEGER(0..65535) OPTIONAL
|
|
}
|
|
|
|
PathName ::= IA5String(SIZE (1..64))
|
|
-- See A.3
|
|
|
|
Transaction ::= CHOICE
|
|
{
|
|
transactionRequest [0] TransactionRequest,
|
|
transactionPending [1] TransactionPending,
|
|
transactionReply [2] TransactionReply,
|
|
transactionResponseAck [3] TransactionResponseAck,
|
|
-- use of response acks is dependent on underlying transport
|
|
...,
|
|
segmentReply [4] SegmentReply
|
|
}
|
|
|
|
TransactionId ::= INTEGER(0..4294967295) -- 32-bit unsigned integer
|
|
|
|
TransactionRequest ::= SEQUENCE
|
|
{
|
|
transactionId [0] TransactionId,
|
|
actions [1] SEQUENCE OF ActionRequest,
|
|
...
|
|
}
|
|
|
|
TransactionPending ::= SEQUENCE
|
|
{
|
|
transactionId [0] TransactionId,
|
|
...
|
|
}
|
|
|
|
TransactionReply ::= SEQUENCE
|
|
{
|
|
transactionId [0] TransactionId,
|
|
immAckRequired [1] NULL OPTIONAL,
|
|
transactionResult [2] CHOICE
|
|
{
|
|
transactionError [0]ErrorDescriptor,
|
|
actionReplies [1] SEQUENCE OF ActionReply
|
|
},
|
|
...,
|
|
segmentNumber [3] SegmentNumber OPTIONAL,
|
|
segmentationComplete [4] NULL OPTIONAL
|
|
}
|
|
|
|
SegmentReply ::= SEQUENCE
|
|
{
|
|
transactionId [0] TransactionId,
|
|
segmentNumber [1] SegmentNumber,
|
|
segmentationComplete [2] NULL OPTIONAL,
|
|
...
|
|
}
|
|
|
|
SegmentNumber ::= INTEGER(0..65535)
|
|
|
|
TransactionResponseAck ::= SEQUENCE OF TransactionAck
|
|
|
|
TransactionAck ::= SEQUENCE
|
|
{
|
|
firstAck [0] TransactionId,
|
|
lastAck [1] TransactionId OPTIONAL
|
|
}
|
|
|
|
ErrorDescriptor ::= SEQUENCE
|
|
{
|
|
errorCode [0] ErrorCode,
|
|
errorText [1] ErrorText OPTIONAL
|
|
}
|
|
|
|
ErrorCode ::= INTEGER(0..65535)
|
|
-- See clause 14 for IANA considerations with respect to error codes
|
|
|
|
ErrorText ::= IA5String
|
|
|
|
ContextID ::= INTEGER(0..4294967295)
|
|
-- Context NULL Value: 0
|
|
-- Context CHOOSE Value: 4294967294 (0xFFFFFFFE)
|
|
-- Context ALL Value: 4294967295 (0xFFFFFFFF)
|
|
|
|
ActionRequest ::= SEQUENCE
|
|
{
|
|
contextId [0] ContextID,
|
|
contextRequest [1] ContextRequest OPTIONAL,
|
|
contextAttrAuditReq [2] ContextAttrAuditRequest OPTIONAL,
|
|
commandRequests [3] SEQUENCE OF CommandRequest
|
|
}
|
|
|
|
ActionReply ::= SEQUENCE
|
|
{
|
|
contextId [0] ContextID,
|
|
errorDescriptor [1] ErrorDescriptor OPTIONAL,
|
|
contextReply [2] ContextRequest OPTIONAL,
|
|
commandReply [3] SEQUENCE OF CommandReply
|
|
}
|
|
|
|
-- Wireshark Specific
|
|
ContextIDinList ::= INTEGER(0..4294967295)
|
|
|
|
ContextRequest ::= SEQUENCE
|
|
{
|
|
priority [0] INTEGER(0..15) OPTIONAL,
|
|
emergency [1] BOOLEAN OPTIONAL,
|
|
topologyReq [2] SEQUENCE OF TopologyRequest OPTIONAL,
|
|
...,
|
|
iepscallind [3] BOOLEAN OPTIONAL,
|
|
contextProp [4] SEQUENCE OF PropertyParm OPTIONAL,
|
|
|
|
-- Wireshark Specific
|
|
-- contextList [5] SEQUENCE OF ContextID OPTIONAL
|
|
contextList [5] SEQUENCE OF ContextIDinList OPTIONAL
|
|
-- Currently the way that WS tracing code's persistent data is
|
|
-- organized disallows to relate a request to multiple contexts
|
|
}
|
|
|
|
-- When returning a contextList, the contextId in the ActionReply construct will
|
|
-- return the contextId from the associated ActionRequest.
|
|
|
|
ContextAttrAuditRequest ::= SEQUENCE
|
|
{
|
|
topology [0] NULL OPTIONAL,
|
|
emergency [1] NULL OPTIONAL,
|
|
priority [2] NULL OPTIONAL,
|
|
...,
|
|
iepscallind [3] NULL OPTIONAL,
|
|
contextPropAud [4] SEQUENCE OF IndAudPropertyParm OPTIONAL,
|
|
selectpriority [5] INTEGER(0..15) OPTIONAL,
|
|
-- to select given priority
|
|
selectemergency [6] BOOLEAN OPTIONAL,
|
|
-- to select if emergency set/not set (T/F)
|
|
selectiepscallind [7] BOOLEAN OPTIONAL,
|
|
-- to select if IEPS set/not set (T/F)
|
|
selectLogic [8] SelectLogic OPTIONAL -- default is AND
|
|
}
|
|
|
|
SelectLogic ::= CHOICE
|
|
{
|
|
andAUDITSelect [0] NULL, -- all filter conditions satisfied
|
|
orAUDITSelect [1] NULL, -- at least one filter condition satisfied
|
|
...
|
|
}
|
|
|
|
CommandRequest ::= SEQUENCE
|
|
{
|
|
command [0] Command,
|
|
optional [1] NULL OPTIONAL,
|
|
wildcardReturn [2] NULL OPTIONAL,
|
|
...
|
|
}
|
|
|
|
Command ::= CHOICE
|
|
{
|
|
addReq [0] AmmRequest,
|
|
moveReq [1] AmmRequest,
|
|
modReq [2] AmmRequest,
|
|
-- Add, Move, Modify requests have the same parameters
|
|
subtractReq [3] SubtractRequest,
|
|
auditCapRequest [4] AuditRequest,
|
|
auditValueRequest [5] AuditRequest,
|
|
notifyReq [6] NotifyRequest,
|
|
serviceChangeReq [7] ServiceChangeRequest,
|
|
...
|
|
}
|
|
|
|
CommandReply ::= CHOICE
|
|
{
|
|
addReply [0] AmmsReply,
|
|
moveReply [1] AmmsReply,
|
|
modReply [2] AmmsReply,
|
|
subtractReply [3] AmmsReply,
|
|
-- Add, Move, Modify, Subtract replies have the same parameters
|
|
auditCapReply [4] AuditReply,
|
|
auditValueReply [5] AuditReply,
|
|
notifyReply [6] NotifyReply,
|
|
serviceChangeReply [7] ServiceChangeReply,
|
|
...
|
|
}
|
|
|
|
TopologyRequest ::= SEQUENCE
|
|
{
|
|
terminationFrom [0] TerminationID,
|
|
terminationTo [1] TerminationID,
|
|
topologyDirection [2] ENUMERATED
|
|
{
|
|
bothway(0),
|
|
isolate(1),
|
|
oneway(2)
|
|
},
|
|
...,
|
|
streamID [3]StreamID OPTIONAL,
|
|
topologyDirectionExtension [4] ENUMERATED
|
|
{
|
|
onewayexternal(0),
|
|
onewayboth(1),
|
|
...
|
|
} OPTIONAL
|
|
}
|
|
|
|
AmmRequest ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationIDList,
|
|
descriptors [1] SEQUENCE OF AmmDescriptor,
|
|
-- At most one descriptor of each type (see AmmDescriptor)
|
|
-- allowed in the sequence.
|
|
...
|
|
}
|
|
|
|
AmmDescriptor ::= CHOICE
|
|
{
|
|
mediaDescriptor [0] MediaDescriptor,
|
|
modemDescriptor [1] ModemDescriptor,
|
|
muxDescriptor [2] MuxDescriptor,
|
|
eventsDescriptor [3] EventsDescriptor,
|
|
eventBufferDescriptor [4] EventBufferDescriptor,
|
|
signalsDescriptor [5] SignalsDescriptor,
|
|
digitMapDescriptor [6] DigitMapDescriptor,
|
|
auditDescriptor [7] AuditDescriptor,
|
|
...,
|
|
statisticsDescriptor [8] StatisticsDescriptor
|
|
}
|
|
|
|
AmmsReply ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationIDList,
|
|
terminationAudit [1]TerminationAudit OPTIONAL,
|
|
...
|
|
}
|
|
|
|
SubtractRequest ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationIDList,
|
|
auditDescriptor [1] AuditDescriptor OPTIONAL,
|
|
...
|
|
}
|
|
|
|
AuditRequest ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationID,
|
|
auditDescriptor [1] AuditDescriptor,
|
|
...,
|
|
terminationIDList [3] TerminationIDList OPTIONAL
|
|
}
|
|
-- terminationID shall contain the first termination in the
|
|
-- list when using the terminationIDList construct in AuditRequest
|
|
|
|
AuditReply ::= CHOICE
|
|
{
|
|
contextAuditResult [0] TerminationIDList,
|
|
error [1] ErrorDescriptor,
|
|
auditResult [2] AuditResult,
|
|
...,
|
|
auditResultTermList [3] TermListAuditResult
|
|
}
|
|
|
|
AuditResult ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationID,
|
|
terminationAuditResult [1] TerminationAudit
|
|
}
|
|
|
|
TermListAuditResult ::= SEQUENCE
|
|
{
|
|
terminationIDList [0] TerminationIDList,
|
|
terminationAuditResult [1] TerminationAudit,
|
|
...
|
|
}
|
|
|
|
TerminationAudit ::= SEQUENCE OF AuditReturnParameter
|
|
|
|
AuditReturnParameter ::= CHOICE
|
|
{
|
|
errorDescriptor [0] ErrorDescriptor,
|
|
mediaDescriptor [1] MediaDescriptor,
|
|
modemDescriptor [2] ModemDescriptor,
|
|
muxDescriptor [3] MuxDescriptor,
|
|
eventsDescriptor [4] EventsDescriptor,
|
|
eventBufferDescriptor [5] EventBufferDescriptor,
|
|
signalsDescriptor [6] SignalsDescriptor,
|
|
digitMapDescriptor [7] DigitMapDescriptor,
|
|
observedEventsDescriptor [8] ObservedEventsDescriptor,
|
|
statisticsDescriptor [9] StatisticsDescriptor,
|
|
packagesDescriptor [10] PackagesDescriptor,
|
|
emptyDescriptors [11] AuditDescriptor,
|
|
...
|
|
}
|
|
|
|
AuditDescriptor ::= SEQUENCE
|
|
{
|
|
auditToken [0] BIT STRING
|
|
{
|
|
muxToken(0),
|
|
modemToken(1),
|
|
mediaToken(2),
|
|
eventsToken(3),
|
|
signalsToken(4),
|
|
digitMapToken(5),
|
|
statsToken(6),
|
|
observedEventsToken(7),
|
|
packagesToken(8),
|
|
eventBufferToken(9)
|
|
} OPTIONAL,
|
|
...,
|
|
auditPropertyToken [1] SEQUENCE OF IndAuditParameter OPTIONAL
|
|
}
|
|
|
|
IndAuditParameter ::= CHOICE
|
|
{
|
|
indaudmediaDescriptor [0] IndAudMediaDescriptor,
|
|
indaudeventsDescriptor [1] IndAudEventsDescriptor,
|
|
indaudeventBufferDescriptor [2] IndAudEventBufferDescriptor,
|
|
indaudsignalsDescriptor [3] IndAudSignalsDescriptor,
|
|
indauddigitMapDescriptor [4] IndAudDigitMapDescriptor,
|
|
indaudstatisticsDescriptor [5] IndAudStatisticsDescriptor,
|
|
indaudpackagesDescriptor [6] IndAudPackagesDescriptor,
|
|
...
|
|
}
|
|
|
|
IndAudMediaDescriptor ::= SEQUENCE
|
|
{
|
|
termStateDescr [0] IndAudTerminationStateDescriptor OPTIONAL,
|
|
streams [1] CHOICE
|
|
{
|
|
oneStream [0] IndAudStreamParms,
|
|
multiStream [1] SEQUENCE OF IndAudStreamDescriptor
|
|
} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
IndAudStreamDescriptor ::= SEQUENCE
|
|
{
|
|
streamID [0] StreamID,
|
|
streamParms [1] IndAudStreamParms
|
|
}
|
|
|
|
IndAudStreamParms ::= SEQUENCE
|
|
{
|
|
localControlDescriptor [0] IndAudLocalControlDescriptor OPTIONAL,
|
|
localDescriptor [1] IndAudLocalRemoteDescriptor OPTIONAL,
|
|
remoteDescriptor [2] IndAudLocalRemoteDescriptor OPTIONAL,
|
|
...,
|
|
statisticsDescriptor [3] IndAudStatisticsDescriptor OPTIONAL
|
|
}
|
|
|
|
IndAudLocalControlDescriptor ::= SEQUENCE
|
|
{
|
|
streamMode [0] NULL OPTIONAL,
|
|
reserveValue [1] NULL OPTIONAL,
|
|
reserveGroup [2] NULL OPTIONAL,
|
|
propertyParms [3] SEQUENCE OF IndAudPropertyParm OPTIONAL,
|
|
...,
|
|
streamModeSel [4] StreamMode OPTIONAL
|
|
}
|
|
-- must not have both streamMode and streamModeSel
|
|
-- if both are present only streamModeSel shall be honoured
|
|
|
|
IndAudPropertyParm ::= SEQUENCE
|
|
{
|
|
name [0] PkgdName,
|
|
...,
|
|
propertyParms [1] PropertyParm OPTIONAL
|
|
}
|
|
-- to select based on property values
|
|
-- AND/OR selection logic is specified at context level
|
|
|
|
IndAudLocalRemoteDescriptor ::= SEQUENCE
|
|
{
|
|
propGroupID [0] INTEGER(0..65535) OPTIONAL,
|
|
propGrps [1] IndAudPropertyGroup,
|
|
...
|
|
}
|
|
|
|
IndAudPropertyGroup ::= SEQUENCE OF IndAudPropertyParm
|
|
|
|
IndAudTerminationStateDescriptor ::= SEQUENCE
|
|
{
|
|
propertyParms [0] SEQUENCE OF IndAudPropertyParm,
|
|
eventBufferControl [1] NULL OPTIONAL,
|
|
serviceState [2] NULL OPTIONAL,
|
|
...,
|
|
serviceStateSel [3] ServiceState OPTIONAL
|
|
}
|
|
-- must not have both serviceState and serviceStateSel
|
|
-- if both are present only serviceStateSel shall be honoured
|
|
|
|
IndAudEventsDescriptor ::= SEQUENCE
|
|
{
|
|
requestID [0] RequestID OPTIONAL,
|
|
pkgdName [1] PkgdName,
|
|
streamID [2] StreamID OPTIONAL,
|
|
...
|
|
}
|
|
|
|
IndAudEventBufferDescriptor ::= SEQUENCE
|
|
{
|
|
eventName [0] PkgdName,
|
|
streamID [1] StreamID OPTIONAL,
|
|
...
|
|
}
|
|
|
|
IndAudSignalsDescriptor ::=CHOICE
|
|
{
|
|
signal [0] IndAudSignal,
|
|
seqSigList [1] IndAudSeqSigList,
|
|
...
|
|
}
|
|
|
|
IndAudSeqSigList ::= SEQUENCE
|
|
{
|
|
id [0] INTEGER(0..65535),
|
|
signalList [1] IndAudSignal OPTIONAL
|
|
}
|
|
|
|
IndAudSignal ::= SEQUENCE
|
|
{
|
|
signalName [0] PkgdName,
|
|
streamID [1] StreamID OPTIONAL,
|
|
...,
|
|
signalRequestID [2] RequestID OPTIONAL
|
|
}
|
|
|
|
IndAudDigitMapDescriptor ::= SEQUENCE
|
|
{
|
|
digitMapName [0] DigitMapName OPTIONAL
|
|
}
|
|
|
|
IndAudStatisticsDescriptor ::= SEQUENCE
|
|
{
|
|
statName [0] PkgdName
|
|
}
|
|
|
|
IndAudPackagesDescriptor ::= SEQUENCE
|
|
{
|
|
packageName [0] Name,
|
|
packageVersion [1] INTEGER(0..99),
|
|
...
|
|
}
|
|
|
|
NotifyRequest ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationIDList,
|
|
observedEventsDescriptor [1] ObservedEventsDescriptor,
|
|
errorDescriptor [2] ErrorDescriptor OPTIONAL,
|
|
...
|
|
}
|
|
|
|
NotifyReply ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationIDList,
|
|
errorDescriptor [1] ErrorDescriptor OPTIONAL,
|
|
...
|
|
}
|
|
|
|
ObservedEventsDescriptor ::= SEQUENCE
|
|
{
|
|
requestId [0] RequestID,
|
|
observedEventLst [1] SEQUENCE OF ObservedEvent
|
|
}
|
|
|
|
ObservedEvent ::= SEQUENCE
|
|
{
|
|
eventName [0] EventName,
|
|
streamID [1] StreamID OPTIONAL,
|
|
eventParList [2] SEQUENCE OF EventParameter,
|
|
timeNotation [3] TimeNotation OPTIONAL,
|
|
...
|
|
}
|
|
|
|
-- EventName ::= PkgdName
|
|
EventName ::= OCTET STRING
|
|
|
|
EventParameter ::= SEQUENCE
|
|
{
|
|
-- Wireshark specific
|
|
-- eventParameterName [0] Name,
|
|
-- value [1] Value,
|
|
eventParameterName [0] EventParameterName,
|
|
eventParamValue [1] EventParamValues,
|
|
-- end
|
|
-- For use of extraInfos see the comment related to PropertyParm
|
|
extraInfo [2] CHOICE
|
|
{
|
|
relation [0] Relation,
|
|
range [1] BOOLEAN,
|
|
sublist [2] BOOLEAN
|
|
} OPTIONAL,
|
|
...
|
|
}
|
|
-- Wireshark specific
|
|
EventParameterName ::= Name
|
|
|
|
EventParamValues ::= SEQUENCE OF EventParamValue
|
|
|
|
EventParamValue ::= OCTET STRING
|
|
-- end
|
|
ServiceChangeRequest ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationIDList,
|
|
serviceChangeParms [1] ServiceChangeParm,
|
|
...
|
|
}
|
|
|
|
ServiceChangeReply ::= SEQUENCE
|
|
{
|
|
terminationID [0] TerminationIDList,
|
|
serviceChangeResult [1] ServiceChangeResult,
|
|
...
|
|
}
|
|
-- For ServiceChangeResult, no parameters are mandatory. Hence the
|
|
-- distinction between ServiceChangeParm and ServiceChangeResParm.
|
|
|
|
ServiceChangeResult ::= CHOICE
|
|
{
|
|
errorDescriptor [0] ErrorDescriptor,
|
|
serviceChangeResParms [1] ServiceChangeResParm
|
|
}
|
|
|
|
WildcardField ::= OCTET STRING(SIZE(1))
|
|
|
|
TerminationID ::= SEQUENCE
|
|
{
|
|
wildcard [0] SEQUENCE OF WildcardField,
|
|
id [1] OCTET STRING(SIZE(1..8)),
|
|
...
|
|
}
|
|
-- See A.1 for explanation of wildcarding mechanism.
|
|
-- TerminationID 0xFFFFFFFFFFFFFFFF indicates the Root Termination.
|
|
|
|
TerminationIDList ::= SEQUENCE OF TerminationID
|
|
|
|
MediaDescriptor ::= SEQUENCE
|
|
{
|
|
termStateDescr [0] TerminationStateDescriptor OPTIONAL,
|
|
streams [1] CHOICE
|
|
{
|
|
oneStream [0] StreamParms,
|
|
multiStream [1] SEQUENCE OF StreamDescriptor
|
|
} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
StreamDescriptor ::= SEQUENCE
|
|
{
|
|
streamID [0] StreamID,
|
|
streamParms [1] StreamParms
|
|
}
|
|
|
|
StreamParms ::= SEQUENCE
|
|
{
|
|
localControlDescriptor [0] LocalControlDescriptor OPTIONAL,
|
|
localDescriptor [1] LocalRemoteDescriptor OPTIONAL,
|
|
remoteDescriptor [2] LocalRemoteDescriptor OPTIONAL,
|
|
...,
|
|
statisticsDescriptor [3] StatisticsDescriptor OPTIONAL
|
|
}
|
|
|
|
LocalControlDescriptor ::= SEQUENCE
|
|
{
|
|
streamMode [0] StreamMode OPTIONAL,
|
|
reserveValue [1] BOOLEAN OPTIONAL,
|
|
reserveGroup [2] BOOLEAN OPTIONAL,
|
|
propertyParms [3] SEQUENCE OF PropertyParm,
|
|
...
|
|
}
|
|
|
|
StreamMode ::= ENUMERATED
|
|
{
|
|
sendOnly(0),
|
|
recvOnly(1),
|
|
sendRecv(2),
|
|
inactive(3),
|
|
loopBack(4),
|
|
...
|
|
}
|
|
-- In PropertyParm, value is a SEQUENCE OF octet string. When sent
|
|
-- by an MGC the interpretation is as follows:
|
|
-- empty sequence means CHOOSE
|
|
-- one element sequence specifies value
|
|
-- If the sublist field is not selected, a longer sequence means
|
|
-- "choose one of the values" (i.e., value1 OR value2 OR ...)
|
|
-- If the sublist field is selected,
|
|
-- a sequence with more than one element encodes the value of a
|
|
-- list-valued property (i.e., value1 AND value2 AND ...).
|
|
-- The relation field may only be selected if the value sequence
|
|
-- has length 1. It indicates that the MG has to choose a value
|
|
-- for the property. E.g., x > 3 (using the greaterThan
|
|
-- value for relation) instructs the MG to choose any value larger
|
|
-- than 3 for property x.
|
|
-- The range field may only be selected if the value sequence
|
|
-- has length 2. It indicates that the MG has to choose a value
|
|
-- in the range between the first octet in the value sequence and
|
|
-- the trailing octet in the value sequence, including the
|
|
-- boundary values.
|
|
-- When sent by the MG, only responses to an AuditCapability request
|
|
-- may contain multiple values, a range, or a relation field.
|
|
PropertyParm ::= SEQUENCE
|
|
{
|
|
-- name [0] PkgdName,
|
|
propertyName [0] PkgdName,
|
|
-- value [1] SEQUENCE OF OCTET STRING,
|
|
value [1] SEQUENCE OF PropertyID,
|
|
extraInfo [2] CHOICE
|
|
{
|
|
relation [0] Relation,
|
|
range [1] BOOLEAN,
|
|
sublist [2] BOOLEAN
|
|
} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
Name ::= OCTET STRING(SIZE(2))
|
|
|
|
PkgdName ::= OCTET STRING(SIZE(4))
|
|
-- represents Package Name (2 octets) plus property, event,
|
|
-- signal names or StatisticsID. (2 octets)
|
|
-- To wildcard a package use 0xFFFF for first two octets, CHOOSE
|
|
-- is not allowed. To reference native property tag specified in
|
|
-- Annex C, use 0x0000 as first two octets.
|
|
-- To wildcard a PropertyID, EventID, SignalID, or StatisticsID, use
|
|
-- 0xFFFF for last two octets, CHOOSE is not allowed.
|
|
-- Wildcarding of Package Name is permitted only if PropertyID,
|
|
-- EventID, SignalID, or StatisticsID are also wildcarded.
|
|
-- Wireshark specific
|
|
PropertyID ::= OCTET STRING
|
|
|
|
Relation ::= ENUMERATED
|
|
{
|
|
greaterThan(0),
|
|
smallerThan(1),
|
|
unequalTo(2),
|
|
...
|
|
}
|
|
|
|
LocalRemoteDescriptor ::= SEQUENCE
|
|
{
|
|
propGrps [0] SEQUENCE OF PropertyGroup,
|
|
...
|
|
}
|
|
|
|
PropertyGroup ::= SEQUENCE OF PropertyParm
|
|
|
|
TerminationStateDescriptor ::= SEQUENCE
|
|
{
|
|
propertyParms [0] SEQUENCE OF PropertyParm,
|
|
eventBufferControl [1] EventBufferControl OPTIONAL,
|
|
serviceState [2] ServiceState OPTIONAL,
|
|
...
|
|
}
|
|
|
|
EventBufferControl ::= ENUMERATED
|
|
{
|
|
off(0),
|
|
lockStep(1),
|
|
...
|
|
}
|
|
|
|
ServiceState ::= ENUMERATED
|
|
{
|
|
test(0),
|
|
outOfSvc(1),
|
|
inSvc(2),
|
|
...
|
|
}
|
|
|
|
MuxDescriptor ::= SEQUENCE
|
|
{
|
|
muxType [0] MuxType,
|
|
termList [1] SEQUENCE OF TerminationID,
|
|
nonStandardData [2] NonStandardData OPTIONAL,
|
|
...
|
|
}
|
|
|
|
MuxType ::= ENUMERATED
|
|
{
|
|
h221(0),
|
|
h223(1),
|
|
h226(2),
|
|
v76(3),
|
|
...,
|
|
nx64k(4)
|
|
}
|
|
|
|
StreamID ::= INTEGER(0..65535) -- 16-bit unsigned integer
|
|
|
|
EventsDescriptor ::= SEQUENCE
|
|
{
|
|
requestID [0] RequestID OPTIONAL,
|
|
-- RequestID must be present if eventList
|
|
-- is non empty
|
|
eventList [1] SEQUENCE OF RequestedEvent,
|
|
...
|
|
}
|
|
|
|
RequestedEvent ::= SEQUENCE
|
|
{
|
|
-- pkgdName [0] PkgdName,
|
|
eventName [0] EventName,
|
|
streamID [1] StreamID OPTIONAL,
|
|
eventAction [2] RequestedActions OPTIONAL,
|
|
evParList [3] SEQUENCE OF EventParameter,
|
|
...
|
|
}
|
|
|
|
RegulatedEmbeddedDescriptor ::= SEQUENCE
|
|
{
|
|
secondEvent [0] SecondEventsDescriptor OPTIONAL,
|
|
signalsDescriptor [1] SignalsDescriptor OPTIONAL,
|
|
...
|
|
}
|
|
|
|
NotifyBehaviour ::= CHOICE
|
|
{
|
|
notifyImmediate [0] NULL,
|
|
notifyRegulated [1] RegulatedEmbeddedDescriptor,
|
|
neverNotify [2] NULL,
|
|
...
|
|
}
|
|
|
|
RequestedActions ::= SEQUENCE
|
|
{
|
|
keepActive [0] BOOLEAN OPTIONAL,
|
|
eventDM [1] EventDM OPTIONAL,
|
|
secondEvent [2] SecondEventsDescriptor OPTIONAL,
|
|
signalsDescriptor [3] SignalsDescriptor OPTIONAL,
|
|
...,
|
|
notifyBehaviour [4] NotifyBehaviour OPTIONAL,
|
|
resetEventsDescriptor [5] NULL OPTIONAL
|
|
}
|
|
|
|
EventDM ::= CHOICE
|
|
{
|
|
digitMapName [0] DigitMapName,
|
|
digitMapValue [1] DigitMapValue
|
|
}
|
|
|
|
SecondEventsDescriptor ::= SEQUENCE
|
|
{
|
|
requestID [0] RequestID OPTIONAL,
|
|
eventList [1] SEQUENCE OF SecondRequestedEvent,
|
|
...
|
|
}
|
|
|
|
SecondRequestedEvent ::= SEQUENCE
|
|
{
|
|
pkgdName [0] PkgdName,
|
|
streamID [1] StreamID OPTIONAL,
|
|
eventAction [2] SecondRequestedActions OPTIONAL,
|
|
evParList [3] SEQUENCE OF EventParameter,
|
|
...
|
|
}
|
|
|
|
SecondRequestedActions ::= SEQUENCE
|
|
{
|
|
keepActive [0] BOOLEAN OPTIONAL,
|
|
eventDM [1] EventDM OPTIONAL,
|
|
signalsDescriptor [2] SignalsDescriptor OPTIONAL,
|
|
...,
|
|
notifyBehaviour [3] NotifyBehaviour OPTIONAL,
|
|
resetEventsDescriptor [4] NULL OPTIONAL
|
|
}
|
|
|
|
EventBufferDescriptor ::= SEQUENCE OF EventSpec
|
|
|
|
EventSpec ::= SEQUENCE
|
|
{
|
|
eventName [0] EventName,
|
|
streamID [1] StreamID OPTIONAL,
|
|
eventParList [2] SEQUENCE OF EventParameter,
|
|
...
|
|
}
|
|
|
|
SignalsDescriptor ::= SEQUENCE OF SignalRequest
|
|
|
|
SignalRequest ::=CHOICE
|
|
{
|
|
signal [0] Signal,
|
|
seqSigList [1] SeqSigList,
|
|
...
|
|
}
|
|
|
|
SeqSigList ::= SEQUENCE
|
|
{
|
|
id [0] INTEGER(0..65535),
|
|
signalList [1] SEQUENCE OF Signal
|
|
}
|
|
|
|
Signal ::= SEQUENCE
|
|
{
|
|
signalName [0] SignalName,
|
|
streamID [1] StreamID OPTIONAL,
|
|
sigType [2] SignalType OPTIONAL,
|
|
duration [3] INTEGER (0..65535) OPTIONAL,
|
|
notifyCompletion [4] NotifyCompletion OPTIONAL,
|
|
keepActive [5] BOOLEAN OPTIONAL,
|
|
sigParList [6] SEQUENCE OF SigParameter,
|
|
...,
|
|
direction [7] SignalDirection OPTIONAL,
|
|
requestID [8] RequestID OPTIONAL,
|
|
intersigDelay [9] INTEGER (0..65535) OPTIONAL
|
|
}
|
|
|
|
SignalType ::= ENUMERATED
|
|
{
|
|
brief(0),
|
|
onOff(1),
|
|
timeOut(2),
|
|
...
|
|
}
|
|
|
|
SignalDirection ::= ENUMERATED
|
|
{
|
|
internal(0),
|
|
external(1),
|
|
both(2),
|
|
...
|
|
}
|
|
|
|
-- SignalName ::= PkgdName
|
|
SignalName ::= OCTET STRING
|
|
|
|
NotifyCompletion ::= BIT STRING
|
|
{
|
|
onTimeOut(0), onInterruptByEvent(1),
|
|
onInterruptByNewSignalDescr(2), otherReason(3), onIteration(4)
|
|
}
|
|
|
|
SigParameter ::= SEQUENCE
|
|
{
|
|
-- sigParameterName [0] Name,
|
|
-- value [1] Value,
|
|
sigParameterName [0] SigParameterName,
|
|
value [1] SigParamValues,
|
|
-- For use of extraInfo see the comment related to PropertyParm
|
|
extraInfo [2] CHOICE
|
|
{
|
|
relation [0] Relation,
|
|
range [1] BOOLEAN,
|
|
sublist [2] BOOLEAN
|
|
} OPTIONAL,
|
|
...
|
|
}
|
|
-- Wireshark specific
|
|
SigParameterName ::= Name
|
|
|
|
SigParamValues ::= SEQUENCE OF SigParamValue
|
|
|
|
SigParamValue ::= OCTET STRING
|
|
-- end
|
|
-- For an AuditCapReply with all events, the RequestID shall be ALL.
|
|
-- ALL is represented by 0xffffffff.
|
|
RequestID ::= INTEGER(0..4294967295) -- 32-bit unsigned integer
|
|
|
|
ModemDescriptor ::= SEQUENCE
|
|
{
|
|
mtl [0] SEQUENCE OF ModemType,
|
|
mpl [1] SEQUENCE OF PropertyParm,
|
|
nonStandardData [2] NonStandardData OPTIONAL
|
|
}
|
|
|
|
ModemType ::= ENUMERATED
|
|
{
|
|
v18(0),
|
|
v22(1),
|
|
v22bis(2),
|
|
v32(3),
|
|
v32bis(4),
|
|
v34(5),
|
|
v90(6),
|
|
v91(7),
|
|
synchISDN(8),
|
|
...
|
|
}
|
|
|
|
DigitMapDescriptor ::= SEQUENCE
|
|
{
|
|
digitMapName [0] DigitMapName OPTIONAL,
|
|
digitMapValue [1] DigitMapValue OPTIONAL
|
|
}
|
|
|
|
DigitMapName ::= Name
|
|
|
|
DigitMapValue ::= SEQUENCE
|
|
{
|
|
startTimer [0] INTEGER(0..99) OPTIONAL,
|
|
shortTimer [1] INTEGER(0..99) OPTIONAL,
|
|
longTimer [2] INTEGER(0..99) OPTIONAL,
|
|
digitMapBody [3] IA5String,
|
|
-- Units are seconds for start, short and long timers, and hundreds
|
|
-- of milliseconds for duration timer. Thus start, short, and long
|
|
-- range from 1 to 99 seconds and duration from 100 ms to 9.9 s
|
|
-- See A.3 for explanation of DigitMap syntax
|
|
...,
|
|
durationTimer [4] INTEGER (0..99) OPTIONAL
|
|
}
|
|
|
|
ServiceChangeParm ::= SEQUENCE
|
|
{
|
|
serviceChangeMethod [0] ServiceChangeMethod,
|
|
serviceChangeAddress [1] ServiceChangeAddress OPTIONAL,
|
|
serviceChangeVersion [2] INTEGER(0..99) OPTIONAL,
|
|
serviceChangeProfile [3] ServiceChangeProfile OPTIONAL,
|
|
-- serviceChangeReason [4] Value,
|
|
serviceChangeReason [4] SCreasonValue,
|
|
-- A serviceChangeReason consists of a numeric reason code
|
|
-- and an optional text description.
|
|
-- The serviceChangeReason shall be a string consisting of
|
|
-- a decimal reason code, optionally followed by a single
|
|
-- space character and a textual description string.
|
|
-- This string is first BER-encoded as an IA5String.
|
|
-- The result of this BER-encoding is then encoded as
|
|
-- an ASN.1 OCTET STRING type, "double wrapping" the
|
|
-- value as was done for package elements.
|
|
|
|
serviceChangeDelay [5] INTEGER(0..4294967295) OPTIONAL,
|
|
-- 32-bit unsigned integer
|
|
serviceChangeMgcId [6] MId OPTIONAL,
|
|
timeStamp [7] TimeNotation OPTIONAL,
|
|
nonStandardData [8] NonStandardData OPTIONAL,
|
|
...,
|
|
serviceChangeInfo [9] AuditDescriptor OPTIONAL,
|
|
serviceChangeIncompleteFlag [10] NULL OPTIONAL
|
|
}
|
|
|
|
-- Wireshark extension to decode serviceChangeReason
|
|
SCreasonValue ::= SEQUENCE OF SCreasonValueOctetStr
|
|
SCreasonValueOctetStr ::= OCTET STRING
|
|
ServiceChangeReasonStr ::= IA5String
|
|
-- end
|
|
|
|
ServiceChangeAddress ::= CHOICE
|
|
{
|
|
portNumber [0] INTEGER(0..65535), -- TCP/UDP port number
|
|
ip4Address [1] IP4Address,
|
|
ip6Address [2] IP6Address,
|
|
domainName [3] DomainName,
|
|
deviceName [4] PathName,
|
|
mtpAddress [5] MtpAddress,
|
|
...
|
|
}
|
|
|
|
ServiceChangeResParm ::= SEQUENCE
|
|
{
|
|
serviceChangeMgcId [0] MId OPTIONAL,
|
|
serviceChangeAddress [1] ServiceChangeAddress OPTIONAL,
|
|
serviceChangeVersion [2] INTEGER(0..99) OPTIONAL,
|
|
serviceChangeProfile [3] ServiceChangeProfile OPTIONAL,
|
|
timestamp [4] TimeNotation OPTIONAL,
|
|
...
|
|
}
|
|
|
|
ServiceChangeMethod ::= ENUMERATED
|
|
{
|
|
failover(0),
|
|
forced(1),
|
|
graceful(2),
|
|
restart(3),
|
|
disconnected(4),
|
|
handOff(5),
|
|
...
|
|
}
|
|
|
|
ServiceChangeProfile ::= SEQUENCE
|
|
{
|
|
profileName [0] IA5String(SIZE (1..67))
|
|
-- 64 characters for name, 1 for "/", 2 for version to match ABNF
|
|
}
|
|
|
|
PackagesDescriptor ::= SEQUENCE OF PackagesItem
|
|
|
|
PackagesItem ::= SEQUENCE
|
|
{
|
|
packageName [0] Name,
|
|
packageVersion [1] INTEGER(0..99),
|
|
...
|
|
}
|
|
|
|
StatisticsDescriptor ::= SEQUENCE OF StatisticsParameter
|
|
|
|
StatisticsParameter ::= SEQUENCE
|
|
{
|
|
statName [0] PkgdName,
|
|
statValue [1] Value OPTIONAL
|
|
}
|
|
-- If statistic consists of a sub-lists there will be more than
|
|
-- one octetstring in statValue.
|
|
NonStandardData ::= SEQUENCE
|
|
{
|
|
nonStandardIdentifier [0] NonStandardIdentifier,
|
|
data [1] OCTET STRING
|
|
}
|
|
|
|
NonStandardIdentifier ::= CHOICE
|
|
{
|
|
object [0] OBJECT IDENTIFIER,
|
|
h221NonStandard [1] H221NonStandard,
|
|
experimental [2] IA5String(SIZE(8)),
|
|
-- first two characters should be "X-" or "X+"
|
|
...
|
|
}
|
|
|
|
H221NonStandard ::= SEQUENCE
|
|
{
|
|
t35CountryCode1 [0] INTEGER(0..255),
|
|
t35CountryCode2 [1] INTEGER(0..255), -- country, as per T.35
|
|
t35Extension [2] INTEGER(0..255), -- assigned nationally
|
|
manufacturerCode [3] INTEGER(0..65535), -- assigned nationally
|
|
...
|
|
}
|
|
|
|
TimeNotation ::= SEQUENCE
|
|
{
|
|
date [0] IA5String(SIZE(8)), -- yyyymmdd format
|
|
time [1] IA5String(SIZE(8)) -- hhmmssss format
|
|
-- per ISO 8601:2004
|
|
}
|
|
|
|
Value ::= SEQUENCE OF OCTET STRING
|
|
|
|
END
|