6 Abstract syntax of the CS1 INAP

6.1 IN CS1 operation types
6.2 IN CS1 error types
6.3 IN CS1 data types
6.4 IN CS1 application protocol (operation and error codes)
6.5 IN CS1 application contexts

This Clause specifies the abstract syntax for the CS1 INAP, using ASN.1 as defined in CCITT Recommendation X.208 [14].
The encoding rules which are applicable to the defined abstract syntax are the Basic Encoding Rules for ASN.1, defined in CCITT Recommendation X.209 [15] with the restrictions as described in ETS 300 287 [5] (ITU-T Recommendation Q.773, � 4.1.1). Additional encodings are cited for parameters used in existing ISUP (ETS 300 356-1 [8]) and DSS1 (ETS 300 403-1 [7]) standards.
Any tags and values used in the ITU-T Recommendation Q1218 [12] and not used in this ETS shall be regarded as reserved.
For the ISUP and DSS1 parameters used in the INAP, only the coding of the parameter value will be coded as defined in ISUP or DSS1. The DSS1/ISUP defined parameter identifiers are removed and replaced by the INAP defined parameter identifiers.
The mapping of OPERATION and ERROR to TCAP components is defined in ETS 300 287 [5] (ITU-T Recommendation Q.773). The class of an operation is not stated explicitly but is specified in the ASN.1 OPERATION MACRO, as follows:

	class 1: 	both RESULT and ERRORS appear in the ASN.1 OPERATION MACRO definition;
	class 2:	only ERRORS appears in the ASN.1 OPERATION MACRO definition;
	class 3:	only RESULT appears in the ASN.1 OPERATION MACRO definition;
	class 4:	neither RESULT nor ERRORS appears in the ASN.1 OPERATION MACRO definition.

These map to the classes 2 through 5, respectively, specified in CCITT Recommendation X.219 [16] and ETS 300 196 [4] (ITU-T Recommendation Q.932).
The abstract syntax for INAP is composed of several ASN.1 modules describing operations, errors, and associated data types. The values (operation codes and error codes) are defined in a separate module.
The module containing all the type definitions for INAP operations is IN-CS1-Operations and is described in subclause 6.1.
The module containing all the type definitions for INAP errors is IN-CS1-Errors and is described in subclause 6.2.
The module containing all the type definitions for INAP data types is IN-CS1-DataTypes and is described in subclause 6.3.
The module containing the operation codes and error codes for INAP is IN-CS1-Codes and is described in subclause 6.4.
All the AC definitions for Core INAP are described in subclause 6.5.

6.1 IN CS1 operation types

Core-INAP-CS1-Operations {ccitt(0) identified-organization(4) etsi(0) inDomain(1) in-network(1) modules(0) cs1-operations(0) version1(0)}

--  This module contains the type definitions for the IN CS1 operations.

DEFINITIONS ::=

BEGIN

IMPORTS
	OPERATION
FROM TCAPMessages {ccitt recommendation q 773 modules(2) messages(1) version2(2)}

--  error types
	Canceled,
	CancelFailed,
	ETCFailed,
	ImproperCallerResponse,
	MissingCustomerRecord,
	MissingParameter,
	ParameterOutOfRange,
	RequestedInfoError,
	SystemFailure,
	TaskRefused,
	UnavailableResource,
	UnexpectedComponentSequence,
	UnexpectedDataValue,
	UnexpectedParameter,
	UnknownLegID

FROM Core-INAP-CS1-Errors {ccitt(0) identified-organization(4) etsi(0) inDomain(1) in-network(1) modules(0) cs1-errors(1) version1(0)}

--  argument types
	ActivateServiceFilteringArg,
	ApplyChargingArg,
	ApplyChargingReportArg,
	AssistRequestInstructionsArg,
	CallGapArg,
	CallInformationReportArg,
	CallInformationRequestArg,
	CancelArg">CancelArg,
	CollectInformationArg,
	ConnectArg,
	ConnectToResourceArg,
	EstablishTemporaryConnectionArg,
	EventNotificationChargingArg,
	EventReportBCSMArg,
	FurnishChargingInformationArg,
	InitialDPArg,
	InitiateCallAttemptArg,
	PlayAnnouncementArg,
	PromptAndCollectUserInformationArg,
	ReceivedInformationArg">ReceivedInformationArg,
	ReleaseCallArg,
	RequestNotificationChargingEventArg,
	RequestReportBCSMEventArg,
	ResetTimerArg,
	SendChargingInformationArg,
	ServiceFilteringResponseArg,
	SpecializedResourceReportArg

FROM Core-INAP-CS1-DataTypes {ccitt(0) identified-organization(4) etsi(0) inDomain(1) in-network(1) modules(0) cs1-datatypes(2) version1(0)};
 --  TYPE DEFINITIONS FOR IN CS1 OPERATIONS FOLLOWS

