1-- 3GPP TS 29.078 11.0.0 (2011-09)
2-- 6	Circuit Switched Call Control
3-- 6.1	gsmSSF/CCF - gsmSCF Interface
4-- 6.1.1	Operations and arguments
5CAP-gsmSSF-gsmSCF-ops-args {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
6umts-network(1) modules(3) cap-gsmSSF-gsmSCF-ops-args(101) version8(7)}
7
8DEFINITIONS IMPLICIT TAGS ::= BEGIN
9
10-- This module contains the operations and operation arguments used for the
11-- gsmSSF - gsmSCF interface, for the control of circuit switched calls.
12
13-- The table in subclause 2.1 lists the specifications that contain the modules
14-- that are used by CAP.
15
16IMPORTS
17
18	errortypes,
19	datatypes,
20	operationcodes,
21	classes,
22	tc-Messages,
23	ros-InformationObjects
24FROM CAP-object-identifiers {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
25umts-network(1) modules(3) cap-object-identifiers(100) version8(7)}
26
27	OPERATION
28FROM Remote-Operations-Information-Objects ros-InformationObjects
29
30	CallingPartysCategory,
31	HighLayerCompatibility,
32	LegID,
33	RedirectionInformation,
34	ServiceKey
35FROM CS1-DataTypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
36modules(0) cs1-datatypes(2) version1(0)}
37
38	MiscCallInfo
39FROM CS2-datatypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
40cs2(20) modules(0) in-cs2-datatypes (0) version1(0)}
41
42	Ext-BasicServiceCode,
43	IMEI,
44	IMSI,
45	ISDN-AddressString
46FROM MAP-CommonDataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
47gsm-Network(1) modules(3) map-CommonDataTypes(18) version12(12)}
48
49	CUG-Index,
50	CUG-Interlock,
51	CUG-Info,
52	LocationInformation,
53	MS-Classmark2,
54	SubscriberState,
55	SupportedCamelPhases,
56	OfferedCamel4Functionalities
57FROM MAP-MS-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
58gsm-Network(1) modules(3) map-MS-DataTypes(11) version12(12)}
59
60	CallReferenceNumber,
61	SuppressionOfAnnouncement,
62	UU-Data
63FROM MAP-CH-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
64gsm-Network(1) modules(3) map-CH-DataTypes(13) version12(12)}
65
66	PARAMETERS-BOUND
67FROM CAP-classes classes
68
69	opcode-activityTest,
70	opcode-applyCharging,
71	opcode-applyChargingReport,
72	opcode-assistRequestInstructions,
73	opcode-callGap,
74	opcode-callInformationReport,
75	opcode-callInformationRequest,
76	opcode-cancel,
77	opcode-collectInformation,
78	opcode-connect,
79	opcode-connectToResource,
80	opcode-continue,
81	opcode-continueWithArgument,
82	opcode-disconnectForwardConnection,
83	opcode-dFCWithArgument,
84	opcode-disconnectLeg,
85	opcode-entityReleased,
86	opcode-establishTemporaryConnection,
87	opcode-eventReportBCSM,
88	opcode-furnishChargingInformation,
89	opcode-initialDP,
90	opcode-initiateCallAttempt,
91	opcode-moveLeg,
92	opcode-playTone,
93	opcode-releaseCall,
94	opcode-requestReportBCSMEvent,
95	opcode-resetTimer,
96	opcode-sendChargingInformation,
97	opcode-splitLeg
98FROM CAP-operationcodes operationcodes
99-- The CAP Operation identifiers for CAP V4 in Rel-6 are the same as the CAP Operation
100-- identifiers for CAP V4 in Rel-5.
101
102	AChBillingChargingCharacteristics {},
103	AdditionalCallingPartyNumber {},
104	AlertingPattern,
105	AChChargingAddress {},
106	AssistingSSPIPRoutingAddress {},
107	BCSMEvent {},
108	BCSM-Failure,
109	BearerCapability {},
110	Burst,
111	CalledPartyNumber {},
112	CalledPartyBCDNumber {},
113	CallingPartyNumber {},
114	CallResult {},
115	CallSegmentID {},
116	CallSegmentToCancel {},
117	CallSegmentFailure {},
118	Carrier,
119	Cause {},
120	CGEncountered,
121	ChargeNumber {},
122	ControlType,
123	CorrelationID {},
124	DestinationRoutingAddress {},
125	EventSpecificInformationBCSM {},
126	EventTypeBCSM,
127	Extensions {},
128	FCIBillingChargingCharacteristics {},
129	GapCriteria {},
130	GapIndicators,
131	GapTreatment,
132	GenericNumbers {},
133	InvokeID,
134	IPRoutingAddress {},
135	IPSSPCapabilities {},
136	leg1,
137	leg2,
138	LegOrCallSegment {},
139	LocationNumber {},
140	LowLayerCompatibility {},
141	MonitorMode,
142	NAOliInfo,
143	OCSIApplicable,
144	OriginalCalledPartyID {},
145	ReceivingSideID,
146	RedirectingPartyID {},
147	RequestedInformationList {},
148	RequestedInformationTypeList,
149	ScfID {},
150	SCIBillingChargingCharacteristics {},
151	SendingSideID,
152	ServiceInteractionIndicatorsTwo,
153	TimeAndTimezone {},
154	TimerID,
155	TimerValue
156FROM CAP-datatypes datatypes
157-- For Rel-6, the CAP-datatypes module is updated to version8(7); Object Identifier 'datatypes'
158-- is also updated to version8(7). As a result, the present module uses Rel-6 data type definitions.
159
160	cancelFailed,
161	eTCFailed,
162	missingCustomerRecord,
163	missingParameter,
164	parameterOutOfRange,
165	requestedInfoError,
166	systemFailure,
167	taskRefused,
168	unexpectedComponentSequence,
169	unexpectedDataValue,
170	unexpectedParameter,
171	unknownLegID,
172	unknownCSID
173FROM CAP-errortypes errortypes
174-- For Rel-6, the CAP-errortypes module is updated to version8(7); Object Identifier
175-- 'errortypes' is also updated to version8(7). As a result, the present module uses Rel-6
176-- error type definitions.
177
178;
179
180activityTest OPERATION ::= {
181	RETURN RESULT	TRUE
182	CODE			opcode-activityTest}
183-- Direction: gsmSCF -> gsmSSF, Timer: Tat
184-- This operation is used to check for the continued existence of a relationship
185-- between the gsmSCF and gsmSSF, assist gsmSSF or gsmSRF. If the relationship is
186-- still in existence, then the gsmSSF will respond. If no reply is received,
187-- then the gsmSCF will assume that the gsmSSF, assist gsmSSF or gsmSRF has failed
188-- in some way.
189
190applyCharging {PARAMETERS-BOUND : bound} OPERATION ::= {
191	ARGUMENT		ApplyChargingArg {bound}
192	RETURN RESULT	FALSE
193	ERRORS			{missingParameter |
194					unexpectedComponentSequence |
195					unexpectedParameter |
196					unexpectedDataValue |
197					parameterOutOfRange |
198					systemFailure |
199					taskRefused |
200					unknownLegID |
201					unknownCSID}
202	CODE			opcode-applyCharging}
203-- Direction: gsmSCF -> gsmSSF, Timer: Tac
204-- This operation is used for interacting from the gsmSCF with the gsmSSF charging mechanisms.
205-- The ApplyChargingReport operation provides the feedback from the gsmSSF to the gsmSCF.
206
207ApplyChargingArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
208	aChBillingChargingCharacteristics	[0] AChBillingChargingCharacteristics {bound},
209	partyToCharge						[2] SendingSideID DEFAULT sendingSideID : leg1,
210	extensions							[3] Extensions {bound}						OPTIONAL,
211	aChChargingAddress					[50] AChChargingAddress {bound}
212												DEFAULT legID:sendingSideID:leg1,
213	...,
214	-- WS modification Frensh National standard addition
215	-- https://gitlab.com/wireshark/wireshark/-/issues/7656
216	iTXcharging [64] BOOLEAN OPTIONAL
217	-- End WS
218	}
219
220-- The partyToCharge parameter indicates the party in the call to which the ApplyCharging operation
221-- shall be applied.
222
223applyChargingReport {PARAMETERS-BOUND : bound} OPERATION ::= {
224	ARGUMENT		ApplyChargingReportArg {bound}
225	RETURN RESULT	FALSE
226	ERRORS			{missingParameter |
227					unexpectedComponentSequence |
228					unexpectedParameter |
229					unexpectedDataValue |
230					unknownCSID |
231					unknownLegID |
232					parameterOutOfRange |
233					systemFailure |
234					taskRefused}
235	CODE			opcode-applyChargingReport}
236-- Direction: gsmSSF -> gsmSCF, Timer: Tacr
237-- This operation is used by the gsmSSF to report to the gsmSCF the occurrence of a
238-- specific charging event as requested by the gsmSCF using the ApplyCharging operation.
239
240ApplyChargingReportArg {PARAMETERS-BOUND : bound} ::= CallResult {bound}
241
242assistRequestInstructions {PARAMETERS-BOUND : bound} OPERATION ::= {
243	ARGUMENT		AssistRequestInstructionsArg {bound}
244	RETURN RESULT	FALSE
245	ERRORS			{missingCustomerRecord |
246					missingParameter |
247					systemFailure |
248					taskRefused |
249					unexpectedComponentSequence |
250					unexpectedDataValue |
251					unexpectedParameter}
252	CODE			opcode-assistRequestInstructions}
253-- Direction: gsmSSF -> gsmSCF or gsmSRF -> gsmSCF, Timer: Tari
254-- This operation is used when there is an assist procedure and may be
255-- sent by the gsmSSF or gsmSRF to the gsmSCF. This operation is sent by the
256-- assisting gsmSSF to gsmSCF, when the initiating gsmSSF has set up a connection to
257-- the gsmSRF or to the assisting gsmSSF as a result of receiving an
258-- EstablishTemporaryConnection from
259-- the gsmSCF.
260-- Refer to clause 11 for a description of the procedures associated with this operation.
261
262AssistRequestInstructionsArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
263	correlationID						[0] CorrelationID {bound},
264	iPSSPCapabilities					[2] IPSSPCapabilities {bound},
265	extensions							[3] Extensions {bound}						OPTIONAL,
266	...
267	}
268-- OPTIONAL denotes network operator specific use. The value of the correlationID may be the
269-- Called Party Number supplied by the initiating gsmSSF.
270
271callGap {PARAMETERS-BOUND : bound} OPERATION ::= {
272	ARGUMENT		CallGapArg {bound}
273	RETURN RESULT	FALSE
274	ALWAYS RESPONDS FALSE
275	CODE			opcode-callGap}
276-- Direction: gsmSCF -> gsmSSF, Timer: Tcg
277-- This operation is used to request the gsmSSF to reduce the rate at which specific service
278-- requests are sent to the gsmSCF.
279
280CallGapArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
281	gapCriteria							[0] GapCriteria {bound},
282	gapIndicators						[1] GapIndicators,
283	controlType							[2] ControlType								OPTIONAL,
284	gapTreatment						[3] GapTreatment {bound}					OPTIONAL,
285	extensions							[4] Extensions {bound}						OPTIONAL,
286	...
287	}
288-- OPTIONAL denotes network operator optional. If gapTreatment is not present, then the gsmSSF will
289-- use a default treatment depending on network operator implementation.
290
291callInformationReport {PARAMETERS-BOUND : bound} OPERATION ::= {
292	ARGUMENT		CallInformationReportArg {bound}
293	RETURN RESULT	FALSE
294	ALWAYS RESPONDS	FALSE
295	CODE			opcode-callInformationReport}
296-- Direction: gsmSSF -> gsmSCF, Timer: Tcirp
297-- This operation is used to send specific call information for a single call party to the gsmSCF as
298-- requested by the gsmSCF in a previous CallInformationRequest.
299
300CallInformationReportArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
301	requestedInformationList			[0] RequestedInformationList {bound},
302	extensions							[2] Extensions {bound}						OPTIONAL,
303	legID								[3] ReceivingSideID DEFAULT receivingSideID:leg2,
304	...
305	}
306
307callInformationRequest {PARAMETERS-BOUND : bound} OPERATION ::= {
308	ARGUMENT		CallInformationRequestArg {bound}
309	RETURN RESULT	FALSE
310	ERRORS			{missingParameter |
311					parameterOutOfRange |
312					requestedInfoError |
313					systemFailure |
314					taskRefused |
315					unexpectedComponentSequence |
316					unexpectedDataValue |
317					unexpectedParameter |
318					unknownLegID}
319	CODE			opcode-callInformationRequest}
320-- Direction: gsmSCF -> gsmSSF, Timer: Tcirq
321-- This operation is used to request the gsmSSF to record specific information about a single
322-- call party and report it to the gsmSCF (with a CallInformationReport operation).
323
324CallInformationRequestArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
325	requestedInformationTypeList		[0] RequestedInformationTypeList,
326	extensions							[2] Extensions {bound}						OPTIONAL,
327	legID								[3] SendingSideID DEFAULT sendingSideID:leg2,
328	...
329	}
330-- OPTIONAL denotes network operator optional.
331
332cancel {PARAMETERS-BOUND : bound} OPERATION ::= {
333	ARGUMENT		CancelArg {bound}
334	RETURN RESULT	FALSE
335	ERRORS			{cancelFailed |
336					missingParameter |
337					taskRefused |
338					unknownCSID}
339	CODE			opcode-cancel}
340-- Direction: gsmSCF -> gsmSSF, or gsmSCF -> gsmSRF, Timer: Tcan
341-- This operation cancels the correlated previous operation or all previous requests. The following
342-- operations can be canceled: PlayAnnouncement, PromptAndCollectUserInformation.
343
344CancelArg {PARAMETERS-BOUND : bound} ::= CHOICE {
345	invokeID							[0] InvokeID,
346	allRequests							[1] NULL,
347	callSegmentToCancel					[2]	CallSegmentToCancel {bound}
348	}
349-- The InvokeID has the same value as that which was used for the operation to be cancelled.
350
351collectInformation {PARAMETERS-BOUND : bound} OPERATION::= {
352	ARGUMENT			CollectInformationArg {bound}
353	RETURN RESULT		FALSE
354	ERRORS		{missingParameter |
355					parameterOutOfRange |
356					SystemFailure	|
357					TaskRefused	|
358					UnexpectedComponentSequence	|
359					UnexpectedDataValue	|
360					UnexpectedParameter}
361	CODE				opcode-collectInformation}
362-- Direction: gsmSCF-> gsmSSF, Timer: Tci
363-- This operation is used to request the gsmSSF to perform the call
364-- processing actions to prompt a calling party for additional digits.
365
366CollectInformationArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
367	extensions										[0]	Extensions {bound}	OPTIONAL,
368	...
369}
370
371connect {PARAMETERS-BOUND : bound} OPERATION ::= {
372	ARGUMENT		ConnectArg {bound}
373	RETURN RESULT	FALSE
374	ERRORS			{missingParameter |
375					parameterOutOfRange |
376					systemFailure |
377					taskRefused |
378					unexpectedComponentSequence |
379					unexpectedDataValue |
380					unexpectedParameter |
381					unknownLegID}
382	CODE			opcode-connect}
383-- Direction: gsmSCF-> gsmSSF, Timer: Tcon
384-- This operation is used to request the gsmSSF to perform the call processing actions
385-- to route or forward a call to a specified destination.
386
387ConnectArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
388	destinationRoutingAddress			[0] DestinationRoutingAddress {bound},
389	alertingPattern						[1] AlertingPattern							OPTIONAL,
390	originalCalledPartyID				[6] OriginalCalledPartyID {bound}			OPTIONAL,
391	extensions							[10] Extensions {bound}						OPTIONAL,
392	carrier								[11] Carrier {bound}						OPTIONAL,
393	callingPartysCategory				[28] CallingPartysCategory					OPTIONAL,
394	redirectingPartyID					[29] RedirectingPartyID {bound}				OPTIONAL,
395	redirectionInformation				[30] RedirectionInformation					OPTIONAL,
396	genericNumbers						[14] GenericNumbers {bound}					OPTIONAL,
397	serviceInteractionIndicatorsTwo 	[15] ServiceInteractionIndicatorsTwo		OPTIONAL,
398	chargeNumber						[19] ChargeNumber {bound}					OPTIONAL,
399	legToBeConnected					[21] LegID									OPTIONAL,
400	cug-Interlock						[31] CUG-Interlock							OPTIONAL,
401	cug-OutgoingAccess					[32] NULL									OPTIONAL,
402	suppressionOfAnnouncement			[55] SuppressionOfAnnouncement				OPTIONAL,
403	oCSIApplicable						[56] OCSIApplicable							OPTIONAL,
404	naOliInfo							[57] NAOliInfo								OPTIONAL,
405	bor-InterrogationRequested			[58] NULL									OPTIONAL,
406	... ,
407	suppress-N-CSI						[59] NULL									OPTIONAL
408	}
409-- na-Info is included at the discretion of the gsmSCF operator.
410
411connectToResource {PARAMETERS-BOUND : bound} OPERATION ::= {
412	ARGUMENT		ConnectToResourceArg {bound}
413	RETURN RESULT	FALSE
414	ERRORS			{missingParameter |
415					systemFailure |
416					taskRefused |
417					unexpectedComponentSequence |
418					unexpectedDataValue |
419					unexpectedParameter |
420					unknownCSID}
421	CODE			opcode-connectToResource}
422-- Direction: gsmSCF -> gsmSSF, Timer: Tctr
423-- This operation is used to connect a call segment from the gsmSSF to the
424-- gsmSRF.
425
426ConnectToResourceArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
427	resourceAddress	CHOICE {
428		ipRoutingAddress					[0] IPRoutingAddress {bound},
429		none								[3] NULL
430		},
431	extensions							[4] Extensions {bound}						OPTIONAL,
432	serviceInteractionIndicatorsTwo		[7] ServiceInteractionIndicatorsTwo			OPTIONAL,
433	callSegmentID						[50] CallSegmentID {bound}					OPTIONAL,
434	...
435	}
436
437continue OPERATION ::= {
438	RETURN RESULT	FALSE
439	ALWAYS RESPONDS	FALSE
440	CODE			opcode-continue}
441-- Direction: gsmSCF -> gsmSSF, Timer: Tcue
442-- This operation is used to request the gsmSSF to proceed with call processing at the
443-- DP at which it previously suspended call processing to await gsmSCF instructions
444-- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
445-- processing without substituting new data from gsmSCF.
446
447continueWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
448	ARGUMENT		ContinueWithArgumentArg {bound}
449	RETURN RESULT	FALSE
450	ERRORS			{missingParameter |
451					parameterOutOfRange |
452					unexpectedComponentSequence |
453					unexpectedDataValue |
454					unexpectedParameter |
455					unknownLegID |
456					unknownCSID}
457	CODE			opcode-continueWithArgument}
458-- Direction: gsmSCF -> gsmSSF, Timer: Tcwa
459-- This operation is used to request the gsmSSF to proceed with call processing at the
460-- DP at which it previously suspended call processing to await gsmSCF instructions
461-- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
462-- processing with the modified call setup information as received from the gsmSCF.
463
464ContinueWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
465	alertingPattern						[1] AlertingPattern							OPTIONAL,
466	extensions							[6] Extensions {bound}						OPTIONAL,
467	serviceInteractionIndicatorsTwo		[7] ServiceInteractionIndicatorsTwo			OPTIONAL,
468	callingPartysCategory				[12] CallingPartysCategory					OPTIONAL,
469	genericNumbers						[16] GenericNumbers {bound}					OPTIONAL,
470	cug-Interlock						[17] CUG-Interlock							OPTIONAL,
471	cug-OutgoingAccess					[18] NULL									OPTIONAL,
472	chargeNumber						[50] ChargeNumber {bound}					OPTIONAL,
473	carrier								[52] Carrier {bound}						OPTIONAL,
474	suppressionOfAnnouncement			[55] SuppressionOfAnnouncement				OPTIONAL,
475	naOliInfo							[56] NAOliInfo								OPTIONAL,
476	bor-InterrogationRequested			[57] NULL									OPTIONAL,
477	suppress-O-CSI						[58] NULL									OPTIONAL,
478	continueWithArgumentArgExtension	[59] ContinueWithArgumentArgExtension {bound} OPTIONAL,
479	...
480	}
481
482ContinueWithArgumentArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
483	suppress-D-CSI						[0]	NULL									OPTIONAL,
484	suppress-N-CSI						[1]	NULL									OPTIONAL,
485	suppressOutgoingCallBarring			[2]	NULL									OPTIONAL,
486	legOrCallSegment					[3]	LegOrCallSegment {bound}				OPTIONAL,
487	...
488	}
489
490disconnectForwardConnection OPERATION ::= {
491	RETURN RESULT	FALSE
492	ERRORS			{systemFailure |
493					taskRefused |
494					unexpectedComponentSequence}
495	CODE			opcode-disconnectForwardConnection}
496-- Direction: gsmSCF -> gsmSSF, Timer: Tdfc
497-- This operation is used to disconnect a forward temporary connection or a connection to a
498-- resource. Refer to clause 11 for a description of the procedures associated with this operation.
499
500disconnectForwardConnectionWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
501	ARGUMENT		DisconnectForwardConnectionWithArgumentArg {bound}
502	RETURN RESULT	FALSE
503	ERRORS			{missingParameter |
504					systemFailure |
505					taskRefused |
506					unexpectedComponentSequence |
507					unexpectedDataValue |
508					unexpectedParameter |
509					unknownCSID}
510	CODE			opcode-dFCWithArgument}
511-- Direction gsmSCF -> gsmSSF, Timer Tdfcwa
512-- This operation is used to disconnect a forward temporary connection or a connection to a
513-- resource. Refer to clause 11 for a description of the procedures associated with this operation.
514
515DisconnectForwardConnectionWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
516	callSegmentID						[1] CallSegmentID {bound}					OPTIONAL,
517	extensions							[2] Extensions {bound}						OPTIONAL,
518	...
519	}
520
521disconnectLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
522	ARGUMENT		DisconnectLegArg {bound}
523	RETURN RESULT	TRUE
524	ERRORS			{missingParameter |
525					systemFailure |
526					taskRefused |
527					unexpectedComponentSequence |
528					unexpectedDataValue |
529					unexpectedParameter |
530					unknownLegID}
531	CODE			opcode-disconnectLeg}
532-- Direction: gsmSCF -> gsmSSF, Timer Tdl
533-- This operation is used by the gsmSCF to release a specific leg associated with the call and
534-- retain any other legs not specified in the DisconnectLeg. Refer to clause 11 for a description
535-- of the procedures associated with this operation.
536
537DisconnectLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
538	legToBeReleased						[0]	LegID,
539	releaseCause						[1]	Cause {bound}							OPTIONAL,
540	extensions							[2]	Extensions {bound}						OPTIONAL,
541	...
542	}
543
544entityReleased {PARAMETERS-BOUND : bound} OPERATION ::= {
545	ARGUMENT		EntityReleasedArg {bound}
546	RETURN RESULT	FALSE
547	ALWAYS RESPONDS	FALSE
548	CODE			opcode-entityReleased}
549-- Direction: gsmSSF -> gsmSCF, Timer: Ter
550-- This operation is used by the gsmSSF to inform the gsmSCF of an error or exception
551
552EntityReleasedArg {PARAMETERS-BOUND : bound} ::= CHOICE {
553	callSegmentFailure					[0]	CallSegmentFailure {bound},
554	bCSM-Failure						[1]	BCSM-Failure {bound}
555	}
556
557establishTemporaryConnection {PARAMETERS-BOUND : bound} OPERATION ::= {
558	ARGUMENT		EstablishTemporaryConnectionArg {bound}
559	RETURN RESULT	FALSE
560	ERRORS			{eTCFailed |
561					missingParameter |
562					systemFailure |
563					taskRefused |
564					unexpectedComponentSequence |
565					unexpectedDataValue |
566					unexpectedParameter |
567					unknownCSID}
568	CODE			opcode-establishTemporaryConnection}
569-- Direction: gsmSCF -> gsmSSF, Timer: Tetc
570-- This operation is used to create a connection to a resource for a limited period
571-- of time (e.g. to play an announcement, to collect user information); it implies
572-- the use of the assist procedure. Refer to clause 11 for a description of the
573-- procedures associated with this operation.
574
575EstablishTemporaryConnectionArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
576	assistingSSPIPRoutingAddress		[0] AssistingSSPIPRoutingAddress {bound},
577	correlationID						[1] CorrelationID {bound}					OPTIONAL,
578	scfID								[3] ScfID {bound}							OPTIONAL,
579	extensions							[4] Extensions {bound}						OPTIONAL,
580	carrier								[5] Carrier {bound}							OPTIONAL,
581	serviceInteractionIndicatorsTwo		[6] ServiceInteractionIndicatorsTwo			OPTIONAL,
582	callSegmentID						[7]	CallSegmentID {bound}					OPTIONAL,
583	naOliInfo							[50] NAOliInfo								OPTIONAL,
584	chargeNumber						[51] ChargeNumber {bound}					OPTIONAL,
585	...,
586	originalCalledPartyID				[52] OriginalCalledPartyID {bound}			OPTIONAL,
587	callingPartyNumber					[53] CallingPartyNumber {bound}				OPTIONAL
588	}
589
590eventReportBCSM {PARAMETERS-BOUND : bound} OPERATION ::= {
591	ARGUMENT		EventReportBCSMArg {bound}
592	RETURN RESULT	FALSE
593	ALWAYS RESPONDS	FALSE
594	CODE			opcode-eventReportBCSM}
595-- Direction: gsmSSF -> gsmSCF, Timer: Terb
596-- This operation is used to notify the gsmSCF of a call-related event (e.g. BCSM
597-- events such as O_Busy or O_No_Answer) previously requested by the gsmSCF in a
598-- RequestReportBCSMEvent operation.
599
600EventReportBCSMArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
601	eventTypeBCSM						[0] EventTypeBCSM,
602	eventSpecificInformationBCSM		[2] EventSpecificInformationBCSM {bound}	OPTIONAL,
603	legID								[3] ReceivingSideID							OPTIONAL,
604	miscCallInfo						[4] MiscCallInfo DEFAULT {messageType request},
605	extensions							[5] Extensions {bound}						OPTIONAL,
606	...
607	}
608
609furnishChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
610	ARGUMENT		FurnishChargingInformationArg {bound}
611	RETURN RESULT	FALSE
612	ERRORS			{missingParameter |
613					taskRefused |
614					unexpectedComponentSequence |
615					unexpectedDataValue |
616					unexpectedParameter |
617					unknownLegID}
618	CODE			opcode-furnishChargingInformation}
619-- Direction: gsmSCF -> gsmSSF, Timer: Tfci
620-- This operation is used to request the gsmSSF to generate, register a call record
621-- or to include some information in the default call record.
622-- The registered call record is intended for off line charging of the call.
623
624FurnishChargingInformationArg {PARAMETERS-BOUND : bound} ::=
625	FCIBillingChargingCharacteristics{bound}
626
627initialDP {PARAMETERS-BOUND : bound} OPERATION ::= {
628	ARGUMENT		InitialDPArg {bound}
629	RETURN RESULT	FALSE
630	ERRORS			{missingCustomerRecord |
631					missingParameter |
632					parameterOutOfRange |
633					systemFailure |
634					taskRefused |
635					unexpectedComponentSequence |
636					unexpectedDataValue |
637					unexpectedParameter}
638	CODE			opcode-initialDP}
639-- Direction: gsmSSF -> gsmSCF, Timer: Tidp
640-- This operation is used after a TDP to indicate request for service.
641
642InitialDPArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
643	serviceKey							[0] ServiceKey	,
644	calledPartyNumber					[2] CalledPartyNumber {bound}				OPTIONAL,
645	callingPartyNumber					[3] CallingPartyNumber {bound}				OPTIONAL,
646	callingPartysCategory				[5] CallingPartysCategory					OPTIONAL,
647	cGEncountered						[7] CGEncountered							OPTIONAL,
648	iPSSPCapabilities					[8] IPSSPCapabilities {bound}				OPTIONAL,
649	locationNumber						[10] LocationNumber {bound}					OPTIONAL,
650	originalCalledPartyID				[12] OriginalCalledPartyID {bound}			OPTIONAL,
651	extensions							[15] Extensions {bound}						OPTIONAL,
652	highLayerCompatibility				[23] HighLayerCompatibility					OPTIONAL,
653	additionalCallingPartyNumber		[25] AdditionalCallingPartyNumber {bound}	OPTIONAL,
654	bearerCapability					[27] BearerCapability {bound}				OPTIONAL,
655	eventTypeBCSM						[28] EventTypeBCSM							OPTIONAL,
656	redirectingPartyID					[29] RedirectingPartyID {bound}				OPTIONAL,
657	redirectionInformation				[30] RedirectionInformation					OPTIONAL,
658	cause								[17] Cause {bound}							OPTIONAL,
659	serviceInteractionIndicatorsTwo		[32] ServiceInteractionIndicatorsTwo		OPTIONAL,
660	carrier								[37] Carrier {bound}						OPTIONAL,
661	cug-Index							[45] CUG-Index								OPTIONAL,
662	cug-Interlock						[46] CUG-Interlock							OPTIONAL,
663	cug-OutgoingAccess					[47] NULL									OPTIONAL,
664	iMSI								[50] IMSI									OPTIONAL,
665	subscriberState						[51] SubscriberState						OPTIONAL,
666	locationInformation					[52] LocationInformation					OPTIONAL,
667	ext-basicServiceCode				[53] Ext-BasicServiceCode					OPTIONAL,
668	callReferenceNumber					[54] CallReferenceNumber					OPTIONAL,
669	mscAddress							[55] ISDN-AddressString						OPTIONAL,
670	calledPartyBCDNumber				[56] CalledPartyBCDNumber {bound}			OPTIONAL,
671	timeAndTimezone						[57] TimeAndTimezone {bound}				OPTIONAL,
672	callForwardingSS-Pending			[58] NULL									OPTIONAL,
673	initialDPArgExtension				[59] InitialDPArgExtension {bound}			OPTIONAL,
674	...
675	}
676
677InitialDPArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
678	gmscAddress							[0] ISDN-AddressString						OPTIONAL,
679	forwardingDestinationNumber			[1] CalledPartyNumber {bound}				OPTIONAL,
680	ms-Classmark2						[2] MS-Classmark2							OPTIONAL,
681	iMEI								[3] IMEI									OPTIONAL,
682	supportedCamelPhases				[4] SupportedCamelPhases					OPTIONAL,
683	offeredCamel4Functionalities		[5] OfferedCamel4Functionalities			OPTIONAL,
684	bearerCapability2					[6] BearerCapability {bound}				OPTIONAL,
685	ext-basicServiceCode2				[7] Ext-BasicServiceCode					OPTIONAL,
686	highLayerCompatibility2				[8] HighLayerCompatibility					OPTIONAL,
687	lowLayerCompatibility				[9] LowLayerCompatibility {bound}			OPTIONAL,
688	lowLayerCompatibility2				[10] LowLayerCompatibility {bound}			OPTIONAL,
689	...,
690	enhancedDialledServicesAllowed		[11] NULL									OPTIONAL,
691	uu-Data								[12] UU-Data								OPTIONAL,
692	collectInformationAllowed			[13] NULL									OPTIONAL,
693	releaseCallArgExtensionAllowed		[14] NULL									OPTIONAL
694}
695-- If iPSSPCapabilities is not present then this denotes that a colocated gsmSRF is not
696-- supported by the gsmSSF. If present, then the gsmSSF supports a colocated gsmSRF capable
697-- of playing announcements via elementaryMessageIDs and variableMessages, the playing of
698-- tones and the collection of DTMF digits. Other supported capabilities are explicitly
699-- detailed in the IPSSPCapabilities parameter itself.
700-- Carrier is included at the discretion of the gsmSSF operator.
701-- The UserCSGInformation is conveyed in the LocationInformation. The encoding of the parameter is
702-- as defined in 3GPP TS 29.002 [11].
703
704initiateCallAttempt {PARAMETERS-BOUND : bound} OPERATION ::= {
705	ARGUMENT		InitiateCallAttemptArg {bound}
706	RESULT			InitiateCallAttemptRes {bound}
707	ERRORS			{missingParameter |
708					parameterOutOfRange |
709					systemFailure |
710					taskRefused |
711					unexpectedComponentSequence |
712					unexpectedDataValue |
713					unexpectedParameter
714					}
715	CODE			opcode-initiateCallAttempt}
716-- Direction: gsmSCF -> gsmSSF, Timer Tica
717-- This operation is used to instruct the gsmSSF to create a new call to a call party using the
718-- address information provided by the gsmSCF.
719
720InitiateCallAttemptArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
721	destinationRoutingAddress			[0]	DestinationRoutingAddress {bound},
722	extensions							[4]	Extensions {bound}						OPTIONAL,
723	legToBeCreated						[5]	LegID									OPTIONAL,
724	newCallSegment						[6]	CallSegmentID {bound}					OPTIONAL,
725	callingPartyNumber					[30] CallingPartyNumber {bound}				OPTIONAL,
726	callReferenceNumber					[51] CallReferenceNumber					OPTIONAL,
727	gsmSCFAddress						[52] ISDN-AddressString						OPTIONAL,
728	suppress-T-CSI						[53] NULL									OPTIONAL,
729	...
730	}
731
732InitiateCallAttemptRes {PARAMETERS-BOUND : bound} ::= SEQUENCE {
733	supportedCamelPhases				[0] SupportedCamelPhases					OPTIONAL,
734	offeredCamel4Functionalities		[1] OfferedCamel4Functionalities			OPTIONAL,
735	extensions							[2]	Extensions {bound}						OPTIONAL,
736	...,
737	releaseCallArgExtensionAllowed		[3]	NULL									OPTIONAL
738	}
739
740moveLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
741	ARGUMENT		MoveLegArg {bound}
742	RETURN RESULT	TRUE
743	ERRORS			{missingParameter |
744					systemFailure |
745					taskRefused |
746					unexpectedComponentSequence |
747					unexpectedDataValue |
748					unexpectedParameter |
749					unknownLegID}
750	CODE			opcode-moveLeg}
751-- Direction: gsmSCF -> gsmSSF, Timer: Tml
752-- This operation is used by the gsmSCF to move a leg from one call segment to another call segment
753-- within the same call segment association.
754
755MoveLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
756	legIDToMove							[0]	LegID,
757	extensions							[2]	Extensions {bound}						OPTIONAL,
758	...
759	}
760
761playTone {PARAMETERS-BOUND : bound} OPERATION ::= {
762	ARGUMENT		PlayToneArg {bound}
763	RETURN RESULT	FALSE
764	ERRORS			{missingParameter |
765					parameterOutOfRange |
766					systemFailure |
767					unexpectedComponentSequence |
768					unexpectedDataValue |
769					unexpectedParameter |
770					unknownLegID |
771					unknownCSID}
772	CODE			opcode-playTone}
773-- Direction: gsmSCF -> gsmSSF, Timer: Tpt
774-- This operation is used to play tones to either a leg or a call segment using
775-- the MSC's tone generator.
776
777PlayToneArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
778	legOrCallSegment					[0] LegOrCallSegment {bound},
779	bursts								[1] Burst,
780	extensions							[2] Extensions {bound}						OPTIONAL,
781	...
782	}
783
784releaseCall {PARAMETERS-BOUND : bound} OPERATION ::= {
785	ARGUMENT		ReleaseCallArg {bound}
786	RETURN RESULT	FALSE
787	ALWAYS RESPONDS	FALSE
788	CODE			opcode-releaseCall}
789-- Direction: gsmSCF ->?gsmSSF, Timer: Trc
790-- This operation is used to tear down an existing call at any phase of the call for all parties
791-- involved in the call.
792
793ReleaseCallArg {PARAMETERS-BOUND : bound} ::= CHOICE {
794	allCallSegments					AllCallSegments,
795	allCallSegmentsWithExtension	[2] AllCallSegmentsWithExtension
796	}
797
798AllCallSegments ::= Cause {bound}
799-- A default value of decimal 31 (normal unspecified) shall be given.
800
801AllCallSegmentsWithExtension ::= SEQUENCE {
802	allCallSegments				[0] AllCallSegments,
803	extensions					[1] Extensions {bound} OPTIONAL
804	}
805
806requestReportBCSMEvent {PARAMETERS-BOUND : bound} OPERATION ::= {
807	ARGUMENT		RequestReportBCSMEventArg {bound}
808	RETURN RESULT	FALSE
809	ERRORS			{missingParameter |
810					parameterOutOfRange |
811					systemFailure |
812					taskRefused |
813					unexpectedComponentSequence |
814					unexpectedDataValue |
815					unexpectedParameter |
816					unknownLegID}
817	CODE			opcode-requestReportBCSMEvent}
818-- Direction: gsmSCF -> gsmSSF, Timer: Trrb
819-- This operation is used to request the gsmSSF to monitor for a call-related event
820-- (e.g. BCSM events such as O_Busy or O_No_Answer) and to send a notification
821-- to the gsmSCF when the event is detected.
822--
823-- NOTE:
824-- Every EDP must be explicitly armed by the gsmSCF via a RequestReportBCSMEvent operation.
825-- No implicit arming of EDPs at the gsmSSF after reception of any operation (different
826-- from RequestReportBCSMEvent) from the gsmSCF is allowed.
827
828RequestReportBCSMEventArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
829	bcsmEvents							[0] SEQUENCE SIZE(1..bound.&numOfBCSMEvents) OF
830												BCSMEvent {bound},
831	extensions							[2] Extensions {bound}						OPTIONAL,
832	...
833	}
834-- Indicates the BCSM related events for notification.
835
836resetTimer {PARAMETERS-BOUND : bound} OPERATION ::= {
837	ARGUMENT		ResetTimerArg {bound}
838	RETURN RESULT	FALSE
839	ERRORS			{missingParameter |
840					parameterOutOfRange |
841					taskRefused |
842					unexpectedComponentSequence |
843					unexpectedDataValue |
844					unexpectedParameter |
845					unknownCSID}
846	CODE			opcode-resetTimer}
847-- Direction: gsmSCF -> gsmSSF, Timer: Trt
848-- This operation is used to request the gsmSSF to refresh an application timer in the gsmSSF.
849
850ResetTimerArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
851	timerID								[0] TimerID	DEFAULT tssf,
852	timervalue							[1] TimerValue,
853	extensions							[2] Extensions {bound}						OPTIONAL,
854	callSegmentID						[3]	CallSegmentID {bound}					OPTIONAL,
855	...
856	}
857
858sendChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
859	ARGUMENT		SendChargingInformationArg {bound}
860	RETURN RESULT	FALSE
861	ERRORS			{missingParameter |
862					unexpectedComponentSequence |
863					unexpectedParameter |
864					parameterOutOfRange |
865					systemFailure |
866					taskRefused |
867					unexpectedDataValue |
868					unknownLegID}
869	CODE			opcode-sendChargingInformation}
870-- Direction: gsmSCF -> gsmSSF, Timer: Tsci
871-- This operation is used to instruct the gsmSSF on the charging information to send by the gsmSSF.
872-- The charging information can either be sent back by means of signalling or internal
873-- if the gsmSSF is located in the local exchange. In the local exchange
874-- this information may be used to update the charge meter or to create a standard call record.
875
876SendChargingInformationArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
877	sCIBillingChargingCharacteristics	[0] SCIBillingChargingCharacteristics {bound},
878	partyToCharge						[1] SendingSideID,
879	extensions							[2] Extensions {bound}						OPTIONAL,
880	...
881	}
882
883splitLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
884	ARGUMENT		SplitLegArg {bound}
885	RETURN RESULT	TRUE
886	ERRORS			{missingParameter |
887					unexpectedComponentSequence |
888					unexpectedParameter |
889					unexpectedDataValue |
890					systemFailure |
891					taskRefused |
892					unknownLegID}
893	CODE			opcode-splitLeg}
894-- Direction: gsmSCF -> gsmSSF, Timer Tsl
895-- This operation is used by the gsmSCF to separate a leg from its source call segment and
896-- place it in a new call segment within the same call segment association.
897
898SplitLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
899	legToBeSplit						[0]	LegID,
900	newCallSegment						[1]	CallSegmentID {bound}					OPTIONAL,
901	extensions							[2]	Extensions {bound}						OPTIONAL,
902	...
903	}
904
905END
906