forked from osmocom/wireshark
8c608e6e82
Change-Id: Ie476c6f82f318188b41ed922b92c6fec119ea954 Reviewed-on: https://code.wireshark.org/review/244 Reviewed-by: Jeff Morriss <jeff.morriss.ws@gmail.com> Tested-by: Jeff Morriss <jeff.morriss.ws@gmail.com>
906 lines
33 KiB
Groff
906 lines
33 KiB
Groff
-- 3GPP TS 29.078 11.0.0 (2011-09)
|
|
-- 6 Circuit Switched Call Control
|
|
-- 6.1 gsmSSF/CCF - gsmSCF Interface
|
|
-- 6.1.1 Operations and arguments
|
|
CAP-gsmSSF-gsmSCF-ops-args {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
|
|
umts-network(1) modules(3) cap-gsmSSF-gsmSCF-ops-args(101) version8(7)}
|
|
|
|
DEFINITIONS IMPLICIT TAGS ::= BEGIN
|
|
|
|
-- This module contains the operations and operation arguments used for the
|
|
-- gsmSSF - gsmSCF interface, for the control of circuit switched calls.
|
|
|
|
-- The table in subclause 2.1 lists the specifications that contain the modules
|
|
-- that are used by CAP.
|
|
|
|
IMPORTS
|
|
|
|
errortypes,
|
|
datatypes,
|
|
operationcodes,
|
|
classes,
|
|
tc-Messages,
|
|
ros-InformationObjects
|
|
FROM CAP-object-identifiers {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
|
|
umts-network(1) modules(3) cap-object-identifiers(100) version8(7)}
|
|
|
|
OPERATION
|
|
FROM Remote-Operations-Information-Objects ros-InformationObjects
|
|
|
|
CallingPartysCategory,
|
|
HighLayerCompatibility,
|
|
LegID,
|
|
RedirectionInformation,
|
|
ServiceKey
|
|
FROM CS1-DataTypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
|
|
modules(0) cs1-datatypes(2) version1(0)}
|
|
|
|
MiscCallInfo
|
|
FROM CS2-datatypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
|
|
cs2(20) modules(0) in-cs2-datatypes (0) version1(0)}
|
|
|
|
Ext-BasicServiceCode,
|
|
IMEI,
|
|
IMSI,
|
|
ISDN-AddressString
|
|
FROM MAP-CommonDataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
|
|
gsm-Network(1) modules(3) map-CommonDataTypes(18) version12(12)}
|
|
|
|
CUG-Index,
|
|
CUG-Interlock,
|
|
CUG-Info,
|
|
LocationInformation,
|
|
MS-Classmark2,
|
|
SubscriberState,
|
|
SupportedCamelPhases,
|
|
OfferedCamel4Functionalities
|
|
FROM MAP-MS-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
|
|
gsm-Network(1) modules(3) map-MS-DataTypes(11) version12(12)}
|
|
|
|
CallReferenceNumber,
|
|
SuppressionOfAnnouncement,
|
|
UU-Data
|
|
FROM MAP-CH-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
|
|
gsm-Network(1) modules(3) map-CH-DataTypes(13) version12(12)}
|
|
|
|
PARAMETERS-BOUND
|
|
FROM CAP-classes classes
|
|
|
|
opcode-activityTest,
|
|
opcode-applyCharging,
|
|
opcode-applyChargingReport,
|
|
opcode-assistRequestInstructions,
|
|
opcode-callGap,
|
|
opcode-callInformationReport,
|
|
opcode-callInformationRequest,
|
|
opcode-cancel,
|
|
opcode-collectInformation,
|
|
opcode-connect,
|
|
opcode-connectToResource,
|
|
opcode-continue,
|
|
opcode-continueWithArgument,
|
|
opcode-disconnectForwardConnection,
|
|
opcode-dFCWithArgument,
|
|
opcode-disconnectLeg,
|
|
opcode-entityReleased,
|
|
opcode-establishTemporaryConnection,
|
|
opcode-eventReportBCSM,
|
|
opcode-furnishChargingInformation,
|
|
opcode-initialDP,
|
|
opcode-initiateCallAttempt,
|
|
opcode-moveLeg,
|
|
opcode-playTone,
|
|
opcode-releaseCall,
|
|
opcode-requestReportBCSMEvent,
|
|
opcode-resetTimer,
|
|
opcode-sendChargingInformation,
|
|
opcode-splitLeg
|
|
FROM CAP-operationcodes operationcodes
|
|
-- The CAP Operation identifiers for CAP V4 in Rel-6 are the same as the CAP Operation
|
|
-- identifiers for CAP V4 in Rel-5.
|
|
|
|
AChBillingChargingCharacteristics {},
|
|
AdditionalCallingPartyNumber {},
|
|
AlertingPattern,
|
|
AChChargingAddress {},
|
|
AssistingSSPIPRoutingAddress {},
|
|
BCSMEvent {},
|
|
BCSM-Failure,
|
|
BearerCapability {},
|
|
Burst,
|
|
CalledPartyNumber {},
|
|
CalledPartyBCDNumber {},
|
|
CallingPartyNumber {},
|
|
CallResult {},
|
|
CallSegmentID {},
|
|
CallSegmentToCancel {},
|
|
CallSegmentFailure {},
|
|
Carrier,
|
|
Cause {},
|
|
CGEncountered,
|
|
ChargeNumber {},
|
|
ControlType,
|
|
CorrelationID {},
|
|
DestinationRoutingAddress {},
|
|
EventSpecificInformationBCSM {},
|
|
EventTypeBCSM,
|
|
Extensions {},
|
|
FCIBillingChargingCharacteristics {},
|
|
GapCriteria {},
|
|
GapIndicators,
|
|
GapTreatment,
|
|
GenericNumbers {},
|
|
InvokeID,
|
|
IPRoutingAddress {},
|
|
IPSSPCapabilities {},
|
|
leg1,
|
|
leg2,
|
|
LegOrCallSegment {},
|
|
LocationNumber {},
|
|
LowLayerCompatibility {},
|
|
MonitorMode,
|
|
NAOliInfo,
|
|
OCSIApplicable,
|
|
OriginalCalledPartyID {},
|
|
ReceivingSideID,
|
|
RedirectingPartyID {},
|
|
RequestedInformationList {},
|
|
RequestedInformationTypeList,
|
|
ScfID {},
|
|
SCIBillingChargingCharacteristics {},
|
|
SendingSideID,
|
|
ServiceInteractionIndicatorsTwo,
|
|
TimeAndTimezone {},
|
|
TimerID,
|
|
TimerValue
|
|
FROM CAP-datatypes datatypes
|
|
-- For Rel-6, the CAP-datatypes module is updated to version8(7); Object Identifier 'datatypes'
|
|
-- is also updated to version8(7). As a result, the present module uses Rel-6 data type definitions.
|
|
|
|
cancelFailed,
|
|
eTCFailed,
|
|
missingCustomerRecord,
|
|
missingParameter,
|
|
parameterOutOfRange,
|
|
requestedInfoError,
|
|
systemFailure,
|
|
taskRefused,
|
|
unexpectedComponentSequence,
|
|
unexpectedDataValue,
|
|
unexpectedParameter,
|
|
unknownLegID,
|
|
unknownCSID
|
|
FROM CAP-errortypes errortypes
|
|
-- For Rel-6, the CAP-errortypes module is updated to version8(7); Object Identifier
|
|
-- 'errortypes' is also updated to version8(7). As a result, the present module uses Rel-6
|
|
-- error type definitions.
|
|
|
|
;
|
|
|
|
activityTest OPERATION ::= {
|
|
RETURN RESULT TRUE
|
|
CODE opcode-activityTest}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tat
|
|
-- This operation is used to check for the continued existence of a relationship
|
|
-- between the gsmSCF and gsmSSF, assist gsmSSF or gsmSRF. If the relationship is
|
|
-- still in existence, then the gsmSSF will respond. If no reply is received,
|
|
-- then the gsmSCF will assume that the gsmSSF, assist gsmSSF or gsmSRF has failed
|
|
-- in some way.
|
|
|
|
applyCharging {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT ApplyChargingArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
unexpectedComponentSequence |
|
|
unexpectedParameter |
|
|
unexpectedDataValue |
|
|
parameterOutOfRange |
|
|
systemFailure |
|
|
taskRefused |
|
|
unknownLegID |
|
|
unknownCSID}
|
|
CODE opcode-applyCharging}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tac
|
|
-- This operation is used for interacting from the gsmSCF with the gsmSSF charging mechanisms.
|
|
-- The ApplyChargingReport operation provides the feedback from the gsmSSF to the gsmSCF.
|
|
|
|
ApplyChargingArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
aChBillingChargingCharacteristics [0] AChBillingChargingCharacteristics {bound},
|
|
partyToCharge [2] SendingSideID DEFAULT sendingSideID : leg1,
|
|
extensions [3] Extensions {bound} OPTIONAL,
|
|
aChChargingAddress [50] AChChargingAddress {bound}
|
|
DEFAULT legID:sendingSideID:leg1,
|
|
...,
|
|
-- WS modification Frensh National standard addition
|
|
-- https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=7656
|
|
iTXcharging [64] BOOLEAN OPTIONAL
|
|
-- End WS
|
|
}
|
|
|
|
-- The partyToCharge parameter indicates the party in the call to which the ApplyCharging operation
|
|
-- shall be applied.
|
|
|
|
applyChargingReport {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT ApplyChargingReportArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
unexpectedComponentSequence |
|
|
unexpectedParameter |
|
|
unexpectedDataValue |
|
|
unknownCSID |
|
|
unknownLegID |
|
|
parameterOutOfRange |
|
|
systemFailure |
|
|
taskRefused}
|
|
CODE opcode-applyChargingReport}
|
|
-- Direction: gsmSSF -> gsmSCF, Timer: Tacr
|
|
-- This operation is used by the gsmSSF to report to the gsmSCF the occurrence of a
|
|
-- specific charging event as requested by the gsmSCF using the ApplyCharging operation.
|
|
|
|
ApplyChargingReportArg {PARAMETERS-BOUND : bound} ::= CallResult {bound}
|
|
|
|
assistRequestInstructions {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT AssistRequestInstructionsArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingCustomerRecord |
|
|
missingParameter |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter}
|
|
CODE opcode-assistRequestInstructions}
|
|
-- Direction: gsmSSF -> gsmSCF or gsmSRF -> gsmSCF, Timer: Tari
|
|
-- This operation is used when there is an assist procedure and may be
|
|
-- sent by the gsmSSF or gsmSRF to the gsmSCF. This operation is sent by the
|
|
-- assisting gsmSSF to gsmSCF, when the initiating gsmSSF has set up a connection to
|
|
-- the gsmSRF or to the assisting gsmSSF as a result of receiving an
|
|
-- EstablishTemporaryConnection from
|
|
-- the gsmSCF.
|
|
-- Refer to clause 11 for a description of the procedures associated with this operation.
|
|
|
|
AssistRequestInstructionsArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
correlationID [0] CorrelationID {bound},
|
|
iPSSPCapabilities [2] IPSSPCapabilities {bound},
|
|
extensions [3] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
-- OPTIONAL denotes network operator specific use. The value of the correlationID may be the
|
|
-- Called Party Number supplied by the initiating gsmSSF.
|
|
|
|
callGap {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT CallGapArg {bound}
|
|
RETURN RESULT FALSE
|
|
ALWAYS RESPONDS FALSE
|
|
CODE opcode-callGap}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tcg
|
|
-- This operation is used to request the gsmSSF to reduce the rate at which specific service
|
|
-- requests are sent to the gsmSCF.
|
|
|
|
CallGapArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
|
|
gapCriteria [0] GapCriteria {bound},
|
|
gapIndicators [1] GapIndicators,
|
|
controlType [2] ControlType OPTIONAL,
|
|
gapTreatment [3] GapTreatment {bound} OPTIONAL,
|
|
extensions [4] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
-- OPTIONAL denotes network operator optional. If gapTreatment is not present, then the gsmSSF will
|
|
-- use a default treatment depending on network operator implementation.
|
|
|
|
callInformationReport {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT CallInformationReportArg {bound}
|
|
RETURN RESULT FALSE
|
|
ALWAYS RESPONDS FALSE
|
|
CODE opcode-callInformationReport}
|
|
-- Direction: gsmSSF -> gsmSCF, Timer: Tcirp
|
|
-- This operation is used to send specific call information for a single call party to the gsmSCF as
|
|
-- requested by the gsmSCF in a previous CallInformationRequest.
|
|
|
|
CallInformationReportArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
requestedInformationList [0] RequestedInformationList {bound},
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
legID [3] ReceivingSideID DEFAULT receivingSideID:leg2,
|
|
...
|
|
}
|
|
|
|
callInformationRequest {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT CallInformationRequestArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
parameterOutOfRange |
|
|
requestedInfoError |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownLegID}
|
|
CODE opcode-callInformationRequest}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tcirq
|
|
-- This operation is used to request the gsmSSF to record specific information about a single
|
|
-- call party and report it to the gsmSCF (with a CallInformationReport operation).
|
|
|
|
CallInformationRequestArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
|
|
requestedInformationTypeList [0] RequestedInformationTypeList,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
legID [3] SendingSideID DEFAULT sendingSideID:leg2,
|
|
...
|
|
}
|
|
-- OPTIONAL denotes network operator optional.
|
|
|
|
cancel {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT CancelArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {cancelFailed |
|
|
missingParameter |
|
|
taskRefused |
|
|
unknownCSID}
|
|
CODE opcode-cancel}
|
|
-- Direction: gsmSCF -> gsmSSF, or gsmSCF -> gsmSRF, Timer: Tcan
|
|
-- This operation cancels the correlated previous operation or all previous requests. The following
|
|
-- operations can be canceled: PlayAnnouncement, PromptAndCollectUserInformation.
|
|
|
|
CancelArg {PARAMETERS-BOUND : bound} ::= CHOICE {
|
|
invokeID [0] InvokeID,
|
|
allRequests [1] NULL,
|
|
callSegmentToCancel [2] CallSegmentToCancel {bound}
|
|
}
|
|
-- The InvokeID has the same value as that which was used for the operation to be cancelled.
|
|
|
|
collectInformation {PARAMETERS-BOUND : bound} OPERATION::= {
|
|
ARGUMENT CollectInformationArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
parameterOutOfRange |
|
|
SystemFailure |
|
|
TaskRefused |
|
|
UnexpectedComponentSequence |
|
|
UnexpectedDataValue |
|
|
UnexpectedParameter}
|
|
CODE opcode-collectInformation}
|
|
-- Direction: gsmSCF-> gsmSSF, Timer: Tci
|
|
-- This operation is used to request the gsmSSF to perform the call
|
|
-- processing actions to prompt a calling party for additional digits.
|
|
|
|
CollectInformationArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
|
|
extensions [0] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
connect {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT ConnectArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
parameterOutOfRange |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownLegID}
|
|
CODE opcode-connect}
|
|
-- Direction: gsmSCF-> gsmSSF, Timer: Tcon
|
|
-- This operation is used to request the gsmSSF to perform the call processing actions
|
|
-- to route or forward a call to a specified destination.
|
|
|
|
ConnectArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
destinationRoutingAddress [0] DestinationRoutingAddress {bound},
|
|
alertingPattern [1] AlertingPattern OPTIONAL,
|
|
originalCalledPartyID [6] OriginalCalledPartyID {bound} OPTIONAL,
|
|
extensions [10] Extensions {bound} OPTIONAL,
|
|
carrier [11] Carrier {bound} OPTIONAL,
|
|
callingPartysCategory [28] CallingPartysCategory OPTIONAL,
|
|
redirectingPartyID [29] RedirectingPartyID {bound} OPTIONAL,
|
|
redirectionInformation [30] RedirectionInformation OPTIONAL,
|
|
genericNumbers [14] GenericNumbers {bound} OPTIONAL,
|
|
serviceInteractionIndicatorsTwo [15] ServiceInteractionIndicatorsTwo OPTIONAL,
|
|
chargeNumber [19] ChargeNumber {bound} OPTIONAL,
|
|
legToBeConnected [21] LegID OPTIONAL,
|
|
cug-Interlock [31] CUG-Interlock OPTIONAL,
|
|
cug-OutgoingAccess [32] NULL OPTIONAL,
|
|
suppressionOfAnnouncement [55] SuppressionOfAnnouncement OPTIONAL,
|
|
oCSIApplicable [56] OCSIApplicable OPTIONAL,
|
|
naOliInfo [57] NAOliInfo OPTIONAL,
|
|
bor-InterrogationRequested [58] NULL OPTIONAL,
|
|
... ,
|
|
suppress-N-CSI [59] NULL OPTIONAL
|
|
}
|
|
-- na-Info is included at the discretion of the gsmSCF operator.
|
|
|
|
connectToResource {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT ConnectToResourceArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownCSID}
|
|
CODE opcode-connectToResource}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tctr
|
|
-- This operation is used to connect a call segment from the gsmSSF to the
|
|
-- gsmSRF.
|
|
|
|
ConnectToResourceArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
resourceAddress CHOICE {
|
|
ipRoutingAddress [0] IPRoutingAddress {bound},
|
|
none [3] NULL
|
|
},
|
|
extensions [4] Extensions {bound} OPTIONAL,
|
|
serviceInteractionIndicatorsTwo [7] ServiceInteractionIndicatorsTwo OPTIONAL,
|
|
callSegmentID [50] CallSegmentID {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
continue OPERATION ::= {
|
|
RETURN RESULT FALSE
|
|
ALWAYS RESPONDS FALSE
|
|
CODE opcode-continue}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tcue
|
|
-- This operation is used to request the gsmSSF to proceed with call processing at the
|
|
-- DP at which it previously suspended call processing to await gsmSCF instructions
|
|
-- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
|
|
-- processing without substituting new data from gsmSCF.
|
|
|
|
continueWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT ContinueWithArgumentArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
parameterOutOfRange |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownLegID |
|
|
unknownCSID}
|
|
CODE opcode-continueWithArgument}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tcwa
|
|
-- This operation is used to request the gsmSSF to proceed with call processing at the
|
|
-- DP at which it previously suspended call processing to await gsmSCF instructions
|
|
-- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
|
|
-- processing with the modified call setup information as received from the gsmSCF.
|
|
|
|
ContinueWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
alertingPattern [1] AlertingPattern OPTIONAL,
|
|
extensions [6] Extensions {bound} OPTIONAL,
|
|
serviceInteractionIndicatorsTwo [7] ServiceInteractionIndicatorsTwo OPTIONAL,
|
|
callingPartysCategory [12] CallingPartysCategory OPTIONAL,
|
|
genericNumbers [16] GenericNumbers {bound} OPTIONAL,
|
|
cug-Interlock [17] CUG-Interlock OPTIONAL,
|
|
cug-OutgoingAccess [18] NULL OPTIONAL,
|
|
chargeNumber [50] ChargeNumber {bound} OPTIONAL,
|
|
carrier [52] Carrier {bound} OPTIONAL,
|
|
suppressionOfAnnouncement [55] SuppressionOfAnnouncement OPTIONAL,
|
|
naOliInfo [56] NAOliInfo OPTIONAL,
|
|
bor-InterrogationRequested [57] NULL OPTIONAL,
|
|
suppress-O-CSI [58] NULL OPTIONAL,
|
|
continueWithArgumentArgExtension [59] ContinueWithArgumentArgExtension {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
ContinueWithArgumentArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
suppress-D-CSI [0] NULL OPTIONAL,
|
|
suppress-N-CSI [1] NULL OPTIONAL,
|
|
suppressOutgoingCallBarring [2] NULL OPTIONAL,
|
|
legOrCallSegment [3] LegOrCallSegment {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
disconnectForwardConnection OPERATION ::= {
|
|
RETURN RESULT FALSE
|
|
ERRORS {systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence}
|
|
CODE opcode-disconnectForwardConnection}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tdfc
|
|
-- This operation is used to disconnect a forward temporary connection or a connection to a
|
|
-- resource. Refer to clause 11 for a description of the procedures associated with this operation.
|
|
|
|
disconnectForwardConnectionWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT DisconnectForwardConnectionWithArgumentArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownCSID}
|
|
CODE opcode-dFCWithArgument}
|
|
-- Direction gsmSCF -> gsmSSF, Timer Tdfcwa
|
|
-- This operation is used to disconnect a forward temporary connection or a connection to a
|
|
-- resource. Refer to clause 11 for a description of the procedures associated with this operation.
|
|
|
|
DisconnectForwardConnectionWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
callSegmentID [1] CallSegmentID {bound} OPTIONAL,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
disconnectLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT DisconnectLegArg {bound}
|
|
RETURN RESULT TRUE
|
|
ERRORS {missingParameter |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownLegID}
|
|
CODE opcode-disconnectLeg}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer Tdl
|
|
-- This operation is used by the gsmSCF to release a specific leg associated with the call and
|
|
-- retain any other legs not specified in the DisconnectLeg. Refer to clause 11 for a description
|
|
-- of the procedures associated with this operation.
|
|
|
|
DisconnectLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
legToBeReleased [0] LegID,
|
|
releaseCause [1] Cause {bound} OPTIONAL,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
entityReleased {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT EntityReleasedArg {bound}
|
|
RETURN RESULT FALSE
|
|
ALWAYS RESPONDS FALSE
|
|
CODE opcode-entityReleased}
|
|
-- Direction: gsmSSF -> gsmSCF, Timer: Ter
|
|
-- This operation is used by the gsmSSF to inform the gsmSCF of an error or exception
|
|
|
|
EntityReleasedArg {PARAMETERS-BOUND : bound} ::= CHOICE {
|
|
callSegmentFailure [0] CallSegmentFailure {bound},
|
|
bCSM-Failure [1] BCSM-Failure {bound}
|
|
}
|
|
|
|
establishTemporaryConnection {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT EstablishTemporaryConnectionArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {eTCFailed |
|
|
missingParameter |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownCSID}
|
|
CODE opcode-establishTemporaryConnection}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tetc
|
|
-- This operation is used to create a connection to a resource for a limited period
|
|
-- of time (e.g. to play an announcement, to collect user information); it implies
|
|
-- the use of the assist procedure. Refer to clause 11 for a description of the
|
|
-- procedures associated with this operation.
|
|
|
|
EstablishTemporaryConnectionArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
assistingSSPIPRoutingAddress [0] AssistingSSPIPRoutingAddress {bound},
|
|
correlationID [1] CorrelationID {bound} OPTIONAL,
|
|
scfID [3] ScfID {bound} OPTIONAL,
|
|
extensions [4] Extensions {bound} OPTIONAL,
|
|
carrier [5] Carrier {bound} OPTIONAL,
|
|
serviceInteractionIndicatorsTwo [6] ServiceInteractionIndicatorsTwo OPTIONAL,
|
|
callSegmentID [7] CallSegmentID {bound} OPTIONAL,
|
|
naOliInfo [50] NAOliInfo OPTIONAL,
|
|
chargeNumber [51] ChargeNumber {bound} OPTIONAL,
|
|
...,
|
|
originalCalledPartyID [52] OriginalCalledPartyID {bound} OPTIONAL,
|
|
callingPartyNumber [53] CallingPartyNumber {bound} OPTIONAL
|
|
}
|
|
|
|
eventReportBCSM {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT EventReportBCSMArg {bound}
|
|
RETURN RESULT FALSE
|
|
ALWAYS RESPONDS FALSE
|
|
CODE opcode-eventReportBCSM}
|
|
-- Direction: gsmSSF -> gsmSCF, Timer: Terb
|
|
-- This operation is used to notify the gsmSCF of a call-related event (e.g. BCSM
|
|
-- events such as O_Busy or O_No_Answer) previously requested by the gsmSCF in a
|
|
-- RequestReportBCSMEvent operation.
|
|
|
|
EventReportBCSMArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
eventTypeBCSM [0] EventTypeBCSM,
|
|
eventSpecificInformationBCSM [2] EventSpecificInformationBCSM {bound} OPTIONAL,
|
|
legID [3] ReceivingSideID OPTIONAL,
|
|
miscCallInfo [4] MiscCallInfo DEFAULT {messageType request},
|
|
extensions [5] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
furnishChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT FurnishChargingInformationArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownLegID}
|
|
CODE opcode-furnishChargingInformation}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tfci
|
|
-- This operation is used to request the gsmSSF to generate, register a call record
|
|
-- or to include some information in the default call record.
|
|
-- The registered call record is intended for off line charging of the call.
|
|
|
|
FurnishChargingInformationArg {PARAMETERS-BOUND : bound} ::=
|
|
FCIBillingChargingCharacteristics{bound}
|
|
|
|
initialDP {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT InitialDPArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingCustomerRecord |
|
|
missingParameter |
|
|
parameterOutOfRange |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter}
|
|
CODE opcode-initialDP}
|
|
-- Direction: gsmSSF -> gsmSCF, Timer: Tidp
|
|
-- This operation is used after a TDP to indicate request for service.
|
|
|
|
InitialDPArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
serviceKey [0] ServiceKey ,
|
|
calledPartyNumber [2] CalledPartyNumber {bound} OPTIONAL,
|
|
callingPartyNumber [3] CallingPartyNumber {bound} OPTIONAL,
|
|
callingPartysCategory [5] CallingPartysCategory OPTIONAL,
|
|
cGEncountered [7] CGEncountered OPTIONAL,
|
|
iPSSPCapabilities [8] IPSSPCapabilities {bound} OPTIONAL,
|
|
locationNumber [10] LocationNumber {bound} OPTIONAL,
|
|
originalCalledPartyID [12] OriginalCalledPartyID {bound} OPTIONAL,
|
|
extensions [15] Extensions {bound} OPTIONAL,
|
|
highLayerCompatibility [23] HighLayerCompatibility OPTIONAL,
|
|
additionalCallingPartyNumber [25] AdditionalCallingPartyNumber {bound} OPTIONAL,
|
|
bearerCapability [27] BearerCapability {bound} OPTIONAL,
|
|
eventTypeBCSM [28] EventTypeBCSM OPTIONAL,
|
|
redirectingPartyID [29] RedirectingPartyID {bound} OPTIONAL,
|
|
redirectionInformation [30] RedirectionInformation OPTIONAL,
|
|
cause [17] Cause {bound} OPTIONAL,
|
|
serviceInteractionIndicatorsTwo [32] ServiceInteractionIndicatorsTwo OPTIONAL,
|
|
carrier [37] Carrier {bound} OPTIONAL,
|
|
cug-Index [45] CUG-Index OPTIONAL,
|
|
cug-Interlock [46] CUG-Interlock OPTIONAL,
|
|
cug-OutgoingAccess [47] NULL OPTIONAL,
|
|
iMSI [50] IMSI OPTIONAL,
|
|
subscriberState [51] SubscriberState OPTIONAL,
|
|
locationInformation [52] LocationInformation OPTIONAL,
|
|
ext-basicServiceCode [53] Ext-BasicServiceCode OPTIONAL,
|
|
callReferenceNumber [54] CallReferenceNumber OPTIONAL,
|
|
mscAddress [55] ISDN-AddressString OPTIONAL,
|
|
calledPartyBCDNumber [56] CalledPartyBCDNumber {bound} OPTIONAL,
|
|
timeAndTimezone [57] TimeAndTimezone {bound} OPTIONAL,
|
|
callForwardingSS-Pending [58] NULL OPTIONAL,
|
|
initialDPArgExtension [59] InitialDPArgExtension {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
InitialDPArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
gmscAddress [0] ISDN-AddressString OPTIONAL,
|
|
forwardingDestinationNumber [1] CalledPartyNumber {bound} OPTIONAL,
|
|
ms-Classmark2 [2] MS-Classmark2 OPTIONAL,
|
|
iMEI [3] IMEI OPTIONAL,
|
|
supportedCamelPhases [4] SupportedCamelPhases OPTIONAL,
|
|
offeredCamel4Functionalities [5] OfferedCamel4Functionalities OPTIONAL,
|
|
bearerCapability2 [6] BearerCapability {bound} OPTIONAL,
|
|
ext-basicServiceCode2 [7] Ext-BasicServiceCode OPTIONAL,
|
|
highLayerCompatibility2 [8] HighLayerCompatibility OPTIONAL,
|
|
lowLayerCompatibility [9] LowLayerCompatibility {bound} OPTIONAL,
|
|
lowLayerCompatibility2 [10] LowLayerCompatibility {bound} OPTIONAL,
|
|
...,
|
|
enhancedDialledServicesAllowed [11] NULL OPTIONAL,
|
|
uu-Data [12] UU-Data OPTIONAL,
|
|
collectInformationAllowed [13] NULL OPTIONAL,
|
|
releaseCallArgExtensionAllowed [14] NULL OPTIONAL
|
|
}
|
|
-- If iPSSPCapabilities is not present then this denotes that a colocated gsmSRF is not
|
|
-- supported by the gsmSSF. If present, then the gsmSSF supports a colocated gsmSRF capable
|
|
-- of playing announcements via elementaryMessageIDs and variableMessages, the playing of
|
|
-- tones and the collection of DTMF digits. Other supported capabilities are explicitly
|
|
-- detailed in the IPSSPCapabilities parameter itself.
|
|
-- Carrier is included at the discretion of the gsmSSF operator.
|
|
-- The UserCSGInformation is conveyed in the LocationInformation. The encoding of the parameter is
|
|
-- as defined in 3GPP TS 29.002 [11].
|
|
|
|
initiateCallAttempt {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT InitiateCallAttemptArg {bound}
|
|
RESULT InitiateCallAttemptRes {bound}
|
|
ERRORS {missingParameter |
|
|
parameterOutOfRange |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter
|
|
}
|
|
CODE opcode-initiateCallAttempt}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer Tica
|
|
-- This operation is used to instruct the gsmSSF to create a new call to a call party using the
|
|
-- address information provided by the gsmSCF.
|
|
|
|
InitiateCallAttemptArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
destinationRoutingAddress [0] DestinationRoutingAddress {bound},
|
|
extensions [4] Extensions {bound} OPTIONAL,
|
|
legToBeCreated [5] LegID OPTIONAL,
|
|
newCallSegment [6] CallSegmentID {bound} OPTIONAL,
|
|
callingPartyNumber [30] CallingPartyNumber {bound} OPTIONAL,
|
|
callReferenceNumber [51] CallReferenceNumber OPTIONAL,
|
|
gsmSCFAddress [52] ISDN-AddressString OPTIONAL,
|
|
suppress-T-CSI [53] NULL OPTIONAL,
|
|
...
|
|
}
|
|
|
|
InitiateCallAttemptRes {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
supportedCamelPhases [0] SupportedCamelPhases OPTIONAL,
|
|
offeredCamel4Functionalities [1] OfferedCamel4Functionalities OPTIONAL,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
...,
|
|
releaseCallArgExtensionAllowed [3] NULL OPTIONAL
|
|
}
|
|
|
|
moveLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT MoveLegArg {bound}
|
|
RETURN RESULT TRUE
|
|
ERRORS {missingParameter |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownLegID}
|
|
CODE opcode-moveLeg}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tml
|
|
-- This operation is used by the gsmSCF to move a leg from one call segment to another call segment
|
|
-- within the same call segment association.
|
|
|
|
MoveLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
|
|
legIDToMove [0] LegID,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
playTone {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT PlayToneArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
parameterOutOfRange |
|
|
systemFailure |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownLegID |
|
|
unknownCSID}
|
|
CODE opcode-playTone}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tpt
|
|
-- This operation is used to play tones to either a leg or a call segment using
|
|
-- the MSC's tone generator.
|
|
|
|
PlayToneArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
legOrCallSegment [0] LegOrCallSegment {bound},
|
|
bursts [1] Burst,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
releaseCall {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT ReleaseCallArg {bound}
|
|
RETURN RESULT FALSE
|
|
ALWAYS RESPONDS FALSE
|
|
CODE opcode-releaseCall}
|
|
-- Direction: gsmSCF ->?gsmSSF, Timer: Trc
|
|
-- This operation is used to tear down an existing call at any phase of the call for all parties
|
|
-- involved in the call.
|
|
|
|
ReleaseCallArg {PARAMETERS-BOUND : bound} ::= CHOICE {
|
|
allCallSegments AllCallSegments,
|
|
allCallSegmentsWithExtension [2] AllCallSegmentsWithExtension
|
|
}
|
|
|
|
AllCallSegments ::= Cause {bound}
|
|
-- A default value of decimal 31 (normal unspecified) shall be given.
|
|
|
|
AllCallSegmentsWithExtension ::= SEQUENCE {
|
|
allCallSegments [0] AllCallSegments,
|
|
extensions [1] Extensions {bound} OPTIONAL
|
|
}
|
|
|
|
requestReportBCSMEvent {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT RequestReportBCSMEventArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
parameterOutOfRange |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownLegID}
|
|
CODE opcode-requestReportBCSMEvent}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Trrb
|
|
-- This operation is used to request the gsmSSF to monitor for a call-related event
|
|
-- (e.g. BCSM events such as O_Busy or O_No_Answer) and to send a notification
|
|
-- to the gsmSCF when the event is detected.
|
|
--
|
|
-- NOTE:
|
|
-- Every EDP must be explicitly armed by the gsmSCF via a RequestReportBCSMEvent operation.
|
|
-- No implicit arming of EDPs at the gsmSSF after reception of any operation (different
|
|
-- from RequestReportBCSMEvent) from the gsmSCF is allowed.
|
|
|
|
RequestReportBCSMEventArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
bcsmEvents [0] SEQUENCE SIZE(1..bound.&numOfBCSMEvents) OF
|
|
BCSMEvent {bound},
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
-- Indicates the BCSM related events for notification.
|
|
|
|
resetTimer {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT ResetTimerArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
parameterOutOfRange |
|
|
taskRefused |
|
|
unexpectedComponentSequence |
|
|
unexpectedDataValue |
|
|
unexpectedParameter |
|
|
unknownCSID}
|
|
CODE opcode-resetTimer}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Trt
|
|
-- This operation is used to request the gsmSSF to refresh an application timer in the gsmSSF.
|
|
|
|
ResetTimerArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
timerID [0] TimerID DEFAULT tssf,
|
|
timervalue [1] TimerValue,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
callSegmentID [3] CallSegmentID {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
sendChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT SendChargingInformationArg {bound}
|
|
RETURN RESULT FALSE
|
|
ERRORS {missingParameter |
|
|
unexpectedComponentSequence |
|
|
unexpectedParameter |
|
|
parameterOutOfRange |
|
|
systemFailure |
|
|
taskRefused |
|
|
unexpectedDataValue |
|
|
unknownLegID}
|
|
CODE opcode-sendChargingInformation}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer: Tsci
|
|
-- This operation is used to instruct the gsmSSF on the charging information to send by the gsmSSF.
|
|
-- The charging information can either be sent back by means of signalling or internal
|
|
-- if the gsmSSF is located in the local exchange. In the local exchange
|
|
-- this information may be used to update the charge meter or to create a standard call record.
|
|
|
|
SendChargingInformationArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
|
|
sCIBillingChargingCharacteristics [0] SCIBillingChargingCharacteristics {bound},
|
|
partyToCharge [1] SendingSideID,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
splitLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
|
|
ARGUMENT SplitLegArg {bound}
|
|
RETURN RESULT TRUE
|
|
ERRORS {missingParameter |
|
|
unexpectedComponentSequence |
|
|
unexpectedParameter |
|
|
unexpectedDataValue |
|
|
systemFailure |
|
|
taskRefused |
|
|
unknownLegID}
|
|
CODE opcode-splitLeg}
|
|
-- Direction: gsmSCF -> gsmSSF, Timer Tsl
|
|
-- This operation is used by the gsmSCF to separate a leg from its source call segment and
|
|
-- place it in a new call segment within the same call segment association.
|
|
|
|
SplitLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
|
|
legToBeSplit [0] LegID,
|
|
newCallSegment [1] CallSegmentID {bound} OPTIONAL,
|
|
extensions [2] Extensions {bound} OPTIONAL,
|
|
...
|
|
}
|
|
|
|
END
|