diff options
Diffstat (limited to 'epan/dissectors/asn1/camel/CAP-gsmSSF-gsmSCF-ops-args.asn')
-rw-r--r-- | epan/dissectors/asn1/camel/CAP-gsmSSF-gsmSCF-ops-args.asn | 905 |
1 files changed, 905 insertions, 0 deletions
diff --git a/epan/dissectors/asn1/camel/CAP-gsmSSF-gsmSCF-ops-args.asn b/epan/dissectors/asn1/camel/CAP-gsmSSF-gsmSCF-ops-args.asn new file mode 100644 index 00000000..36f847ed --- /dev/null +++ b/epan/dissectors/asn1/camel/CAP-gsmSSF-gsmSCF-ops-args.asn @@ -0,0 +1,905 @@ +-- 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://gitlab.com/wireshark/wireshark/-/issues/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 |