-- Module IN-CS3-SSF-SCF-ops-args (Q.1238.2:06/2000)
-- See also ITU-T Q.1238.2 (06/2000)
-- See also the index of all ASN.1 assignments needed in this document
IN-CS3-SSF-SCF-ops-args {itu-t recommendation q 1238 modules(1)
in-cs3-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-CS3-object-identifiers {itu-t recommendation q 1238 modules(1)
in-cs3-object-identifiers(0) version1(0)}
OPERATION
FROM Remote-Operations-Information-Objects {joint-iso-itu-t
remote-operations(4) informationObjects(5) version1(0)}
COMMON-BOUNDS
FROM IN-CS3-common-classes {itu-t recommendation q 1238 modules(1)
in-cs3-common-classes(5) version1(0)}
SCF-SSF-BOUNDS
FROM IN-CS3-SSF-SCF-Classes {itu-t recommendation q 1238 modules(1)
in-cs3-ssf-scf-classes(7) version1(0)}
SCF-SRF-BOUNDS
FROM IN-CS3-SCF-SRF-classes {itu-t recommendation q 1238 modules(1)
in-cs3-scf-srf-classes(11) version1(0)}
opcode-activateServiceFiltering, opcode-activityTest,
opcode-analysedInformation, opcode-analyseInformation,
opcode-applyCharging, opcode-applyChargingReport,
opcode-assistRequestInstructions, opcode-authorizeTermination,
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-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-CS3-operationcodes {itu-t recommendation q 1238 modules(1)
in-cs3-operationcodes(3) version1(0)}
Extensions{}, Integer4, InvokeID
FROM IN-CS3-common-datatypes {itu-t recommendation q 1238 modules(1)
in-cs3-common-datatypes(1) version1(0)}
AccessCode{}, ActionIndicator, ActionPerformed,
AChBillingChargingCharacteristics{}, AdditionalCallingPartyNumber{},
AlertingPattern, ApplicationTimer, AssistingSSPIPRoutingAddress{},
BackwardGVNS{}, BCSMEvent{}, BearerCapability{}, CalledDirectoryNumber{},
CalledPartyBusinessGroupID, CalledPartyNumber{}, CalledPartySubaddress{},
CallingGeodeticLocation{}, CallingPartyBusinessGroupID,
CallingPartyNumber{}, CallingPartysCategory, CallingPartySubaddress{},
CallProcessingOperationCorrelationID, CallReference{}, CallResult{},
CallSegmentID{}, Carrier{}, Cause{}, CCSS, CGEncountered, ChargeNumber{},
ChargingEvent{}, CNInfo{}, Component, ComponentCorrelationID,
ComponentType, ControlType, CorrelationID{}, CountersValue,
CreateOrRemoveIndicator, CSAID{}, CutAndPaste, DateAndTime,
DefaultFaultHandling{}, 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{}, IPRoutingAddress{}, IPSSPCapabilities{},
ISDNAccessRelatedInformation{}, LegID, leg1, LocationNumber{},
MiscCallInfo, MonitorMode, NumberingPlan, OriginalCalledPartyID{},
ProfileIdentifier{}, Reason{}, RedirectingPartyID{},
RedirectionInformation, RegistratorIdentifier, ReportCondition,
RouteingNumber{}, RequestedInformationList{}, RequestedInformationTypeList,
RequestedUTSIList{}, ResourceID{}, ResourceStatus, ResponseCondition,
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-CS3-SSF-SCF-datatypes {itu-t recommendation q 1238 modules(1)
in-cs3-ssf-scf-datatypes(6) version1(0)}
InformationToSend{}
FROM IN-CS3-SCF-SRF-datatypes {itu-t recommendation q 1238 modules(1)
in-cs3-scf-srf-datatypes(10) version1(0)}
cancelFailed, eTCFailed, improperCallerResponse, missingCustomerRecord,
missingParameter, parameterOutOfRange, requestedInfoError, systemFailure,
taskRefused, unavailableResource, unexpectedComponentSequence,
unexpectedDataValue, unexpectedParameter, unknownLegID, unknownResource
FROM IN-CS3-errortypes {itu-t recommendation q 1238 modules(1)
in-cs3-errortypes(2) version1(0)};
-- The following three definitions are local short-hand notation for convenience.
B1 ::=
COMMON-BOUNDS -- defined in Recommendation Q.1238.1
B2 ::= SCF-SSF-BOUNDS -- defined in Recommendation Q.1238.2
B3 ::= SCF-SRF-BOUNDS -- defined in Recommendation Q.1238.3
-- 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.
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,
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 Q.1238.3
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,
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,
...
}
-- 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,
...
}
-- 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 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,
...
}
-- 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,
...
}
-- 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,
...
}
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,
...
}
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}
-- RESULT NULL ??? EDITOR: &ResultType has to be defined because it is used in scfChained
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,
...
}
-- 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,
...
}
-- 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,
callProcessingOperationCorrelationID
[4] CallProcessingOperationCorrelationID DEFAULT fACility,
extensions [5] Extensions{b1} OPTIONAL,
...
}
-- FACILITY information will be delivered with the specified DSS1 message. The message is specified with the
-- callProcessingOperationCorrelationID
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,
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,
...
}
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