--  SCF-SSF operations

ActivateServiceFiltering 		::= OPERATION
	ARGUMENT
		ActivateServiceFilteringArg
	RESULT
	ERRORS {
		MissingParameter,
		ParameterOutOfRange,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Tasf
--  When receiving this operation, the SSF handles calls to destination in a specified manner 
--  without sending queries for every detected call. It is used for example for providing televoting 
--  or mass calling services. Simple registration functionality (counters) and announcement 
--  control may be located at the SSF. The operation initializes the specified counters in the SSF.
--

ActivityTest 		::= OPERATION
	RESULT
--  Direction: SCF -> SSF, Timer: Tat
--  This operation is used to check for the continued existence of a relationship between the SCF 
--  and SSF. If the relationship is still in existence, then the SSF will respond. If no reply is received, 
--  then the SCF will assume that the SSF has failed in some way and will take the appropriate 
--  action.

ApplyCharging  			::= OPERATION
	ARGUMENT
		ApplyChargingArg
	ERRORS {
		MissingParameter,
		UnexpectedComponentSequence,
		UnexpectedParameter,
		UnexpectedDataValue,
		ParameterOutOfRange,
		SystemFailure,
		TaskRefused
		}

--  Direction: SCF -> SSF, Timer: Tac
--  This operation is used 
--  for interacting from the SCF with the SSF charging mechanisms. The ApplyChargingReport
--  operation provides the feedback from the SSF to the SCF.

ApplyChargingReport  			::= OPERATION
	ARGUMENT
		ApplyChargingReportArg
	ERRORS {
		MissingParameter,
		UnexpectedComponentSequence,
		UnexpectedParameter,
		UnexpectedDataValue,
		ParameterOutOfRange,
		SystemFailure,
		TaskRefused
		}

--  Direction: SSF -> SCF, Timer: Tacr
--  This operation is used by the SSF to report to the
--  SCF the occurrence of a specific charging event as requested by the SCF using the
--  ApplyCharging operation.

AssistRequestInstructions 	::= OPERATION
	ARGUMENT
		AssistRequestInstructionsArg
	ERRORS {
		MissingCustomerRecord,
		MissingParameter,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SSF -> SCF or SRF -> SCF, Timer: Tari
--  This operation is used when there is an assist or a hand-off procedure and may be sent by the 
--  SSF or SRF to the SCF. This operation is sent by the SSF or SRF to the SCF, when the initiating
--  SSF has set up a connection to the SRF or to the assisting SSF as a result of receiving an
--  EstablishTemporaryConnection or Connect (in case of hand-off) operation from the SCF.

CallGap  			::= OPERATION
	ARGUMENT
		CallGapArg

--  Direction: SCF -> SSF, Timer: Tcg
--  This operation is used to request the SSF to reduce the rate at which specific service requests 
--  are sent to the SCF.

CallInformationReport 		::= OPERATION
	ARGUMENT
		CallInformationReportArg

--  Direction: SSF -> SCF, Timer: Tcirp
--  This operation is used to send specific call information for a single call to the SCF as 
--  requested by the SCF in a previous callInformationRequest.

CallInformationRequest 		::= OPERATION
	ARGUMENT
		CallInformationRequestArg
	ERRORS {
		MissingParameter,
		ParameterOutOfRange,
		RequestedInfoError,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Tcirq
--  This operation is used to request the SSF to record specific information about a single call
--  and report it to the SCF (with a callInformationReport operation).
Cancel 		::= OPERATION
	ARGUMENT
		CancelArg">CancelArg
	ERRORS {
		CancelFailed
		}

--  Direction:  SCF -> SRF or SCF -> SSF, Timer: Tcan
--  This generic operation cancels the correlated previous operation or all previous requests. The
--  following operations can be canceled:
--  PlayAnnouncement and PromptAndCollectUserInformation.

CollectInformation 	::= OPERATION
	ARGUMENT
		CollectInformationArg
	ERRORS {
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Tci
--  This operation is used to request the SSF to perform the originating basic call processing 
--  actions to prompt a calling party for destination information, then collect destination information 
--  according to a specified numbering plan (e.g., for virtual private networks).

Connect 		::= OPERATION
	ARGUMENT
		ConnectArg
	ERRORS {
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Tcon
--  This operation is used to request the SSF to perform the call processing actions to route or 
--  forward a call to a specified destination. To do so, the SSF may or may not use destination 
--  information from the calling party (e.g., dialed digits) and existing call setup information (e.g., 
--  route index to a list of trunk groups), depending on the information provided by the SCF.

ConnectToResource 	::= OPERATION
	ARGUMENT
		ConnectToResourceArg
	ERRORS {
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Tctr
--  This operation is used to connect a call from the SSP to the PE containing the SRF.

Continue 		::= OPERATION

--  Direction: SCF -> SSF, Timer: Tcue
--  This operation is used to request the SSF to proceed with call processing at the DP at which it 
--  previously suspended call processing to await SCF instructions (i.e., proceed to the next point 
--  in call in the BCSM). The SSF continues call processing without substituting new data from 
--  SCF.

DisconnectForwardConnection 	::= OPERATION
	ERRORS {
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence
		}

--  Direction: SCF -> SSF, Timer: Tdfc
--  This operation is used to disconnect a forward temporary connection  or a connection to a 
--  resource.

EstablishTemporaryConnection 	::= OPERATION
	ARGUMENT
		EstablishTemporaryConnectionArg
	ERRORS {
		ETCFailed,
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, 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.

EventNotificationCharging 	::= OPERATION
	ARGUMENT
		EventNotificationChargingArg

--  Direction: SSF -> SCF, Timer: Tenc
--  This operation is used by the SSF to  report to the SCF the occurence of a specific
--  charging  event type as previously requested by the SCF in a
--  RequestNotificationChargingEvent operation.
--  The operation supports the capabilities to cope with the interactions concerning charging (refer
--  to Annex B, Clause B.5).

EventReportBCSM 	::= OPERATION
	ARGUMENT
		EventReportBCSMArg

--  Direction: SSF -> SCF, Timer: Terb
--  This operation is used to notify the SCF of a call-related event (e.g., BCSM events such as 
--  busy or no answer) previously requested by the SCF in a RequestReportBCSMEvent 
--  operation.

FurnishChargingInformation 	::= OPERATION
	ARGUMENT
		FurnishChargingInformationArg
	ERRORS {
		MissingParameter,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Tfci

--  This operation is used to request the SSF 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.
--  The charging scenarios supported by this operation are: 2.2, 2.3 and 2.4 (refer to Annex B
--  where these are defined).

InitialDP 	::= OPERATION
	ARGUMENT
		InitialDPArg
	ERRORS {
		MissingCustomerRecord,
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SSF -> SCF, Timer: Tidp
--  This operation is used after a TDP to indicate request for service.

InitiateCallAttempt 	::= OPERATION
	ARGUMENT
		InitiateCallAttemptArg
	ERRORS {
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Tica
--  This operation is used to request the SSF to create a new call to one call party using 
--  address information provided by the SCF (e.g., wake-up call).

ReleaseCall 		::= OPERATION
	ARGUMENT
		ReleaseCallArg

--  Direction: SCF -> SSF, 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.

RequestNotificationChargingEvent 	::= OPERATION
	ARGUMENT
		RequestNotificationChargingEventArg
	ERRORS {
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Trnc

--  This operation is used by the SCF to instruct the SSF on how to manage the charging events
--  which are received from other FEs and not under control of the service logic instance. The
--  operation supports the capabilities to cope with the interactions concerning charging (refer to
--  Annex B, Clause B.5).

RequestReportBCSMEvent 	::= OPERATION
	ARGUMENT
		RequestReportBCSMEventArg
	ERRORS {
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Trrb
--  This operation is used to request the SSF to monitor for a call-related event (e.g., BCSM events 
--  such as busy or no answer), then send a notification back to the SCF when the event is 
--  detected.

ResetTimer 		::= OPERATION
	ARGUMENT
		ResetTimerArg
	ERRORS {
		MissingParameter,
		TaskRefused,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SSF, Timer: Trt
--  This operation is used to request the SSF to refresh an application timer in the SSF.

SendChargingInformation 		::= OPERATION
	ARGUMENT
		SendChargingInformationArg
	ERRORS {
		MissingParameter,
		UnexpectedComponentSequence,
		UnexpectedParameter,
		ParameterOutOfRange,
		SystemFailure,
		TaskRefused,
		UnknownLegID
		}

--  Direction: SCF -> SSF, Timer: Tsci
--  This operation is used to  instruct the
--  SSF on the charging information to be sent by the SSF.
--  The charging information can either be sent back by means of signalling or internal if the SSF 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.
--  The charging scenario supported by this operation is scenario 3.2 (refer to Annex B where these 
--  are defined).

ServiceFilteringResponse 	::= OPERATION
	ARGUMENT
		ServiceFilteringResponseArg

--  Direction: SSF -> SCF, Timer: Tsfr
--  This operation is used to send back to the SCF the values of counters specified in a previous 
--  ActivateServiceFiltering operation.

--  SCF-SRF operations

--  AssistRequestInstructions
--  SRF -> SCF
--  Refer to previous description of this operation in the SCF-SSF operations subclause.

--  Cancel
--  SCF -> SRF
--  Refer to previous description of this operation in the SCF-SSF operations subclause.

PlayAnnouncement 	::= OPERATION
	ARGUMENT
		PlayAnnouncementArg
	ERRORS {
		Canceled,
		MissingParameter,
		SystemFailure,
		UnavailableResource,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}
	LINKED {
		SpecializedResourceReport
		}

--  Direction: SCF -> SRF, Timer: Tpa
--  This operation is to be used after Establish Temporary Connection (assist procedure with a 
--  second SSP) or a Connect to Resource (no assist) operation. It may be used for inband 
--  interaction with an analog user, or for interaction with an ISDN user. In the former case, the SRF 
--  is usually collocated with the SSF for standard tones (congestion tone etc.) or standard 
--  announcements. In the latter case, the SRF is always collocated with the SSF in the switch. Any 
--  error is returned to the SCF. The timer associated with this operation must be of a sufficient 
--  duration to allow its linked operation to be correctly correlated.

PromptAndCollectUserInformation 	::= OPERATION
	ARGUMENT
		PromptAndCollectUserInformationArg
	RESULT
		ReceivedInformationArg">ReceivedInformationArg
	ERRORS {
		Canceled,
		ImproperCallerResponse,
		MissingParameter,
		SystemFailure,
		TaskRefused,
		UnavailableResource,
		UnexpectedComponentSequence,
		UnexpectedDataValue,
		UnexpectedParameter
		}

--  Direction: SCF -> SRF, Timer: Tpc
--  This operation is used to interact with a user to collect information.

SpecializedResourceReport 	::= OPERATION
	ARGUMENT
		SpecializedResourceReportArg

--  Direction: SRF -> SCF, Timer: Tsrr
--  This operation is used as 
--  the response to a PlayAnnouncement operation when the announcement completed report 
--  indication is set.

END

Operation Timers

The following value ranges do apply for operation specific timers in INAP:
short:		1 to 10 seconds;
medium:	1 to 60 seconds;
long:		1 second to 30 minutes.

Table 3 lists all operation timers and the value range for each timer. The definitive value for each operation timer may be network specific and has to be defined by the network operator.

Table 3

6.2 IN CS1 error types

Core-INAP-CS1-Errors { ccitt(0) identified-organization(4) etsi(0) inDomain(1) in-network(1) modules(0) cs1-errors(1) version1(0)}

--  This module contains the type definitions for the IN CS1 errors.

DEFINITIONS IMPLICIT TAGS ::=

BEGIN

IMPORTS
	ERROR
FROM TCAPMessages {ccitt recommendation q 773 modules(2) messages(1) version2(2)}

	InvokeID,
	UnavailableNetworkResource

FROM Core-INAP-CS1-DataTypes {ccitt(0) identified-organization(4) etsi(0) inDomain(1) in-network(1) modules(0) cs1-datatypes(2) version1(0)};

--  TYPE DEFINITION FOR IN CS1 ERRORS FOLLOWS

Canceled 				::= ERROR

--  The operation has been canceled.

CancelFailed 				::= ERROR
	PARAMETER SEQUENCE {
		problem	[0] ENUMERATED {
					unknownOperation(0),
					tooLate(1),
					operationNotCancellable(2)
					},
		operation	[1] InvokeID
	}
--  The operation failed to be canceled.

ETCFailed 				::= ERROR

--  The establish temporary connection failed.
 
ImproperCallerResponse 		::= ERROR

--  The caller response was not as expected.

MissingCustomerRecord 		::= ERROR

--  The Service Logic Program (SLP) could not be found in the SCF.

MissingParameter 			::= ERROR

--  An expected optional parameter was not received.

ParameterOutOfRange 			::= ERROR

--  The parameter was not as expected (e.g., missing or out of range).

RequestedInfoError 			::= ERROR
	PARAMETER	ENUMERATED {
	unknownRequestedInfo(1),
	requestedInfoNotAvailable(2)
	}

--  The requested information cannot be found.

SystemFailure 				::= ERROR
	PARAMETER
		UnavailableNetworkResource

--  The operation could not be completed due to a system failure at the serving PE.

TaskRefused 				::= ERROR
	PARAMETER	ENUMERATED {
		generic(0),
		unobtainable (1),
		congestion(2)
		}

--  An entity normally capable of the task requested cannot or chooses not to perform the task at 
--  this time (this includes error situations like congestion and unobtainable address as used in 
--  e.g., the connect operation).

UnavailableResource 			::= ERROR

--  A requested resource is not available at the serving entity.

UnexpectedComponentSequence 	::= ERROR

--  An incorrect sequence of Components was received (e.g., "DisconnectForwardConnection"
--  followed by "PlayAnnouncement").

UnexpectedDataValue 			::= ERROR

--  The data value was not as expected (e.g., routing number expected but billing number
--  received)

UnexpectedParameter 			::= ERROR

--  A parameter received was not expected.

UnknownLegID 				::= ERROR

--  Leg not known to the SSF.

END

Contents Page
Next Section