903 lines
33 KiB
Groff
903 lines
33 KiB
Groff
-- $Id$
|
||
-- 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,
|
||
...
|
||
}
|
||
|
||
-- 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
|