Facility - Remote operations parameter


SS7-ISUP (3.48/Q.763 (09/97)

8 7 6 5 4 3 2 1 ext1 0 0 1 0 0 0 1 - Remote operations protocol - - components - -
NOTE - The component may be repeated any number of times within the remote operations parameter. In case of multiple service requests, the receiving entity shall treat the repetition of Invoke components identical to the case where multiple Remote Operations parameters are received in a single message.

DSS1 (8.2.3.1 Q.932 (05/98)

Service components


Components

The Components are based on the Remote Operations Service Element (ROSE) of Rec. X.229. The description is divided into two forms:

Component types:

Component type tag
Invoke
Return Result
Return Error
Reject

Component types in ASN.1:

Component ::=   CHOICE { invoke          [1] IMPLICIT Invoke,
                         returnResult    [2] IMPLICIT ReturnResult,
                         returnError     [3] IMPLICIT ReturnError,
                         reject          [4] IMPLICIT Reject }

The full specification of SS7-ISUP components in ASN.1:

ISUPRemoteOperations {CCITT Recommendation q763 moduleA(0)}

DEFINITIONS     ::=
BEGIN
EXPORTS OPERATION, ERROR

Component ::=   CHOICE { invoke          [1] IMPLICIT Invoke,
                         returnResult    [2] IMPLICIT ReturnResult,
                         returnError     [3] IMPLICIT ReturnError,
                         reject          [4] IMPLICIT Reject }

--  The Components are sequences of data elements.

Invoke          ::= SEQUENCE {invokeID, InvokeID Type,
                              linkedID [0] IMPLICIT InvokeID Type OPTIONAL,
                              operationCode OPERATION,
                              parameter ANY DEFINED BY operationCode OPTIONAL }

                              -- ANY is filled by the single ASN.1 data
                              -- type following the key word PARAMETER in
                              -- the type definition of a particular
                              -- operation.

ReturnResult    ::= SEQUENCE {invokeID InvokeID Type,
                              SEQUENCE {operationCode OPERATION,
                              parameters ANY DEFINED BY operationCode}OPTIONAL}

                              -- ANY is filled by the single ASN.1 data
                              -- type following the key word PARAMETER in
                              -- the type definition of a particular
                              -- operation.


ReturnError     ::= SEQUENCE {invokeID InvokeID Type
                              errorCode ERROR,
                              parameter ANY DEFINED BY errorCode
                              OPTIONAL }

                              -- ANY is filled by the single ASN.1 data
                              -- type following the key word PARAMETER in
                              -- the type definition of a particular
                              -- error.

Reject          ::= SEQUENCE {invokeID CHOICE {InvokeID Type, NULL },
                              problem CHOICE {
                              generalProblem   [0] IMPLICIT GeneralProblem,
                              invokeProblem    [1] IMPLICIT InvokeProblem,
                              returnResultProblem  [2] IMPLICIT ReturnResultProblem,
                              returnErrorProblem [3] IMPLICIT ReturnErrorProblem }}


InvokeIDType    ::=     INTEGER (-128 ... 127).
-- OPERATIONS
-- Operations are specified with the OPERATION MACRO. When an operation is specified, the valid parameter set, results and errors for that operation are indicated. Default values and optional parameters are permitted.
OPERATION MACRO
BEGIN                   ::=

TYPE NOTATION           ::=     Parameter Result Errors LinkedOperations
VALUE NOTATION  ::=     value (VALUE CHOICE {
                                        localValue INTEGER,
                                        globalValue OBJECT IDENTIFIER })

Parameter               ::=     "PARAMETER" NamedType | empty

Result                  ::=     "RESULT" ResultType | empty

Errors                  ::=     "ERRORS"  "{"ErrorNames"}" | empty

LinkedOperations        ::=     "LINKED" {LinkedOperationNames"}" | empty

ResultType              ::=     NamedTyped | empty

Error Names             ::=     ErrorList | empty

Error List              ::=     Error | ErrorList", "Error

Error                   ::=     value (ERROR)
                -- shall reference an error value
                                    |type
                -- shall reference an error type if no error value is specified

LinkedOperationNames    ::=     OperationList | empty

OperationList           ::=     Operation | OperationList", "Operation

Operation                       ::=     value (OPERATION)
                                                -- shall reference an Operation Value
                                        |type
                                                -- shall reference an Operation type if no Operation value is specified

NamedType                       ::=     identifiertype | type

END             -- end of Operation Macro
-- ERRORS
-- Errors are specified with the ERROR MACRO. When an error is specified, the valid parameters for that error are indicated. Default values and optional parameters are permitted.
ERROR MACRO             ::=
BEGIN

TYPE NOTATION           ::=     Parameter
VALUE NOTATION  ::=     value (VALUE CHOICE {
                                             localValue INTEGER,
                                             globalValue OBJECT IDENTIFIER} )
Parameter               ::=     "PARAMETER"NamedType | empty

NamedType               ::=     identifier type | type
END             --  end of Error Macro

-- PROBLEMS

GeneralProblem          ::=     INTEGER {       unrecognizedComponent (0)
                                                                mistypedComponent (1)
                                                                badlyStructuredComponent (2) }

InvokeProblem           ::=     INTEGER {       duplicateInvokeID (0)
                                                                unrecognizedOperation  (1)
                                                                mistypedParameter (2)
                                                                resourceLimitation (3)
                                                                initiatingRelease (4)
                                                                unrecognizedLinkedID  (5)
                                                                linkedResponseUnexpected (6)
                                                                unexpectedLinkedOperation (7) }

ReturnResultProblem     ::=     INTEGER {       unrecognizedInvokeID (0)
                                                                returnResultUnexpected  (1)
                                                                mistypedParameter (2) }

ReturnErrorProblem      ::=     INTEGER {       unrecognizedInvokeID (0)
                                                                returnErrorUnexpected (1)
                                                                unrecognizedError (2)
                                                                unexpectedError (3)
                                                                mistypedParameter (4) }

END             --  end of ISUPRemoteOperation Module.
The full specification of DSS1 components in ASN.1:
Facility-Information-Element-Component { ccitt recommendation q 932 facility-information-element-component (3) }

DEFINITIONS     ::=
BEGIN
EXPORTS         Component, InvokeComponent, InvokeIdentifierType;
IMPORTS         OPERATION, ERROR        FROM-Remote-Operations-Notation

{ joint iso-ccitt x 219 remote-operation(4) notation(0) }

--  Component definitions:
--  Types and values of operations and errors are defined in the
--  Q.95x-series
--  Recommendations or elsewhere using
--  Remote Operations notation
--  Operation values and error values are either of integer type
--  or of object identifier
--  type. If integer types are used, they shall be
--  distinct within that abstract syntax adopted in the Q.95x-series
--  Recommendations.

Component ::=  CHOICE {
                        invokeComp   [1] IMPLICIT InvokeComponent,
                        retResultComp[2] IMPLICIT ReturnResultComponent,
                        retErrorComp [3] IMPLICIT ReturnErrorComponent,
                        rejectComp   [4] IMPLICIT RejectComponent }

InvokeComponent ::=  SEQUENCE {
                     invokeIdentifier InvokeIdentifierType,
                     linkedIdentifier [0] IMPLICIT
                     invokeIdentifierType OPTIONAL,
                     operationValue OPERATION,
                     argument ANY DEFINED BY
                     operationValue OPTIONAL }

--  ANY is filled by the single ASN.1
--  data type following the keyword
--  ARGUMENT in the type
--  definition of a particular operation

ReturnResultComponent ::=               SEQUENCE {
        invokeid invokeIdentifierType,
        SEQUENCE {
        operationValue OPERATION,
        result ANY DEFINED BY
        operationValue OPTIONAL } }
--  ANY is filled by the single ASN.1
--  data type following the keyword
--  RESULT in the type definition
--  of a particular operation

ReturnErrorComponent ::=        SEQUENCE {
        invokeld InvokeldentifierType,
        errorValue ERROR,
        parameter ANY DEFINED BY errorValue
        OPTIONAL }
--  ANY is filled by the single ASN.1 data type
--  following the keyword PARAMETER
--  in the type definition of a
--  particular error

RejectComponent ::=             SEQUENCE {
        InvokeId CHOICE {
                                        InvokeIdentifierType,
                                        NULL },
        problemCHOICE {
        [0] IMPLICIT GeneralProblem,
        [1] IMPLICIT InvokeProblem,
        [2] IMPLICIT ReturnResultProblem,
        [3] IMPLICIT ReturnErrorProblem } }

InvokeldentifierType ::=                INTEGER (-32768 .. 32767)

GeneralProblem ::=              INTEGER {
--  detected by the Q.932 protocol entity
              unrecognizedComponent    (0),
              mistypedComponent        (1),
              badlyStructuredComponent (2) }

InvokeProblem ::=                       INTEGER {
--  detected by particular supplementary
--  service entity
        duplicatelnvocation      (0),
        unrecognizedOperation    (1),
        mistypedArgument         (2),
        resourceLimitation       (3),
        initiatorReleasing       (4),
        unrecognizedLinkedld     (5),
        linkedResponseUnexpected (6),
        unexpectedChildOperation (7) }

ReturnResuItProblem ::=         INTEGER {
--  detected by particular supplementary
--  service entity
        unrecognizedlnvocation (0),
        resultResponseUnexpected (1),
        mistypedResult (2) }

ReturnErrorProblem ::=          INTEGER {
--  detected by particular supplementary
--  service entity
        unrecognizedInvocation  (0),
        errorResponseUnexpected (1),
        unrecognizedError       (2),
        unexpectedError         (3),
        mistypedParameter       (4) }
END             --  of Q.932 Facility Information Element Component
                --  definitions

Remote Operations Protocol - Component (octets 4, etc.) q.932.8.2.3.1

This Recommendation makes use of and is a subset of Recommendations X.208 [7] [Specification of Abstract Syntax Notation One (ASN.1)], X.209 [8] [Specification of basic encoding rules for Abstract Syntax Notation One (ASN.1)], X.219 [9] (Remote operations : model notation and service definition), and X.229 [10] (Remote operations: protocol specification). An extract of the relevant clauses of Recommendations X.208 and X.209 and X.219 is provided in Appendices III and IV, respectively. Table 8-7 provides a formal definition of the abstract syntax of the different component types. The component, comprised of octets 4, etc., may be repeated an indefinite number of times within the Facility information element. In the case of multiple service requests, the receiving entity (user or network) shall treat the repetition of components id entical to the case where multiple Facility information elements are received in a single message. Additional requirements for initiating multiple service requests (user or network) are for further study. NOTE 1 - Recommendation X.229 which defines the Remote Operations Service Element (ROSE) uses the term Application Protocol Data Unit (APDU) in place of component. However, since this protocol element may be applied to the support of network layer service s and of application layer services, the term "component" is more appropriate in the context of this Recommendation. NOTE 2 - See Appendices III and IV for a general description of the component coding and formatting principles.

Facility information element component coding

ss7 Remote operations parameter

 Invoke identifier tags
An invoke identifier is used to identify an operation invocation and is reflected in the return result, return error or reject component sent in response to it. Invoke identifiers used within the Facility information element have significance only within the call reference, including the dummy call reference, in which they are sent. Procedures need to be provided to resolve possible conflicts in the case of use of the dummy Call reference value in the broadcast CEI and a specific CEI simultaneously. Proce dures may need to be provided to ensure that invoke identifiers are not prematurely reused during the lifetime of an operation which may result in a return error (Class 3) or a reject (Classes 3 and 5). Procedures may also need to be provided to avoid the case of two invoke components with the same Invoke Identifier being simultaneously sent in opposite directions. In the absence of such procedures, component exchanges resulting in ambiguous reject compo nents can occur as shown in Figure 8-3.
inv, id = x
------------------------------------->
inv, id = x
<-------------------------------------
rr, id = x
------------------------------------->
rej, id = x, prob. tag = general
<-------------------------------------

8.2.3.1.3       Treatment of existing Q.931 information elements as parameters
Supplementary service protocol specifications are expected to require new parameters to be defined and to require the use of existing Q.931 information elements.
New parameters shall be defined using X.209 coding if they do not appear elsewhere in Q.931 messages.
Supplementary service protocol specifiers may elect to encapsulate one or more existing Q.931 information elements within an X.209 data element, thereby retaining the Q.931 coding for these information elements. When this option is chosen, all the Q.931 i
nformation elements should be grouped together as the content following the Q.931 information elements tag. This is illustrated in Figure 8-4. The tag is defined in Table 8-8. This data element may appear by itself or as a member of a sequence or set as i
ndicated in IV.6.
NOTE - Encapsulation of the Facility information element within Facility information elements shall not be used.


Figure 8-4/Q.932 - Encapsulation of Q.931 information elements
Table 8-8/Q.932 - Q.931 information elements tag
Bits
8  7  6  5  4  3  2  1
0  1  0  0  0  0  0  0  Q.931 information elements
NOTE - All other values are reserved but this approach may also be applied in the future to coding structures from other Recommendations by defining other tags as required.
Table 8-9 provides a formal definition of the Q.931 information element type.
Table 8-9/Q.932
Embedded-Q931-Types { ccitt recommendation q 932 embedded-q931-types (5) }
DEFINITIONS EXPLICIT TAGS ::=
BEGIN
EXPORTS                         Q931 InformationElement;
Q931InformationElement          ::=     [APPLICATION 0] IMPLICIT OCTET STRING
END -- of Embedded-Q931-Types