-- Module IN-SSF-SCF-ops-args (Q.1248.2:07/2001)
-- See also ITU-T Q.1248.2 (07/2001)
-- See also the index of all ASN.1 assignments needed in this document
IN-SSF-SCF-ops-args {itu-t recommendation q 1248 modules(1)
in-ssf-scf-ops-args(8) version1(0)} DEFINITIONS IMPLICIT TAGS ::=
BEGIN
IMPORTS
common-classes, common-datatypes, errortypes, scf-srf-classes,
scf-srf-datatypes, ssf-scf-classes, ssf-scf-datatypes, operationcodes,
ros-InformationObjects
FROM IN-object-identifiers {itu-t recommendation q 1248 modules(1)
in-object-identifiers(0) version1(0)}
OPERATION
FROM Remote-Operations-Information-Objects ros-InformationObjects
COMMON-BOUNDS
FROM IN-common-classes common-classes
SCF-SSF-BOUNDS
FROM IN-SSF-SCF-Classes ssf-scf-classes
SCF-SRF-BOUNDS
FROM IN-SCF-SRF-Classes scf-srf-classes
opcode-activateServiceFiltering, opcode-activityTest,
opcode-analysedInformation, opcode-analyseInformation,
opcode-applyCharging, opcode-applyChargingReport,
opcode-assistRequestInstructions, opcode-authorizeTermination,
opcode-callFiltering, opcode-callGap, opcode-callInformationReport,
opcode-callInformationRequest, opcode-cancel,
opcode-cancelStatusReportRequest, opcode-collectedInformation,
opcode-collectInformation, opcode-connect, opcode-connectToResource,
opcode-continue, opcode-continueWithArgument,
opcode-createCallSegmentAssociation, opcode-createOrRemoveTriggerData,
opcode-disconnectForwardConnection, opcode-dFCWithArgument,
opcode-disconnectLeg, opcode-entityReleased,
opcode-establishTemporaryConnection, opcode-eventNotificationCharging,
opcode-eventReportBCSM, opcode-eventReportFacility,
opcode-facilitySelectedAndAvailable, opcode-furnishChargingInformation,
opcode-holdCallInNetwork, opcode-initialDP, opcode-initiateCallAttempt,
opcode-manageTriggerData, opcode-mergeCallSegments,
opcode-moveCallSegments, opcode-oAbandon, opcode-oAnswer,
opcode-oCalledPartyBusy, opcode-oDisconnect, opcode-oMidCall,
opcode-moveLeg, opcode-oNoAnswer, opcode-originationAttempt,
opcode-originationAttemptAuthorized, opcode-oSuspended, opcode-reconnect,
opcode-releaseCall, opcode-reportUTSI, opcode-requestCurrentStatusReport,
opcode-requestEveryStatusChangeReport,
opcode-requestFirstStatusMatchReport,
opcode-requestNotificationChargingEvent, opcode-requestReportBCSMEvent,
opcode-requestReportUTSI, opcode-requestReportFacilityEvent,
opcode-resetTimer, opcode-monitorRouteReport, opcode-monitorRouteRequest,
opcode-routeSelectFailure, opcode-selectFacility, opcode-selectRoute,
opcode-sendChargingInformation, opcode-sendFacilityInformation,
opcode-sendSTUI, opcode-serviceFilteringResponse, opcode-setServiceProfile,
opcode-splitLeg, opcode-statusReport, opcode-tAnswer, opcode-tBusy,
opcode-tDisconnect, opcode-termAttemptAuthorized,
opcode-terminationAttempt, opcode-tMidCall, opcode-tNoAnswer,
opcode-tSuspended
FROM IN-operationcodes operationcodes
Extensions{}, Integer4, InvokeID
FROM IN-common-datatypes common-datatypes
AccessCode{}, ActionIndicator, ActionPerformed,
AChBillingChargingCharacteristics{}, AdditionalCallingPartyNumber{},
AlertingPattern, ApplicationTimer, AssistingSSPIPRoutingAddress{},
BackwardGVNS{}, BCSMEvent{}, BearerCapability{}, BISDNParameters{},
CalledDirectoryNumber{}, CalledPartyBusinessGroupID, CalledPartyNumber{},
CalledPartySubaddress{}, CallingGeodeticLocation{},
CallingPartyBusinessGroupID, CallingPartyNumber{}, CallingPartysCategory,
CallingPartySubaddress{}, CallProcessingOperation, CallReference{},
CallResult{}, CallSegmentID{}, Carrier{}, Cause{}, CCSS, CGEncountered,
ChargeNumber{}, ChargingEvent{}, CNInfo{}, Component,
ComponentCorrelationID, ComponentType, ConnectionIdentifier{}, ControlType,
CorrelationID{}, CountersValue{}, CreateOrRemoveIndicator, CSAID{},
GenericIdentifier{}, GlobalCallReference{}, CUG-Index, CUG-Interlock,
CutAndPaste, DateAndTime, DefaultFaultHandling{}, DestinationIndex{},
DestinationRoutingAddress{}, Digits{}, DisplayInformation{},
DpSpecificCommonParameters{}, Duration, EventSpecificInformationBCSM{},
EventSpecificInformationCharging{}, EventTypeBCSM, EventTypeCharging{},
FacilityGroup, FacilityGroupMember, FCIBillingChargingCharacteristics{},
FeatureCode{}, FeatureRequestIndicator, FilteredCallTreatment{},
FilteringCharacteristics, FilteringCriteria{}, FilteringTimeOut,
ForwardCallIndicators, ForwardGVNS{}, ForwardingCondition, GapCriteria{},
GapIndicators, GapTreatment{}, GenericName{}, GenericNumbers{},
HighLayerCompatibility{}, HoldCause, initialCallSegment, INprofile{},
INServiceCompatibilityIndication{}, INServiceCompatibilityResponse,
IPAvailable{}, IPRelatedInformation{}, IPRoutingAddress{},
IPSSPCapabilities{}, ISDNAccessRelatedInformation{}, LegID, leg1,
LocationNumber{}, MiscCallInfo, MonitorMode, MonitoringCriteria,
MonitoringTimeOut, NumberingPlan, OriginalCalledPartyID{},
ProfileIdentifier{}, QoSParameter{}, Reason{}, RedirectingPartyID{},
RedirectionInformation, RegistratorIdentifier, ReportCondition,
RouteingNumber{}, RequestedInformationList{},
RequestedInformationTypeList{}, RequestedUTSIList{}, ResourceID{},
ResourceStatus, ResponseCondition, RouteCountersValue{}, RouteList{},
ScfID{}, SCIBillingChargingCharacteristics{}, SDSSinformation{},
ServiceInteractionIndicators{}, ServiceInteractionIndicatorsTwo,
ServiceKey, ServiceProfileIdentifier, TDPIdentifier, TerminalType,
TimerID, TimerValue, TravellingClassMark{}, TriggerData,
TriggerDataIdentifier{}, TriggerDPType, Triggers{}, TriggerStatus,
TriggerResults{}, TriggerType, USIInformation{}, USIServiceIndicator{},
VPNIndicator
FROM IN-SSF-SCF-datatypes ssf-scf-datatypes
InformationToSend{}
FROM IN-SCF-SRF-datatypes scf-srf-datatypes
cancelFailed, eTCFailed, improperCallerResponse, missingCustomerRecord,
missingParameter, parameterOutOfRange, requestedInfoError, systemFailure,
taskRefused, unavailableResource, unexpectedComponentSequence,
unexpectedDataValue, unexpectedParameter, unknownLegID, unknownResource
FROM IN-errortypes errortypes;
-- The following three definitions are local short-hand notation for convenience.
B1 ::=
COMMON-BOUNDS -- defined in Part 1 of Recommendation Q.1248
B2 ::= SCF-SSF-BOUNDS -- defined in this part (Part 2) of Recommendation Q.1248
B3 ::= SCF-SRF-BOUNDS -- defined in Part 3 of Recommendation Q.1248
-- Operations and Arguments:
activateServiceFiltering{B1:b1, B2:b2, B3:b3} OPERATION ::= {
ARGUMENT ActivateServiceFilteringArg {b1,
b2,
b3}
RETURN RESULT TRUE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedParameter}
CODE opcode-activateServiceFiltering
}
-- 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.
ActivateServiceFilteringArg{B1:b1, B2:b2, B3:b3} ::= SEQUENCE {
filteredCallTreatment [0] FilteredCallTreatment{b2, b3},
filteringCharacteristics [1] FilteringCharacteristics,
filteringTimeOut [2] FilteringTimeOut,
filteringCriteria [3] FilteringCriteria{b2},
startTime [4] DateAndTime OPTIONAL,
extensions [5] Extensions{b1} OPTIONAL,
...
}
activityTest OPERATION ::= {
RETURN RESULT TRUE
ALWAYS RESPONDS FALSE
CODE opcode-activityTest
}
-- Direction: SCF -> SSF or SSF-> SCF, 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.. As an option, this operation may be used in the reverse direction by the
-- SSF to check for the continued existence of a relationship with the SCF.
analysedInformation{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT AnalysedInformationArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-analysedInformation
}
-- Direction: SSF -> SCF, Timer: Tadi
-- This operation is used to indicate availability of routing address and call type. (DP -
-- Analysed_Info).
AnalysedInformationArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
dialledDigits [1] CalledPartyNumber{b2} OPTIONAL,
callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [4] FacilityGroup OPTIONAL,
callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL,
originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL,
prefix [7] Digits{b2} OPTIONAL,
redirectingPartyID [8] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [9] RedirectionInformation OPTIONAL,
routeList [10] RouteList{b2} OPTIONAL,
travellingClassMark [11] TravellingClassMark{b2} OPTIONAL,
extensions [12] Extensions{b1} OPTIONAL,
featureCode [13] FeatureCode{b2} OPTIONAL,
accessCode [14] AccessCode{b2} OPTIONAL,
carrier [15] Carrier{b2} OPTIONAL,
componentType [16] ComponentType OPTIONAL,
component [17] Component OPTIONAL,
componentCorrelationID [18] ComponentCorrelationID OPTIONAL,
...
}
analyseInformation{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT AnalyseInformationArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-analyseInformation
}
-- Direction: SCF -> SSF, Timer: Tai
-- This operation is used to request the SSF to perform the originating basic call processing actions
-- to analyse destination information that is either collected from a calling party or provided by the SCF
-- (e.g. for number translation). This includes actions to validate the information according to an office
-- or customized dialing plan, and if valid, to determine call termination information, to include the called
-- party address, the type of call (e.g. intra-network or inter-network), and carrier (if inter-network).
-- If the called party is not served by the SSF, the SSF also determines a route index based on the called
-- party address and class of service, where the route index points to a list of outgoing trunk groups.
AnalyseInformationArg{B1:b1, B2:b2} ::= SEQUENCE {
destinationRoutingAddress [0] DestinationRoutingAddress{b2},
alertingPattern [1] AlertingPattern OPTIONAL,
iSDNAccessRelatedInformation
[2] ISDNAccessRelatedInformation{b2} OPTIONAL,
originalCalledPartyID [3] OriginalCalledPartyID{b2} OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
callingPartyNumber [5] CallingPartyNumber{b2} OPTIONAL,
callingPartysCategory [6] CallingPartysCategory OPTIONAL,
calledPartyNumber [7] CalledPartyNumber{b2} OPTIONAL,
chargeNumber [8] ChargeNumber{b2} OPTIONAL,
travellingClassMark [9] TravellingClassMark{b2} OPTIONAL,
carrier [10] Carrier{b2} OPTIONAL,
serviceInteractionIndicators
[11] ServiceInteractionIndicators{b2} OPTIONAL,
iNServiceCompatibilityResponse
[12] INServiceCompatibilityResponse OPTIONAL,
forwardGVNS [13] ForwardGVNS{b2} OPTIONAL,
backwardGVNS [14] BackwardGVNS{b2} OPTIONAL,
serviceInteractionIndicatorsTwo
[15] ServiceInteractionIndicatorsTwo OPTIONAL,
correlationID [16] CorrelationID{b2} OPTIONAL,
scfID [17] ScfID{b2} OPTIONAL,
callSegmentID [18] CallSegmentID{b2} OPTIONAL,
legToBeCreated [19] LegID OPTIONAL,
...
}
-- OPTIONAL parameters are only provided if modifications desired to basic call processing values
applyCharging{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ApplyChargingArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | unexpectedComponentSequence | unexpectedParameter |
unexpectedDataValue | parameterOutOfRange | systemFailure | taskRefused |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-applyCharging
}
-- 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.
-- This operation is can also be used to instruct the SSF to release the call regarding some condition.
ApplyChargingArg{B1:b1, B2:b2} ::= SEQUENCE {
aChBillingChargingCharacteristics [0] AChBillingChargingCharacteristics{b2},
partyToCharge [2] LegID OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
releaseIndication [4] BOOLEAN OPTIONAL,
releaseCause [5] Cause{b2} OPTIONAL,
...
}
-- The TAG value 1 should not be used for future extensions (used in CS-1 by regions).
-- The partyToCharge parameter indicates the party in the call to which the ApplyCharging operation
-- should be applied. If it is not present, then it is applied to the A-party
-- The releaseIndicator shall be present and set to TRUE if the release condition is specified in the
-- aCHBillingCharacteristics parameter.
applyChargingReport{B2:b2} OPERATION ::= {
ARGUMENT ApplyChargingReportArg {b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | unexpectedComponentSequence | unexpectedParameter |
unexpectedDataValue | parameterOutOfRange | systemFailure | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-applyChargingReport
}
-- 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.
ApplyChargingReportArg{B2:b2} ::=
CallResult{b2}
-- Note: When the SSF sends the ApplyChargingReport operation as the last event from the Call Segment, the
-- lastEventIndicator parameter is to indicate whether the event is last to the SCF and should be included
-- into the CallResult parameter.
assistRequestInstructions{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT AssistRequestInstructionsArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-assistRequestInstructions
}
-- 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 assisting SSF to 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/SelectRoute operation (in the case of hand-off) from the SCF.
AssistRequestInstructionsArg{B1:b1, B2:b2} ::= SEQUENCE {
correlationID [0] CorrelationID{b2},
iPAvailable [1] IPAvailable{b2} OPTIONAL,
iPSSPCapabilities [2] IPSSPCapabilities{b2} OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
...
}
-- OPTIONAL denotes network operator specific use. The value of the correlationID may be the
-- Called Party Number supplied by the initiating SSF.
authorizeTermination{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT AuthorizeTerminationArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-authorizeTermination
}
-- Direction: SCF -> SSF. Timer: Tatr
-- This operation is used to request the SSF to resume terminating call processing action at the
-- Authorize_Termination PIC of the call based on the information received from the SCF.
AuthorizeTerminationArg{B1:b1, B2:b2} ::= SEQUENCE {
alertingPattern [0] AlertingPattern OPTIONAL,
callingPartyNumber [1] CallingPartyNumber{b2} OPTIONAL,
destinationNumberRoutingAddress [2] CalledPartyNumber{b2} OPTIONAL,
displayInformation [3] DisplayInformation{b2} OPTIONAL,
iSDNAccessRelatedInformation
[4] ISDNAccessRelatedInformation{b2} OPTIONAL,
originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL,
travellingClassMark [6] TravellingClassMark{b2} OPTIONAL,
extensions [7] Extensions{b1} OPTIONAL,
iNServiceCompatibilityResponse [8] INServiceCompatibilityResponse OPTIONAL,
forwardGVNS [9] ForwardGVNS{b2} OPTIONAL,
backwardGVNS [10] BackwardGVNS{b2} OPTIONAL,
legID [11] LegID OPTIONAL,
serviceInteractionIndicatorsTwo
[12] ServiceInteractionIndicatorsTwo OPTIONAL,
scfID [13] ScfID{b2} OPTIONAL,
...
}
-- OPTIONAL parameters are only provided if modifications are desired to basic call processing values.
callFiltering{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT CallFilteringArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-callFiltering
}
-- Direction: SCF -> SSF, Timer: Tcf
-- This operation is used to allow the SCF to influence basic call gapping procedures based in the CCF by sending information from the SCF to the SSF. The SSF relays the received information transparently to the CCF. This way, the SCF can influence the rate at which call attempts are allowed through. The operation thus influences the filtering of calls, as opposed to service requests as is done by the Callgap operation.
CallFilteringArg{B1:b1, B2:b2} ::= SEQUENCE {
destinationIndex [0] DestinationIndex{b2},
gapIndicators [1] GapIndicators,
registratorIdentifier [2] RegistratorIdentifier OPTIONAL,
...,
...,
extensions [3] Extensions{b1} OPTIONAL
}
-- OPTIONAL denotes network operator optional.
callGap{B1:b1, B2:b2, B3:b3} OPERATION ::= {
ARGUMENT CallGapArg {b1,
b2,
b3}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-callGap
}
-- 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. Use of this operation by the SCF to gap queries and updates at the SDF is outside the scope of this capability set .
CallGapArg{B1:b1, B2:b2, B3:b3} ::= SEQUENCE {
gapCriteria [0] GapCriteria{b2},
gapIndicators [1] GapIndicators,
controlType [2] ControlType OPTIONAL,
gapTreatment [3] GapTreatment{b2, b3} OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
...
}
-- OPTIONAL denotes network operator optional. If gapTreatment is not present, the SSF will use
-- a default treatment depending on network operator implementation.
callInformationReport{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT CallInformationReportArg {b1,
b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-callInformationReport
}
-- 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.
CallInformationReportArg{B1:b1, B2:b2} ::= SEQUENCE {
requestedInformationList [0] RequestedInformationList{b2},
correlationID [1] CorrelationID{b2} OPTIONAL,
extensions [2] Extensions{b1} OPTIONAL,
legID [3] LegID OPTIONAL,
lastEventIndicator [4] BOOLEAN DEFAULT FALSE,
...
}
-- OPTIONAL denotes network operator optional.
-- The lastEventIndicator parameter is set with 'TRUE' when the report is last in the Call Segment.
-- In the CS-1, the lastEventIndicator should not be sent, and the meaning of DEFAULT is not applied. The SCF
-- must decide whether the report is last without this parameter.
callInformationRequest{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT CallInformationRequestArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | requestedInfoError |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter | unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-callInformationRequest
}
-- 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).
CallInformationRequestArg{B1:b1, B2:b2} ::= SEQUENCE {
requestedInformationTypeList [0] RequestedInformationTypeList{b2},
correlationID [1] CorrelationID{b2} OPTIONAL,
extensions [2] Extensions{b1} OPTIONAL,
legID [3] LegID OPTIONAL,
...
}
-- OPTIONAL denotes network operator optional .
cancel{B2:b2} OPERATION ::= {
ARGUMENT CancelArg {b2}
RETURN RESULT FALSE
ERRORS {cancelFailed | missingParameter | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-cancel
}
-- Direction: SCF -> SSF, or SCF -> SRF, Timer: Tcan
-- This operation cancels the correlated previous operation or all previous requests
-- This operation can also be used to cancel all outstanding requests and enable the state machine (SSF)
-- to go to idle. In this case the Cancel operation does not specify any specific operation to be cancelled.
-- For the SCF-SRF operations that can be cancelled, refer to Part 3 of Q.1248
CancelArg{B2:b2} ::= CHOICE {
invokeID [0] InvokeID,
allRequests [1] NULL,
callSegmentToCancel
[2] SEQUENCE {invokeID [0] InvokeID,
callSegmentID [1] CallSegmentID{b2},
...},
allRequestsForCallSegment [3] CallSegmentID{b2},
...
}
-- The InvokeID has the same value as that which was used for the SCF-SRF operation, i.e. is used to identify
-- the correlated previous SCF-SRF operation to be canccelled.
cancelStatusReportRequest{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT CancelStatusReportRequestArg {b1,
b2}
RETURN RESULT FALSE
ERRORS {cancelFailed | missingParameter | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-cancelStatusReportRequest
}
-- Direction: SCF -> SSF, Timer: Tcsr
-- This operation cancels the following processes: RequestFirstStatusMatchReport and
-- RequestEveryStatusChangeReport.
CancelStatusReportRequestArg{B1:b1, B2:b2} ::= SEQUENCE {
resourceID [0] ResourceID{b2} OPTIONAL,
extensions [1] Extensions{b1} OPTIONAL,
...
}
collectedInformation{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT CollectedInformationArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-collectedInformation
}
-- Direction: SSF -> SCF, Timer: Tcdi
-- This operation is used to indicate availability of complete initial information package/dialing string from
-- originating party. (This event may have already occurred in the case of en bloc signaling, in which case
-- the waiting duration in this PIC is zero.) (DP - Collected_Info
CollectedInformationArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
dialledDigits [1] CalledPartyNumber{b2} OPTIONAL,
callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [4] FacilityGroup OPTIONAL,
callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL,
originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL,
prefix [7] Digits{b2} OPTIONAL,
redirectingPartyID [8] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [9] RedirectionInformation OPTIONAL,
travellingClassMark [10] TravellingClassMark{b2} OPTIONAL,
extensions [11] Extensions{b1} OPTIONAL,
featureCode [12] FeatureCode{b2} OPTIONAL,
accessCode [13] AccessCode{b2} OPTIONAL,
carrier [14] Carrier{b2} OPTIONAL,
componentType [15] ComponentType OPTIONAL,
component [16] Component OPTIONAL,
componentCorrelationID [17] ComponentCorrelationID OPTIONAL,
...
}
collectInformation{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT CollectInformationArg {b1,
b2}
OPTIONAL TRUE
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-collectInformation
}
-- 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).
CollectInformationArg{B1:b1, B2:b2} ::= SEQUENCE {
alertingPattern [0] AlertingPattern OPTIONAL,
numberingPlan [1] NumberingPlan OPTIONAL,
originalCalledPartyID [2] OriginalCalledPartyID{b2} OPTIONAL,
travellingClassMark [3] TravellingClassMark{b2} OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
callingPartyNumber [5] CallingPartyNumber{b2} OPTIONAL,
dialledDigits [6] CalledPartyNumber{b2} OPTIONAL,
serviceInteractionIndicators
[7] ServiceInteractionIndicators{b2} OPTIONAL,
iNServiceCompatibilityResponse [8] INServiceCompatibilityResponse OPTIONAL,
forwardGVNS [9] ForwardGVNS{b2} OPTIONAL,
backwardGVNS [10] BackwardGVNS{b2} OPTIONAL,
serviceInteractionIndicatorsTwo
[11] ServiceInteractionIndicatorsTwo OPTIONAL,
callSegmentID [12] CallSegmentID{b2} OPTIONAL,
legToBeCreated [13] LegID OPTIONAL,
...
}
connect{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ConnectArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-connect
}
-- 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.
-- When address information is only included in the Connect operation, call processing resumes at PIC3 in
-- the O-BCSM.
-- When address information and routing information is included, call processing resumes at PIC4.
ConnectArg{B1:b1, B2:b2} ::= SEQUENCE {
destinationRoutingAddress [0] DestinationRoutingAddress{b2},
alertingPattern [1] AlertingPattern OPTIONAL,
correlationID [2] CorrelationID{b2} OPTIONAL,
cutAndPaste [3] CutAndPaste OPTIONAL,
forwardingCondition [4] ForwardingCondition OPTIONAL,
iSDNAccessRelatedInformation
[5] ISDNAccessRelatedInformation{b2} OPTIONAL,
originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL,
routeList [7] RouteList{b2} OPTIONAL,
-- maximum number of routes is limited to 3
scfID [8] ScfID{b2} OPTIONAL,
travellingClassMark [9] TravellingClassMark{b2} OPTIONAL,
extensions [10] Extensions{b1} OPTIONAL,
carrier [11] Carrier{b2} OPTIONAL,
serviceInteractionIndicators
[26] ServiceInteractionIndicators{b2} OPTIONAL,
callingPartyNumber [27] CallingPartyNumber{b2} OPTIONAL,
callingPartysCategory [28] CallingPartysCategory OPTIONAL,
redirectingPartyID [29] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [30] RedirectionInformation OPTIONAL,
displayInformation [12] DisplayInformation{b2} OPTIONAL,
forwardCallIndicators [13] ForwardCallIndicators OPTIONAL,
genericNumbers [14] GenericNumbers{b2} OPTIONAL,
serviceInteractionIndicatorsTwo
[15] ServiceInteractionIndicatorsTwo OPTIONAL,
iNServiceCompatibilityResponse
[16] INServiceCompatibilityResponse OPTIONAL,
forwardGVNS [17] ForwardGVNS{b2} OPTIONAL,
backwardGVNS [18] BackwardGVNS{b2} OPTIONAL,
chargeNumber [19] ChargeNumber{b2} OPTIONAL,
callSegmentID [20] CallSegmentID{b2} OPTIONAL,
legToBeCreated [21] LegID OPTIONAL,
sDSSinformation [22] SDSSinformation{b2} OPTIONAL,
calledDirectoryNumber [23] CalledDirectoryNumber{b2} OPTIONAL,
bearerCapability [24] BearerCapability{b2} OPTIONAL,
calledPartySubaddress [60] CalledPartySubaddress{b2} OPTIONAL,
connectionIdentifier [61] ConnectionIdentifier{b2} OPTIONAL,
genericIdentifier [62] GenericIdentifier{b2} OPTIONAL,
qOSParameter [63] QoSParameter{b2} OPTIONAL,
bISDNParameters [64] BISDNParameters{b2} OPTIONAL,
...,
cug-Interlock [31] CUG-Interlock OPTIONAL,
cug-OutgoingAccess [32] NULL OPTIONAL,
ipRelatedInformation [33] IPRelatedInformation{b2} OPTIONAL
}
-- OPTIONAL parameters are only provided if modifications desired to basic call processing values
connectToResource{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ConnectToResourceArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-connectToResource
}
-- Direction: SCF -> SSF, Timer: Tctr
-- This operation is used to connect a call from the SSP to the physical entity containing the SRF.
ConnectToResourceArg{B1:b1, B2:b2} ::= SEQUENCE {
resourceAddress
CHOICE {ipRoutingAddress [0] IPRoutingAddress{b2},
legID [1] LegID,
ipAddressAndLegID
[2] SEQUENCE {ipRoutingAddress [0] IPRoutingAddress{b2},
legID [1] LegID,
...},
none [3] NULL,
callSegmentID [5] CallSegmentID{b2},
ipAddressAndCallSegment
[6] SEQUENCE {ipRoutingAddress [0] IPRoutingAddress{b2},
callSegmentID [1] CallSegmentID{b2},
...}},
extensions [4] Extensions{b1} OPTIONAL,
serviceInteractionIndicators
[30] ServiceInteractionIndicators{b2} OPTIONAL,
serviceInteractionIndicatorsTwo
[7] ServiceInteractionIndicatorsTwo OPTIONAL,
uSIServiceIndicator [35] USIServiceIndicator{b2} OPTIONAL,
uSIInformation [36] USIInformation{b2} OPTIONAL,
...
}
continue OPERATION ::= {
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-continue
}
-- 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.
-- This operation is not valid for a single call segment CSA with more than 2 legs or a multi call segment CSA.
continueWithArgument{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ContinueWithArgumentArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | unexpectedComponentSequence | unexpectedParameter |
unexpectedDataValue | unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-continueWithArgument
}
-- Direction: SCF -> SSF, Timer: Tcwa
-- This operation is used to request the SSF to proceed with call processing at the DP a which it previously
-- suspended call processing to await SCF instructions.
-- It is also used to provide additional service related information to a User (Called Party or Calling Party) whilst
-- the call processing proceeds.
ContinueWithArgumentArg{B1:b1, B2:b2} ::= SEQUENCE {
legorCSID
CHOICE {legID [0] LegID,
csID [9] CallSegmentID{b2}} DEFAULT legID:sendingSideID:leg1,
alertingPattern [1] AlertingPattern OPTIONAL,
genericName [2] GenericName{b2} OPTIONAL,
iNServiceCompatibilityResponse [3] INServiceCompatibilityResponse OPTIONAL,
forwardGVNS [4] ForwardGVNS{b2} OPTIONAL,
backwardGVNS [5] BackwardGVNS{b2} OPTIONAL,
extensions [6] Extensions{b1} OPTIONAL,
serviceInteractionIndicatorsTwo
[7] ServiceInteractionIndicatorsTwo OPTIONAL,
sDSSinformation [8] SDSSinformation{b2} OPTIONAL,
connectionIdentifier [60] ConnectionIdentifier{b2} OPTIONAL,
...,
iSDNAccessRelatedInformation
[19] ISDNAccessRelatedInformation{b2} OPTIONAL,
originalCalledPartyID [10] OriginalCalledPartyID{b2} OPTIONAL,
callingPartyNumber [11] CallingPartyNumber{b2} OPTIONAL,
callingPartysCategory [12] CallingPartysCategory OPTIONAL,
redirectingPartyID [13] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [14] RedirectionInformation OPTIONAL,
forwardCallIndicators [15] ForwardCallIndicators OPTIONAL,
genericNumbers [16] GenericNumbers{b2} OPTIONAL,
cug-Interlock [17] CUG-Interlock OPTIONAL,
cug-OutgoingAccess [18] NULL OPTIONAL,
ipRelationInformation [20] IPRelatedInformation{b2} OPTIONAL
}
-- OPTIONAL parameters are only provided if modifications desired to basic call processing values
createCallSegmentAssociation{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT CreateCallSegmentAssociationArg {b1}
OPTIONAL TRUE
RESULT CreateCallSegmentAssociationResultArg {b1,
b2}
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
CODE opcode-createCallSegmentAssociation
}
-- Direction SCF -> SSF, Timer Tcsa
-- This operation is used to create a new CSA. The new CSA will not contain any Call Segments after creation.
-- The SSF is responsible for specifying a new CSA identifier for the created CSA which is unique within
-- the SSF.
CreateCallSegmentAssociationArg{B1:b1} ::= SEQUENCE {
extensions [0] Extensions{b1} OPTIONAL,
...
}
CreateCallSegmentAssociationResultArg{B1:b1, B2:b2} ::= SEQUENCE {
newCallSegmentAssociation [0] CSAID{b2},
extensions [1] Extensions{b1} OPTIONAL,
...
}
createOrRemoveTriggerData{B1:b1, B2:b2, B3:b3} OPERATION ::= {
ARGUMENT CreateOrRemoveTriggerDataArg {b1,
b2,
b3}
RESULT CreateOrRemoveTriggerDataResultArg {b1,
b2}
ERRORS
{missingParameter | missingCustomerRecord | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
CODE opcode-createOrRemoveTriggerData
}
-- Direction: SCF -> SSF, Class 1, Timer: Tcrt
-- This trigger management operation is used by the SCF outside the context of a call to create a new
-- trigger detection point in the CCF/SSF by downloading trigger data
-- (e.g. triggering criteria, ServiceKey, SCF address,....)
-- or to remove an existing trigger.
CreateOrRemoveTriggerDataArg{B1:b1, B2:b2, B3:b3} ::= SEQUENCE {
createOrRemove [0] CreateOrRemoveIndicator DEFAULT create,
dPName [1] EventTypeBCSM OPTIONAL,
triggerDPType [2] TriggerDPType DEFAULT tdp-r,
serviceKey [3] ServiceKey OPTIONAL,
profile [4] ProfileIdentifier{b2} OPTIONAL,
triggerData [5] TriggerData OPTIONAL,
defaultFaultHandling [6] DefaultFaultHandling{b2, b3} OPTIONAL,
tDPIdentifier [7] TDPIdentifier{b2} OPTIONAL,
...,
...,
extensions [30] Extensions{b1} OPTIONAL
}
CreateOrRemoveTriggerDataResultArg{B1:b1, B2:b2} ::= SEQUENCE {
triggerStatus [0] TriggerStatus,
tDPIdentifier [1] TDPIdentifier{b2},
registratorIdentifier [2] RegistratorIdentifier OPTIONAL,
...,
...,
extensions [30] Extensions{b1} OPTIONAL
}
disconnectForwardConnection OPERATION ::= {
RETURN RESULT FALSE
ERRORS {systemFailure | taskRefused | unexpectedComponentSequence}
ALWAYS RESPONDS FALSE
CODE opcode-disconnectForwardConnection
}
-- Direction: SCF -> SSF, Timer: Tdfc
-- This operation is used to disconnect a forward temporary connection or a connection to a resource.
disconnectForwardConnectionWithArgument{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT DisconnectForwardConnectionWithArgumentArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-dFCWithArgument
}
-- Direction: SCF -> SSF, Timer: Tdfcwa
-- This operation is used to disconnect a forward temporary connection or a connection to a resource.
DisconnectForwardConnectionWithArgumentArg{B1:b1, B2:b2} ::= SEQUENCE {
partyToDisconnect
CHOICE {legID [0] LegID,
callSegmentID [1] CallSegmentID{b2}},
extensions [2] Extensions{b1} OPTIONAL,
uSIServiceIndicator [3] USIServiceIndicator{b2} OPTIONAL,
uSIInformation [4] USIInformation{b2} OPTIONAL,
...
}
disconnectLeg{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT DisconnectLegArg {b1,
b2}
RETURN RESULT TRUE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
CODE opcode-disconnectLeg
}
-- Direction: SCF -> SSF. Timer: T dl
-- This operation is issued by the SCF to release a specific leg associated with the call and retain any
-- other legs not specified in the DisconnectLeg. Any leg may be disconnected, including the controlling
-- leg, without completely releasing all legs.
DisconnectLegArg{B1:b1, B2:b2} ::= SEQUENCE {
legToBeReleased [0] LegID,
releaseCause [1] Cause{b2} OPTIONAL,
extensions [2] Extensions{b1} OPTIONAL,
...
}
entityReleased{B2:b2} OPERATION ::= {
ARGUMENT EntityReleasedArg {b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-entityReleased
}
-- Direction SSF -> SCF, Timer: Ter
-- This operation is used by SSF to inform the SCF of an error/exception
EntityReleasedArg{B2:b2} ::= CHOICE {
cSFailure
[0] SEQUENCE {callSegmentID [0] CallSegmentID{b2},
reason [1] Reason{b2} OPTIONAL,
cause [2] Cause{b2} OPTIONAL,
...},
bCSMFailure
[1] SEQUENCE {legID [0] LegID,
reason [1] Reason{b2} OPTIONAL,
cause [2] Cause{b2} OPTIONAL,
...}
}
establishTemporaryConnection{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT EstablishTemporaryConnectionArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{eTCFailed | missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-establishTemporaryConnection
}
-- 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.
EstablishTemporaryConnectionArg{B1:b1, B2:b2} ::= SEQUENCE {
assistingSSPIPRoutingAddress [0] AssistingSSPIPRoutingAddress{b2},
correlationID [1] CorrelationID{b2} OPTIONAL,
partyToConnect
CHOICE {legID [2] LegID,
callSegmentID [7] CallSegmentID{b2}} OPTIONAL,
scfID [3] ScfID{b2} OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
carrier [5] Carrier{b2} OPTIONAL,
serviceInteractionIndicators
[30] ServiceInteractionIndicators{b2} OPTIONAL,
serviceInteractionIndicatorsTwo
[6] ServiceInteractionIndicatorsTwo OPTIONAL,
...
}
-- OPTIONAL parameters are only provided if modifications desired to basic call processing values
eventNotificationCharging{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT EventNotificationChargingArg {b1,
b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-eventNotificationCharging
}
-- 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.
EventNotificationChargingArg{B1:b1, B2:b2} ::= SEQUENCE {
eventTypeCharging [0] EventTypeCharging{b2},
eventSpecificInformationCharging
[1] EventSpecificInformationCharging{b2} OPTIONAL,
legID [2] LegID OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
monitorMode [30] MonitorMode DEFAULT notifyAndContinue,
...
}
-- OPTIONAL denotes network operator specific use.
eventReportBCSM{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT EventReportBCSMArg {b1,
b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-eventReportBCSM
}
-- 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.
EventReportBCSMArg{B1:b1, B2:b2} ::= SEQUENCE {
eventTypeBCSM [0] EventTypeBCSM,
bcsmEventCorrelationID [1] CorrelationID{b2} OPTIONAL,
eventSpecificInformationBCSM [2] EventSpecificInformationBCSM{b2} OPTIONAL,
legID [3] LegID OPTIONAL,
miscCallInfo [4] MiscCallInfo DEFAULT {messageType request},
extensions [5] Extensions{b1} OPTIONAL,
componentType [6] ComponentType OPTIONAL,
component [7] Component OPTIONAL,
componentCorrelationID [8] ComponentCorrelationID OPTIONAL,
...
}
eventReportFacility{B1:b1} OPERATION ::= {
ARGUMENT EventReportFacilityArg {b1}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-eventReportFacility
}
-- SSF->SCF, Timer: Terf
-- This operation is issued by the SSF to report the SCF the event, that was previously requested by the
-- SCF, the CCF/SSF receives a DSS1 message which contains a FACILITY IE. Criteria for the report, like
-- reception of the ReturnResult which is specified with ComponentType, is optionally checked
-- before issuing this operation.
EventReportFacilityArg{B1:b1} ::= SEQUENCE {
componentType [0] ComponentType OPTIONAL,
component [1] Component OPTIONAL,
legID [2] LegID OPTIONAL,
componentCorrelationID [3] ComponentCorrelationID OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
...
}
facilitySelectedAndAvailable{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT FacilitySelectedAndAvailableArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-facilitySelectedAndAvailable
}
-- Direction: SSF -> SCF. Timer: Tfs
-- This operation is used for indication of a call termination attempt from the terminating half BCSM. (DP -
-- Facility_Selected_And_Available).
FacilitySelectedAndAvailableArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL,
calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL,
callingPartyBusinessGroupID [3] CallingPartyBusinessGroupID OPTIONAL,
callingPartyNumber [4] CallingPartyNumber{b2} OPTIONAL,
originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL,
redirectingPartyID [6] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [7] RedirectionInformation OPTIONAL,
routeList [8] RouteList{b2} OPTIONAL,
travellingClassMark [9] TravellingClassMark{b2} OPTIONAL,
extensions [10] Extensions{b1} OPTIONAL,
componentType [11] ComponentType OPTIONAL,
component [12] Component OPTIONAL,
componentCorrelationID [13] ComponentCorrelationID OPTIONAL,
...
}
furnishChargingInformation{B2:b2} OPERATION ::= {
ARGUMENT FurnishChargingInformationArg {b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-furnishChargingInformation
}
-- 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.
FurnishChargingInformationArg{B2:b2} ::=
FCIBillingChargingCharacteristics{b2}
holdCallInNetwork OPERATION ::= {
ARGUMENT HoldCallInNetworkArg
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-holdCallInNetwork
}
-- Direction: SCF -> SSF, Timer: Thcn
-- This operation is used to provide the capability of queueing a call during the setup phase (e.g. to provide
-- a call completion to busy, the call would be queued until the destination becomes free).
HoldCallInNetworkArg ::= CHOICE {
holdcause [0] HoldCause,
empty [1] NULL
}
-- holdcause is optional and denotes network operator specific use.
initialDP{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT InitialDPArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-initialDP
}
-- Direction: SSF -> SCF, Timer: Tidp
-- This operation is used after a TDP to indicate request for service.
InitialDPArg{B1:b1, B2:b2} ::= SEQUENCE {
serviceKey [0] ServiceKey OPTIONAL,
dialledDigits [1] CalledPartyNumber{b2} OPTIONAL,
calledPartyNumber [2] CalledPartyNumber{b2} OPTIONAL,
callingPartyNumber [3] CallingPartyNumber{b2} OPTIONAL,
callingPartyBusinessGroupID [4] CallingPartyBusinessGroupID OPTIONAL,
callingPartysCategory [5] CallingPartysCategory OPTIONAL,
callingPartySubaddress [6] CallingPartySubaddress{b2} OPTIONAL,
cGEncountered [7] CGEncountered OPTIONAL,
iPSSPCapabilities [8] IPSSPCapabilities{b2} OPTIONAL,
iPAvailable [9] IPAvailable{b2} OPTIONAL,
locationNumber [10] LocationNumber{b2} OPTIONAL,
miscCallInfo [11] MiscCallInfo OPTIONAL,
originalCalledPartyID [12] OriginalCalledPartyID{b2} OPTIONAL,
serviceProfileIdentifier [13] ServiceProfileIdentifier OPTIONAL,
terminalType [14] TerminalType OPTIONAL,
extensions [15] Extensions{b1} OPTIONAL,
triggerType [16] TriggerType OPTIONAL,
highLayerCompatibility [23] HighLayerCompatibility{b2} OPTIONAL,
serviceInteractionIndicators
[24] ServiceInteractionIndicators{b2} OPTIONAL,
additionalCallingPartyNumber
[25] AdditionalCallingPartyNumber{b2} OPTIONAL,
forwardCallIndicators [26] ForwardCallIndicators OPTIONAL,
bearerCapability [27] BearerCapability{b2} OPTIONAL,
eventTypeBCSM [28] EventTypeBCSM OPTIONAL,
redirectingPartyID [29] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [30] RedirectionInformation OPTIONAL,
cause [17] Cause{b2} OPTIONAL,
componentType [18] ComponentType OPTIONAL,
component [19] Component OPTIONAL,
componentCorrelationID [20] ComponentCorrelationID OPTIONAL,
iSDNAccessRelatedInformation
[21] ISDNAccessRelatedInformation{b2} OPTIONAL,
iNServiceCompatibilityIndication
[22] INServiceCompatibilityIndication{b2} OPTIONAL,
genericNumbers [31] GenericNumbers{b2} OPTIONAL,
serviceInteractionIndicatorsTwo
[32] ServiceInteractionIndicatorsTwo OPTIONAL,
forwardGVNS [33] ForwardGVNS{b2} OPTIONAL,
createdCallSegmentAssociation [34] CSAID{b2} OPTIONAL,
uSIServiceIndicator [35] USIServiceIndicator{b2} OPTIONAL,
uSIInformation [36] USIInformation{b2} OPTIONAL,
carrier [37] Carrier{b2} OPTIONAL,
cCSS [38] CCSS OPTIONAL,
vPNIndicator [39] VPNIndicator OPTIONAL,
cNInfo [40] CNInfo{b2} OPTIONAL,
callReference [41] CallReference{b2} OPTIONAL,
routeingNumber [42] RouteingNumber{b2} OPTIONAL,
callingGeodeticLocation [43] CallingGeodeticLocation{b2} OPTIONAL,
calledPartySubaddress [60] CalledPartySubaddress{b2} OPTIONAL,
connectionIdentifier [61] ConnectionIdentifier{b2} OPTIONAL,
genericIdentifier [62] GenericIdentifier{b2} OPTIONAL,
qOSParameter [63] QoSParameter{b2} OPTIONAL,
bISDNParameters [64] BISDNParameters{b2} OPTIONAL,
...,
globalCallReference [44] GlobalCallReference{b2} OPTIONAL,
cug-Index [45] CUG-Index OPTIONAL,
cug-Interlock [46] CUG-Interlock OPTIONAL,
cug-OutgoingAccess [47] NULL OPTIONAL,
ipRelatedInformation [48] IPRelatedInformation{b2} OPTIONAL
}
-- OPTIONAL for iPSSPCapabilities, iPAvailable, cGEncountered, and miscCallInfo denotes network
-- operator specific use.
-- OPTIONAL for terminalType indicates that this parameter applies only at originating or terminating
-- local exchanges if the SSF has this information.
initiateCallAttempt{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT InitiateCallAttemptArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-initiateCallAttempt
}
-- 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.
InitiateCallAttemptArg{B1:b1, B2:b2} ::= SEQUENCE {
destinationRoutingAddress [0] DestinationRoutingAddress{b2},
alertingPattern [1] AlertingPattern OPTIONAL,
iSDNAccessRelatedInformation
[2] ISDNAccessRelatedInformation{b2} OPTIONAL,
travellingClassMark [3] TravellingClassMark{b2} OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
serviceInteractionIndicators
[29] ServiceInteractionIndicators{b2} OPTIONAL,
callingPartyNumber [30] CallingPartyNumber{b2} OPTIONAL,
legToBeCreated [5] LegID DEFAULT sendingSideID:leg1,
newCallSegment
[6] CallSegmentID{b2} DEFAULT initialCallSegment,
iNServiceCompatibilityResponse [7] INServiceCompatibilityResponse OPTIONAL,
serviceInteractionIndicatorsTwo
[8] ServiceInteractionIndicatorsTwo OPTIONAL,
carrier [9] Carrier{b2} OPTIONAL,
correlationID [10] CorrelationID{b2} OPTIONAL,
scfID [11] ScfID{b2} OPTIONAL,
callReference [12] CallReference{b2} OPTIONAL,
calledDirectoryNumber [13] CalledDirectoryNumber{b2} OPTIONAL,
bearerCapability [60] BearerCapability{b2} OPTIONAL,
calledPartySubaddress [61] CalledPartySubaddress{b2} OPTIONAL,
connectionIdentifier [62] ConnectionIdentifier{b2} OPTIONAL,
genericIdentifier [63] GenericIdentifier{b2} OPTIONAL,
qOSParameter [64] QoSParameter{b2} OPTIONAL,
bISDNParameters [65] BISDNParameters{b2} OPTIONAL,
...,
originalCalledPartyID [14] OriginalCalledPartyID{b2} OPTIONAL,
callingPartysCategory [15] CallingPartysCategory OPTIONAL,
redirectingPartyID [16] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [17] RedirectionInformation OPTIONAL,
displayInformation [18] DisplayInformation{b2} OPTIONAL,
forwardCallIndicators [19] ForwardCallIndicators OPTIONAL,
genericNumbers [20] GenericNumbers{b2} OPTIONAL,
forwardGVNS [21] ForwardGVNS{b2} OPTIONAL,
globalCallReference [23] GlobalCallReference{b2} OPTIONAL,
-- syntax to be confirmed
cug-Interlock [24] CUG-Interlock OPTIONAL,
cug-OutgoingAccess [25] NULL OPTIONAL,
incomingSignallingBufferCopy [26] BOOLEAN DEFAULT FALSE,
ipRelatedInformation [27] IPRelatedInformation{b2} OPTIONAL
}
-- OPTIONAL parameters are only provided if modifications desired to basic call processing values
manageTriggerData{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ManageTriggerDataArg {b1,
b2}
RESULT ManageTriggerDataResultArg {b1,
b2}
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
CODE opcode-manageTriggerData
}
-- Direction: SCF -> SSF, Class 1, Timer: Tmtd
-- This trigger management operation is used outside the context of a call to activate, deactivate or retrieve
-- the status of one or several trigger detection point linked to a subscriber profile known at the switch,
-- e.g. related to an access line ( i.e. an individual trigger).
ManageTriggerDataArg{B1:b1, B2:b2} ::= SEQUENCE {
actionIndicator [0] ActionIndicator,
triggerDataIdentifier
CHOICE {profileAndDP [1] TriggerDataIdentifier{b1, b2},
-- one trigger
profile [5] ProfileIdentifier{b2}},
registratorIdentifier [2] RegistratorIdentifier OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
tDPIdentifier [4] TDPIdentifier{b2} OPTIONAL,
...
}
ManageTriggerDataResultArg{B1:b1, B2:b2} ::= CHOICE {
oneTriggerResult
SEQUENCE {actionPerformed [0] ActionPerformed,
extensions [1] Extensions{b1} OPTIONAL,
...},
severalTriggerResult
[1] SEQUENCE {results [0] TriggerResults{b2},
extensions [1] Extensions{b1} OPTIONAL,
...}
}
mergeCallSegments{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT MergeCallSegmentsArg {b1,
b2}
RETURN RESULT TRUE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
CODE opcode-mergeCallSegments
}
-- Direction: SCF -> SSF. Timer: T mc
-- This operation is issued by the SCF to merge two associated CSs , into one CS .
MergeCallSegmentsArg{B1:b1, B2:b2} ::= SEQUENCE {
sourceCallSegment [0] CallSegmentID{b2},
targetCallSegment [1] CallSegmentID{b2} DEFAULT initialCallSegment,
extensions [2] Extensions{b1} OPTIONAL,
...,
mergeSignallingPaths [3] NULL OPTIONAL
}
monitorRouteReport{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT MonitorRouteReportArg {b1,
b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-monitorRouteReport
}
-- Direction SSF-> SCF: Timer T mrp
-- This operation is used by the SSF to report the result of a route monitoring procedure.
MonitorRouteReportArg{B1:b1, B2:b2} ::= SEQUENCE {
routeCounters [0] RouteCountersValue{b2},
correlationID [2] CorrelationID{b2},
...,
...,
extensions [3] Extensions{b1} OPTIONAL
}
monitorRouteRequest{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT MonitorRouteRequestArg {b1,
b2}
RETURN RESULT TRUE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedParameter}
CODE opcode-monitorRouteRequest
}
-- Direction SCF -> SSF. Timer Tmrr
-- This operationis issued by the SCF to request the SSF to monitor specified routes.
MonitorRouteRequestArg{B1:b1, B2:b2} ::= SEQUENCE {
routeList [0] RouteList{b2},
correlationID [1] CorrelationID{b2},
monitoringCriteria [2] MonitoringCriteria,
monitoringTimeout [3] MonitoringTimeOut,
startTime [4] DateAndTime OPTIONAL,
...,
...,
extensions [5] Extensions{b1} OPTIONAL
}
moveCallSegments{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT MoveCallSegmentsArg {b1,
b2}
RETURN RESULT TRUE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
CODE opcode-moveCallSegments
}
-- Direction: SCF -> SSF, Timer Tmcs
-- This operation moves a CS from the source CSA to the the target CSA
MoveCallSegmentsArg{B1:b1, B2:b2} ::= SEQUENCE {
targetCallSegmentAssociation [0] CSAID{b2},
callSegments
[1] SEQUENCE SIZE (1..b2.&numOfCSs) OF
SEQUENCE {sourceCallSegment
[0] CallSegmentID{b2} DEFAULT initialCallSegment,
newCallSegment [1] CallSegmentID{b2},
...},
legs
[2] SEQUENCE SIZE (1..b2.&numOfLegs) OF
SEQUENCE {sourceLeg [0] LegID,
newLeg [1] LegID,
...},
extensions [3] Extensions{b1} OPTIONAL,
...
}
moveLeg{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT MoveLegArg {b1,
b2}
RETURN RESULT TRUE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
CODE opcode-moveLeg
}
-- Direction : SCF ->SSF, Timer: T ml
-- This operation is issued by the SCF to move a leg from one CS to another with which it is associated.
MoveLegArg{B1:b1, B2:b2} ::= SEQUENCE {
legIDToMove [0] LegID,
targetCallSegment [1] CallSegmentID{b2} DEFAULT 1,
extensions [2] Extensions{b1} OPTIONAL,
...,
detachSignallingPath [3] NULL OPTIONAL, -- action on source
exportSignallingPath [4] NULL OPTIONAL -- action on target
}
oAbandon{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT OAbandonArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-oAbandon
}
-- Direction: SSF -> SCF. Timer: T ob
-- This operation is issued by the SSF after detecting a valid trigger condition at the O_Abandon DP or to
-- report an oAbandon event requested by the RequestReportBCSMEvent.
OAbandonArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
callSegmentID [1] CallSegmentID{b2},
releaseCause [2] Cause{b2} OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
...
}
-- Use of T/EDP-R is outside
-- the scope of this capability set.
oAnswer{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT OAnswerArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-oAnswer
}
-- Direction: SSF -> SCF, Timer: Toa
-- This operation is used for indication from the terminating half BCSM that the call is accepted and answered
-- by terminating party (e.g. terminating party goes offhook, Q.931 Connect message received, IS-UP Answer
-- message received) (DP - O_Answer).
OAnswerArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
callingPartyBusinessGroupID [1] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [2] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [3] FacilityGroup OPTIONAL,
callingFacilityGroupMember [4] FacilityGroupMember OPTIONAL,
originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL,
redirectingPartyID [6] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [7] RedirectionInformation OPTIONAL,
routeList [8] RouteList{b2} OPTIONAL,
travellingClassMark [9] TravellingClassMark{b2} OPTIONAL,
extensions [10] Extensions{b1} OPTIONAL,
...
}
oCalledPartyBusy{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT OCalledPartyBusyArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-oCalledPartyBusy
}
-- Direction: SSF -> SCF, Timer: Tob
-- This operation is used for Indication from the terminating half BCSM that the terminating party is busy
-- (DP - O_Called_Party_Busy). .
OCalledPartyBusyArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
busyCause [1] Cause{b2} OPTIONAL,
callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [4] FacilityGroup OPTIONAL,
callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL,
originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL,
prefix [7] Digits{b2} OPTIONAL,
redirectingPartyID [8] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [9] RedirectionInformation OPTIONAL,
routeList [10] RouteList{b2} OPTIONAL,
travellingClassMark [11] TravellingClassMark{b2} OPTIONAL,
extensions [12] Extensions{b1} OPTIONAL,
carrier [13] Carrier{b2} OPTIONAL,
...
}
oDisconnect{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ODisconnectArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-oDisconnect
}
-- Direction: SSF -> SCF, Timer: Tod
-- This operation is used for a disconnect indication (e.g. onhook, Q.931 Disconnect message, SS7 Release message)
-- is received from the originating party, or received from the terminating party via the terminating half BCSM.
-- (DP - O_Disconnect). .
ODisconnectArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
callingPartyBusinessGroupID [1] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [2] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [3] FacilityGroup OPTIONAL,
callingFacilityGroupMember [4] FacilityGroupMember OPTIONAL,
releaseCause [5] Cause{b2} OPTIONAL,
routeList [6] RouteList{b2} OPTIONAL,
extensions [7] Extensions{b1} OPTIONAL,
carrier [8] Carrier{b2} OPTIONAL,
connectTime [9] Integer4 OPTIONAL,
componentType [10] ComponentType OPTIONAL,
component [11] Component OPTIONAL,
componentCorrelationID [12] ComponentCorrelationID OPTIONAL,
...
}
oMidCall{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT MidCallArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-oMidCall
}
-- Direction: SSF -> SCF, Timer: Tomc
-- This operation is used to indicate a feature request is received from the originating party
-- (e.g. hook flash, ISDN feature activation, Q.931 HOLD or RETrieve message). (DP - O_Mid_Call).
MidCallArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL,
calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL,
callingPartyBusinessGroupID [3] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [4] CallingPartySubaddress{b2} OPTIONAL,
featureRequestIndicator [5] FeatureRequestIndicator OPTIONAL,
extensions [6] Extensions{b1} OPTIONAL,
carrier [7] Carrier{b2} OPTIONAL,
componentType [8] ComponentType OPTIONAL,
component [9] Component OPTIONAL,
componentCorrelationID [10] ComponentCorrelationID OPTIONAL,
...
}
oNoAnswer{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ONoAnswerArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-oNoAnswer
}
-- Direction: SSF -> SCF, Timer: Tona
-- This operation is used for indication from the terminating half BCSM that the terminating party does not
-- answer within a specified time period (DP - O_No_Answer).
ONoAnswerArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
callingPartyBusinessGroupID [1] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [2] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [3] FacilityGroup OPTIONAL,
callingFacilityGroupMember [4] FacilityGroupMember OPTIONAL,
originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL,
prefix [6] Digits{b2} OPTIONAL,
redirectingPartyID [7] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [8] RedirectionInformation OPTIONAL,
routeList [9] RouteList{b2} OPTIONAL,
travellingClassMark [10] TravellingClassMark{b2} OPTIONAL,
extensions [11] Extensions{b1} OPTIONAL,
carrier [12] Carrier{b2} OPTIONAL,
...
}
originationAttempt{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT OriginationAttemptArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-originationAttempt
}
-- Direction: SSF -> SCF. Timer: Tora
-- This operation is used for indication of a call origination attempt from the originating half BCSM.
-- (DP - Origination_Attempt).
OriginationAttemptArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
callingPartyBusinessGroupID [1] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [2] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [3] FacilityGroup OPTIONAL,
callingFacilityGroupMember [4] FacilityGroupMember OPTIONAL,
carrier [5] Carrier{b2} OPTIONAL,
travellingClassMark [6] TravellingClassMark{b2} OPTIONAL,
extensions [7] Extensions{b1} OPTIONAL,
componentType [8] ComponentType OPTIONAL,
component [9] Component OPTIONAL,
componenttCorrelationID [10] ComponentCorrelationID OPTIONAL,
...
}
originationAttemptAuthorized{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT OriginationAttemptAuthorizedArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-originationAttemptAuthorized
}
-- Direction: SSF -> SCF, Timer: Toaa
-- This operation is used to Indicate the desire to place outgoing call (e.g. offhook, Q.931 Setup message,
-- ISUP IAM message) and authority/ability to place outgoing call verified (DP -
-- Origination_Attempt_Authorized).
OriginationAttemptAuthorizedArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
dialledDigits [1] CalledPartyNumber{b2} OPTIONAL,
callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [4] FacilityGroup OPTIONAL,
callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL,
travellingClassMark [6] TravellingClassMark{b2} OPTIONAL,
extensions [7] Extensions{b1} OPTIONAL,
carrier [8] Carrier{b2} OPTIONAL,
componentType [9] ComponentType OPTIONAL,
component [10] Component OPTIONAL,
componentCorrelationID [11] ComponentCorrelationID OPTIONAL,
...
}
oSuspended{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT OSuspendedArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-oSuspended
}
-- Direction: SSF -> SCF. Timer: T os
-- This operation is issued by the SSF after detecting a valid trigger condition at the O_Suspend DP or to
-- report an oSuspend event requested by the RequestReportBCSMEvent.
OSuspendedArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
legID [1] LegID OPTIONAL,
extensions [2] Extensions{b1} OPTIONAL,
...
}
reconnect{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ReconnectArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-reconnect
}
-- Direction: SCF -> SSF. Timer: T re
-- This operation is issued by the SCF to reestablish communication between the controlling leg and the
-- (held) passive leg(s). .
ReconnectArg{B1:b1, B2:b2} ::= SEQUENCE {
notificationDuration [0] ApplicationTimer OPTIONAL,
alertingPattern [1] AlertingPattern OPTIONAL,
displayInformation [2] DisplayInformation{b2} OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
callSegmentID [4] CallSegmentID{b2} OPTIONAL,
...
}
releaseCall{B2:b2} OPERATION ::= {
ARGUMENT ReleaseCallArg {b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-releaseCall
}
-- Direction: SCF -> SSF, Timer: Trc
-- This operation is used by the SCF to tear down an existing call segment at any phase of the call for all parties
-- involved in the call segment or to tear down all existing call segments within a Call Segment Association.
ReleaseCallArg{B2:b2} ::= CHOICE {
initialCallSegment Cause{b2},
callSegmentToRelease
[1] SEQUENCE {callSegment [0] INTEGER(1..b2.&numOfCSs),
releaseCause [1] Cause{b2} OPTIONAL,
forcedRelease [2] BOOLEAN DEFAULT FALSE,
...},
allCallSegments
[2] SEQUENCE {releaseCause [0] Cause{b2} OPTIONAL,
timeToRelease [1] TimerValue OPTIONAL,
forcedRelease [2] BOOLEAN DEFAULT FALSE,
...},
...
}
-- A default cause value of decimal 31 (normal unspecified) should be coded appropriately.
-- If timeToRelease parameter is omitted, the default shall be no timed disconnect requested
-- If forcedRelease parameter is omitted (default value "FALSE") the default shall be no forced release requested.
reportUTSI{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ReportUTSIArg {b1,
b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-reportUTSI
}
-- Direction: SSF -> SCF. Timer: Tru
-- This operation is issued by the SSF in the context of the USI feature. It is used to report the receipt
-- of a User to Service Information (USI) to the SCF.
ReportUTSIArg{B1:b1, B2:b2} ::= SEQUENCE {
uSIServiceIndicator [0] USIServiceIndicator{b2},
legID [1] LegID DEFAULT receivingSideID:leg1,
uSIInformation [2] USIInformation{b2},
extensions [3] Extensions{b1} OPTIONAL,
...
}
requestCurrentStatusReport{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT RequestCurrentStatusReportArg {b2}
RESULT RequestCurrentStatusReportResultArg {b1,
b2}
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownResource}
CODE opcode-requestCurrentStatusReport
}
-- Direction: SCF -> SSF, Timer: Trcs
-- This operation is used to request the SSF to report immediately the busy/idle status of a physical
-- termination resource.
RequestCurrentStatusReportArg{B2:b2} ::=
ResourceID{b2}
RequestCurrentStatusReportResultArg{B1:b1, B2:b2} ::= SEQUENCE {
resourceStatus [0] ResourceStatus,
resourceID [1] ResourceID{b2} OPTIONAL,
extensions [2] Extensions{b1} OPTIONAL,
...
}
requestEveryStatusChangeReport{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT RequestEveryStatusChangeReportArg {b1,
b2}
RETURN RESULT TRUE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownResource}
CODE opcode-requestEveryStatusChangeReport
}
-- Direction: SCF -> SSF, Timer: Tres
-- This operation is used to request the SSF to report every change of busy/idle status of a physical
-- termination resource.
RequestEveryStatusChangeReportArg{B1:b1, B2:b2} ::= SEQUENCE {
resourceID [0] ResourceID{b2},
correlationID [1] CorrelationID{b2} OPTIONAL,
monitorDuration [2] Duration OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
...
}
-- For correlationID OPTIONAL denotes network operator optional.
-- monitorDuration is required if outside the context of a call. It is not expected if we are in the context
-- of a call, because in that case the end of the call implicitly means the end of the monitoring.
requestFirstStatusMatchReport{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT RequestFirstStatusMatchReportArg {b1,
b2}
RETURN RESULT TRUE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownResource}
CODE opcode-requestFirstStatusMatchReport
}
-- Direction: SCF -> SSF, Timer: Trfs
-- This operation is used to request the SSF to report the first change busy/idle to the specified status of
-- a physical termination resource.
RequestFirstStatusMatchReportArg{B1:b1, B2:b2} ::= SEQUENCE {
resourceID [0] ResourceID{b2} OPTIONAL,
resourceStatus [1] ResourceStatus OPTIONAL,
correlationID [2] CorrelationID{b2} OPTIONAL,
monitorDuration [3] Duration OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
bearerCapability [5] BearerCapability{b2} OPTIONAL,
...
}
-- For correlationID OPTIONAL denotes network operator optional.
-- monitorDuration is required if outside the context of a call. It is not expected if we are in the context
-- of a call, because in that case the end of the call implicitly means the end of the monitoring.
requestNotificationChargingEvent{B2:b2} OPERATION ::= {
ARGUMENT RequestNotificationChargingEventArg {b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-requestNotificationChargingEvent
}
-- 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 FE's and not under control of the service logic instance.
RequestNotificationChargingEventArg{B2:b2} ::=
SEQUENCE SIZE (1..b2.&numOfChargingEvents) OF ChargingEvent{b2}
requestReportBCSMEvent{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT RequestReportBCSMEventArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-requestReportBCSMEvent
}
-- 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.
-- It is proposed that Event Detection Point (EDP) processing is always initiated by RequestReportBCSMEvent
-- and the EDP may be acknowledged with either an EventReportBCSM or by a DP-specific operation.
-- NOTE - the application context should identify whether BCSM Event Handling Package
-- is being used, or whether DP Specific Event Handling Package is being used.
-- For a particular IN, only one of the two alternatives identified by the respective Packages should be
-- selected (i.e., only one approach should be selected for a given application context).
-- Every EDP must be explicitly armed by the SCF via a RequestReportBCSMEvent operation.
-- No implicit arming of EDPs at the SSF after reception of any operation (different from
-- RequestReportBCSMEvent) from the SCF is allowed.
RequestReportBCSMEventArg{B1:b1, B2:b2} ::= SEQUENCE {
bcsmEvents
[0] SEQUENCE SIZE (1..b2.&numOfBCSMEvents) OF BCSMEvent{b2},
bcsmEventCorrelationID [1] CorrelationID{b2} OPTIONAL,
extensions [2] Extensions{b1} OPTIONAL,
...
}
-- Indicates the BCSM related events for notification.
-- For correlationID OPTIONAL denotes network operator optional.
requestReportFacilityEvent{B1:b1} OPERATION ::= {
ARGUMENT RequestReportFacilityEventArg {b1}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-requestReportFacilityEvent
}
-- SCF->SSF, Timer: Trrfe
-- This operation is issued by the SCF to request the SSF to report the SCF the event that the CCF/SSF
-- receives a DSS1 message which contains a FACILITY IE during a BCSM being suspended at a DP.
RequestReportFacilityEventArg{B1:b1} ::= SEQUENCE {
componentTypes
[0] SEQUENCE SIZE (1..3) OF ComponentType DEFAULT {any},
legID [1] LegID OPTIONAL,
componentCorrelationID [2] ComponentCorrelationID OPTIONAL,
monitorDuration [3] Duration,
extensions [4] Extensions{b1} OPTIONAL,
...
}
-- componentTypes specifies the component types which should be reported to the SCF.
-- monitorDuration specifies the monitor duration.
requestReportUTSI{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT RequestReportUTSIArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-requestReportUTSI
}
-- Direction: SCF -> SSF. Timer: Trru
-- This operation is issued by the SCF in the context of the USI feature to request the SSF to monitor for
-- a User to Service Information (UTSI) information element, which are received from a user.
RequestReportUTSIArg{B1:b1, B2:b2} ::= SEQUENCE {
requestedUTSIList [0] RequestedUTSIList{b2},
extensions [1] Extensions{b1} OPTIONAL,
legID [2] LegID DEFAULT sendingSideID:leg1,
...
}
resetTimer{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ResetTimerArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-resetTimer
}
-- Direction: SCF -> SSF, Timer: Trt
-- This operation is used to request the SSF to refresh an application timer in the SSF.
ResetTimerArg{B1:b1, B2:b2} ::= SEQUENCE {
timerID [0] TimerID DEFAULT tssf,
timervalue [1] TimerValue,
extensions [2] Extensions{b1} OPTIONAL,
callSegmentID [3] CallSegmentID{b2} OPTIONAL,
...
}
routeSelectFailure{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT RouteSelectFailureArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | taskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-routeSelectFailure
}
-- Direction: SSF -> SCF, Timer: Trsf
-- This operation is used to indicate that the SSP is unable to select a route (e.g. unable to determine a
-- correct route, no more routes on route list) or indication from the terminating half BCSM that a call
-- cannot be presented to the terminating party (e.g. network ongestion) (DP - Route_Select_Failure).
RouteSelectFailureArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
dialledDigits [1] CalledPartyNumber{b2} OPTIONAL,
callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL,
callingFacilityGroup [4] FacilityGroup OPTIONAL,
callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL,
failureCause [6] Cause{b2} OPTIONAL,
originalCalledPartyID [7] OriginalCalledPartyID{b2} OPTIONAL,
prefix [8] Digits{b2} OPTIONAL,
redirectingPartyID [9] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [10] RedirectionInformation OPTIONAL,
routeList [11] RouteList{b2} OPTIONAL,
travellingClassMark [12] TravellingClassMark{b2} OPTIONAL,
extensions [13] Extensions{b1} OPTIONAL,
carrier [14] Carrier{b2} OPTIONAL,
...
}
selectFacility{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT SelectFacilityArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-selectFacility
}
-- Direction: SCF -> SSF, Timer: Tsf
-- This operation is used to request the SSF to perform the terminating basic call processing
-- actions to select the terminating line if it is idle, or selects an idle line from a multi-line hunt
-- group, or selects an idle trunk from a trunk group, as appropriate. If no idle line or trunk is
-- available, the SSF determines that the terminating facility is busy.
SelectFacilityArg{B1:b1, B2:b2} ::= SEQUENCE {
alertingPattern [0] AlertingPattern OPTIONAL,
destinationNumberRoutingAddress [1] CalledPartyNumber{b2} OPTIONAL,
iSDNAccessRelatedInformation
[2] ISDNAccessRelatedInformation{b2} OPTIONAL,
calledFacilityGroup [3] FacilityGroup OPTIONAL,
calledFacilityGroupMember [4] FacilityGroupMember OPTIONAL,
originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL,
extensions [6] Extensions{b1} OPTIONAL,
displayInformation [7] DisplayInformation{b2} OPTIONAL,
serviceInteractionIndicators
[8] ServiceInteractionIndicators{b2} OPTIONAL,
iNServiceCompatibilityResponse [9] INServiceCompatibilityResponse OPTIONAL,
forwardGVNS [10] ForwardGVNS{b2} OPTIONAL,
backwardGVNS [11] BackwardGVNS{b2} OPTIONAL,
serviceInteractionIndicatorsTwo
[12] ServiceInteractionIndicatorsTwo OPTIONAL,
correlationID [13] CorrelationID{b2} OPTIONAL,
scfID [14] ScfID{b2} OPTIONAL,
callSegmentID [15] CallSegmentID{b2} OPTIONAL,
legToBeCreated [16] LegID OPTIONAL,
...,
ipRelatedInformation [17] IPRelatedInformation{b2} OPTIONAL
}
-- OPTIONAL parameters are only provided if modifications desired to basic call processing values.
selectRoute{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT SelectRouteArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-selectRoute
}
-- Direction: SCF -> SSF, Timer: Tsr
-- This operation is used to request the SSF to perform the originating basic call processing actions to
-- determine routing information and select a route for a call, based either on call information available
-- to the SSF, or on call information provided by the SCF (e.g. for alternate routing), to include the
-- called party address, type of call, carrier, route index, and one or more alternate route indices.
-- Based on the routing information, the SSF attempts to select a primary route for the call, and if the
-- route is busy, attempts to select an alternate route. The SSF may fail to select a route for the call
-- if all routes are busy.
SelectRouteArg{B1:b1, B2:b2} ::= SEQUENCE {
destinationRoutingAddress [0] DestinationRoutingAddress{b2},
alertingPattern [1] AlertingPattern OPTIONAL,
correlationID [2] CorrelationID{b2} OPTIONAL,
iSDNAccessRelatedInformation
[3] ISDNAccessRelatedInformation{b2} OPTIONAL,
originalCalledPartyID [4] OriginalCalledPartyID{b2} OPTIONAL,
routeList [5] RouteList{b2} OPTIONAL,
scfID [6] ScfID{b2} OPTIONAL,
travellingClassMark [7] TravellingClassMark{b2} OPTIONAL,
extensions [8] Extensions{b1} OPTIONAL,
carrier [9] Carrier{b2} OPTIONAL,
serviceInteractionIndicators
[10] ServiceInteractionIndicators{b2} OPTIONAL,
iNServiceCompatibilityResponse
[11] INServiceCompatibilityResponse OPTIONAL,
forwardGVNS [12] ForwardGVNS{b2} OPTIONAL,
backwardGVNS [13] BackwardGVNS{b2} OPTIONAL,
serviceInteractionIndicatorsTwo
[14] ServiceInteractionIndicatorsTwo OPTIONAL,
callSegmentID [15] CallSegmentID{b2} OPTIONAL,
legToBeCreated [16] LegID OPTIONAL,
...,
ipRelatedInformation [17] IPRelatedInformation{b2} OPTIONAL
}
-- OPTIONAL parameters are only provided if modifications desired to basic call processing values.
sendChargingInformation{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT SendChargingInformationArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | unexpectedComponentSequence | unexpectedParameter |
parameterOutOfRange | systemFailure | taskRefused | unexpectedDataValue |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-sendChargingInformation
}
-- Direction: SCF -> SSF, Timer: Tsci
-- This operation is used to instruct the SSF on the charging information to send 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.
SendChargingInformationArg{B1:b1, B2:b2} ::= SEQUENCE {
sCIBillingChargingCharacteristics [0] SCIBillingChargingCharacteristics{b2},
partyToCharge [1] LegID,
extensions [2] Extensions{b1} OPTIONAL,
nocharge [3] BOOLEAN OPTIONAL,
...
}
sendFacilityInformation{B1:b1} OPERATION ::= {
ARGUMENT SendFacilityInformationArg {b1}
RETURN RESULT FALSE
ERRORS
{missingParameter | unexpectedComponentSequence | unexpectedParameter |
unexpectedDataValue | systemFailure | taskRefused | unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-sendFacilityInformation
}
-- SCF->SSF, Timer: Tsfi
-- This operation is issued by the SCF during a BCSM being suspended at a DP to request the CCF/SSF
-- sending a FACILITY IE to a user with a specified DSS1 message.
SendFacilityInformationArg{B1:b1} ::= SEQUENCE {
componentType [0] ComponentType,
legID [1] LegID OPTIONAL,
componentCorrelationID [2] ComponentCorrelationID OPTIONAL,
component [3] Component,
callProcessingOperation [4] CallProcessingOperation DEFAULT fACility,
extensions [5] Extensions{b1} OPTIONAL,
...
}
-- FACILITY information will be delivered with the specified DSS1 message. The message is specified with the
-- callProcessingOperation
sendSTUI{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT SendSTUIArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | unexpectedComponentSequence |
unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused |
unknownLegID}
ALWAYS RESPONDS FALSE
CODE opcode-sendSTUI
}
-- Direction: SCF -> SSF. Timer: Tss
-- This operation is issued by the SCF in the context of the USI feature. It is used to request the SSF
-- to send a Service to User Information (USI information) data element to the indicated user.
SendSTUIArg{B1:b1, B2:b2} ::= SEQUENCE {
uSIServiceIndicator [0] USIServiceIndicator{b2},
legID [1] LegID DEFAULT sendingSideID:leg1,
uSIInformation [2] USIInformation{b2},
extensions [3] Extensions{b1} OPTIONAL,
...
}
serviceFilteringResponse{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ServiceFilteringResponseArg {b1,
b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-serviceFilteringResponse
}
-- 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
ServiceFilteringResponseArg{B1:b1, B2:b2} ::= SEQUENCE {
countersValue [0] CountersValue{b2},
filteringCriteria [1] FilteringCriteria{b2},
extensions [2] Extensions{b1} OPTIONAL,
responseCondition [3] ResponseCondition OPTIONAL,
...
}
setServiceProfile{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT SetServiceProfileArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | parameterOutOfRange | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-setServiceProfile
}
-- Direction SCF -> SSF, Timer Tsep
--This operation is used within the context of a call to request the SSF to activate/de-activate a list of trigger for one of the parties in the call.
SetServiceProfileArg{B1:b1, B2:b2} ::= SEQUENCE {
iNprofiles
[0] SEQUENCE SIZE (1..b2.&numOfINProfile) OF INprofile{b1, b2},
...,
...,
extensions [30] Extensions{b1} OPTIONAL
}
splitLeg{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT SplitLegArg {b1,
b2}
RETURN RESULT TRUE
ERRORS
{missingParameter | unexpectedComponentSequence | unexpectedParameter |
unexpectedDataValue | systemFailure | taskRefused | unknownLegID}
CODE opcode-splitLeg
}
-- Direction: SCF -> SSF. Timer: T sl
-- This operation is issued by the SCF to separate one joined leg from a multi-way connection
-- or a single 2 party Call segment.
SplitLegArg{B1:b1, B2:b2} ::= SEQUENCE {
legToBeSplit [0] LegID,
newCallSegment [1] INTEGER(2..b2.&numOfCSs),
extensions [2] Extensions{b1} OPTIONAL,
...,
detachSignallingPath [3] NULL OPTIONAL
}
statusReport{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT StatusReportArg {b1,
b2}
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-statusReport
}
-- Direction: SSF -> SCF, Timer: Tsrp
-- This operation is used as a response to RequestFirstStatusMatchReport or
-- RequestEveryStatusChangeReport operations.
StatusReportArg{B1:b1, B2:b2} ::= SEQUENCE {
resourceStatus [0] ResourceStatus OPTIONAL,
correlationID [1] CorrelationID{b2} OPTIONAL,
resourceID [2] ResourceID{b2} OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
reportCondition [4] ReportCondition OPTIONAL,
...
}
-- For correlationID, OPTIONAL denotes network operator optional.
-- resourceID is required when the SSF sends a report as an answer to a previous request when the
-- correlationID was present.
tAnswer{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT TAnswerArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue |
systemFailure | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-tAnswer
}
-- Direction: SSF -> SCF, Timer: Tta
-- This operation is used to indicate that the call is accepted and answered by terminating party
-- (e.g. terminating party goes offhook, Q.931 Connect message received, ISUP Answer message
-- received) (DP - T_Answer).
TAnswerArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL,
calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL,
calledFacilityGroup [3] FacilityGroup OPTIONAL,
calledFacilityGroupMember [4] FacilityGroupMember OPTIONAL,
extensions [5] Extensions{b1} OPTIONAL,
componentType [6] ComponentType OPTIONAL,
component [7] Component OPTIONAL,
componentCorrelationID [8] ComponentCorrelationID OPTIONAL,
...
}
tBusy{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT TBusyArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue |
systemFailure | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-tBusy
}
-- Direction: SSF -> SCF, Timer: Ttb
-- This operation is used to indicate all resources in group busy (DP- TBusy).
TBusyArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
busyCause [1] Cause{b2} OPTIONAL,
calledPartyBusinessGroupID [2] CalledPartyBusinessGroupID OPTIONAL,
calledPartySubaddress [3] CalledPartySubaddress{b2} OPTIONAL,
originalCalledPartyID [4] OriginalCalledPartyID{b2} OPTIONAL,
redirectingPartyID [5] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [6] RedirectionInformation OPTIONAL,
routeList [7] RouteList{b2} OPTIONAL,
travellingClassMark [8] TravellingClassMark{b2} OPTIONAL,
extensions [9] Extensions{b1} OPTIONAL,
...
}
tDisconnect{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT TDisconnectArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue |
systemFailure | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-tDisconnect
}
-- Direction: SSF -> SCF, Timer: Ttd
-- This operation is used for a disconnect indication (e.g. onhook, Q.931 Disconnect message,
-- SS7 Release message) is received from the terminating party, or received from the originating party
-- via the originating half BCSM. (DP - T_Disconnect).
TDisconnectArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL,
calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL,
calledFacilityGroup [3] FacilityGroup OPTIONAL,
calledFacilityGroupMember [4] FacilityGroupMember OPTIONAL,
releaseCause [5] Cause{b2} OPTIONAL,
extensions [6] Extensions{b1} OPTIONAL,
connectTime [7] Integer4 OPTIONAL,
componentType [8] ComponentType OPTIONAL,
component [9] Component OPTIONAL,
componentCorrelationID [10] ComponentCorrelationID OPTIONAL,
...
}
termAttemptAuthorized{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT TermAttemptAuthorizedArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue |
systemFailure | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-termAttemptAuthorized
}
-- Direction: SSF -> SCF, Timer: Ttaa
-- This operation is used for indication of incoming call received from originating half BCSM and authority
-- to route call to a specified terminating resource (or group) verified. (DP - Termination_Authorized).
TermAttemptAuthorizedArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL,
calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL,
callingPartyBusinessGroupID [3] CallingPartyBusinessGroupID OPTIONAL,
originalCalledPartyID [4] OriginalCalledPartyID{b2} OPTIONAL,
redirectingPartyID [5] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [6] RedirectionInformation OPTIONAL,
routeList [7] RouteList{b2} OPTIONAL,
travellingClassMark [8] TravellingClassMark{b2} OPTIONAL,
extensions [9] Extensions{b1} OPTIONAL,
callingPartySubaddress [10] CallingPartySubaddress{b2} OPTIONAL,
...
}
-- OPTIONAL parameters are only provided if modifications desired to basic call processing values
terminationAttempt{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT TerminationAttemptArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue |
systemFailure | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-terminationAttempt
}
-- Direction: SSF -> SCF. Timer: Ttra
-- This operation is used for indication of a call termination attempt from the terminating half BCSM. (DP -
-- Termination_Attempt).
TerminationAttemptArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL,
calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL,
callingPartyBusinessGroupID [3] CallingPartyBusinessGroupID OPTIONAL,
callingPartySubaddress [4] CallingPartySubaddress{b2} OPTIONAL,
originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL,
redirectingPartyID [6] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [7] RedirectionInformation OPTIONAL,
routeList [8] RouteList{b2} OPTIONAL,
travellingClassMark [9] TravellingClassMark{b2} OPTIONAL,
extensions [10] Extensions{b1} OPTIONAL,
...
}
tMidCall{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT MidCallArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue |
systemFailure | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-tMidCall
}
-- Direction: SSF -> SCF, Timer: Ttmc
-- This operation is used to indicate that a feature request is received from the terminating party (e.g. hook
-- flash, ISDN feature activation Q.931 HOLD or RETrieve message). (DP - T_Mid_Call).
tNoAnswer{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT TNoAnswerArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue |
systemFailure | taskRefused}
ALWAYS RESPONDS FALSE
CODE opcode-tNoAnswer
}
-- Direction: SSF -> SCF, Timer: Ttna
-- This operation is used to indicate that the terminating party does not answer within a specified duration.
-- (DP - T_No_Answer). .
TNoAnswerArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL,
calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL,
calledFacilityGroup [3] FacilityGroup OPTIONAL,
calledFacilityGroupMember [4] FacilityGroupMember OPTIONAL,
originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL,
redirectingPartyID [6] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [7] RedirectionInformation OPTIONAL,
travellingClassMark [8] TravellingClassMark{b2} OPTIONAL,
extensions [9] Extensions{b1} OPTIONAL,
componentType [10] ComponentType OPTIONAL,
component [11] Component OPTIONAL,
componentCorrelationID [12] ComponentCorrelationID OPTIONAL,
...
}
tSuspended{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT TSuspendedArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | taskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter}
ALWAYS RESPONDS FALSE
CODE opcode-tSuspended
}
-- Direction: SSF -> SCF. Timer: T ts
-- This operation is issued by the SSF after detecting a valid trigger condition at the T_Suspend DP or to
-- report a tSuspended event requested by the RequestReportBCSMEvent.
TSuspendedArg{B1:b1, B2:b2} ::= SEQUENCE {
dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2},
legID [1] LegID OPTIONAL,
extensions [2] Extensions{b1} OPTIONAL,
...
}
END
-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D