Transcript DataKinetics Intelligent networking Intelligent Networking • • • • • • • • Overview Conceptual models Example services Configuration Programming Interface Programming examples Example program Debugging IN - Introduction • The Intelligent Network Architecture to quickly create and deploy customer SERVICES Supports.

DataKinetics
Intelligent networking
Intelligent Networking
•
•
•
•
•
•
•
•
Overview
Conceptual models
Example services
Configuration
Programming Interface
Programming examples
Example program
Debugging
IN - Introduction
• The Intelligent Network
Architecture to quickly create and deploy customer SERVICES
Supports many services
Is a standard - multi-vendor
Distributed platform
• Example services supported by IN
Freephone
Premium Rate
Voice mail
Call Diversion
Call baring
Local Number Portability
UPT
The pre-IN years...
• Local switch (service user access point) is monolithic and
proprietary
• Local switch supports switching, call processing and database
processing
• The same functionality may be duplicated between multiple
nodes
• Different implementations create inter-working problems make
enhancements complex
• The network operator is unable to quickly respond to customer
requests
Pre-IN free-phone service
Special
‘800’
exchange
SSP
800 number is
translated and
forward routed to
destination
Network routes call
(signalling and
voice) to special free
phone exchange/
server
Caller dials freephone 800 number
1-800-1234567
800
translation
database
SSP
SSP
PSTN
Local
exchange
Local
exchange
1-755-997612
Classic IN physical Architecture
Intelligent Peripheral
Play-back
announcements
Service Control Point
Control and database
functions
SCEP/
SMP
SCP
IP
Service Creation Environment
Point/
Service Management Point
Service administration
PSTN
SSP
Service Switching
Point - physical
circuit switching
SS7
SSP
Function of the IN SSP
• Point of subscription for the service USER (this is not
necessarily the SUBSCRIBER)
• IN features
Detection of IN calls
Generation and transmission of queries a SCP
Generate and transmit state information to the SCP (B-party busy, B-party no
answer)
Record and transmit statistics to the SCP
Process SCP requests and replies
Service filtering
Function of the IN SCP
•
•
•
•
Parameter (service) validation and authentication
Process requests from SSP, send responses
Call routing, parameter, time, service, subscriber dependant
Control IP to play back standard announcements
Function of the IP
•
The functionality integrated into a Service Switching Point often provides
restricted capabilities only, the main application being targeted towards general
announcements.
•
IPs are dedicated to user interaction. They provide high storage capacity
together with numerous functions:
Standard announcements
Information collection via DTMF
Speaker independent voice recognition
Customized announcements
Fast modification/customization of announcements
Speaker dependent voice recognition
Complex dialogues controlled via internal scripts
Provision of conferencing resources (defined in CS-2)
Function of the SCEP/SMP
•
•
•
•
Service Administration
Development and introduction of new services
Modification of exsisting services
Provides a Service Creation Environment (generally a graphical
interface)
Generalised IN call flow
• User communicates with the SSP (dials the called party
number).
• The SSP analyses the number and determines that this is an IN
call.
• The SSP contacts the SCP to determine how the call should
continue.
• The SCP can optionally obtain further caller information by
instructing the IP to play back announcements (I.e. to collect
PIN).
• The SCP instructs the SSP on how the call should continue,
modifying call data as appropriate to any subscribed services.
Simplified IN Call
2 & 5. How should the
call be processed?
IP
1. Off hook and dial
number
4 Announcement
SCP
3 & 6. Instructions
SS7 Network
SSP
7. Call progressed
through to destination
SSP
Freephone service Example
SSP
Multiple
destinations
SCP
2,6
SSP
3
1
SSP
4
SSP
5
Freephone Service
1. Calling party dials the freephone number (e.g. 0800 123456).
2. A trigger set in the SSP causes an INAP query to be sent to the
SCP, containing the called and calling party information. On
reception of the Query, the SCP translates the freephone
number to the ‘best fit’ destination.
3. The SCP sends the destination number back to the SSP and
requests return of charging information once the call has
completed.
4. The SSP resumes call processing with the new destination
address, routing the call over the PSTN.
5. The call is established.
6. After the call is terminated, the SSP sends charging information
to the SCP.
Televoting service Example
SCP
IP
2,5
4
3,6
1
SSP
SSP
Televoting example
1. Calling party dials the televoting number.
2. Switch recognises televoting call and sends a query to the SCP.
The SCP analyses the dialled number and increments the
appropriate vote count. The SCP determines that a prompt
indicating successful registration of the vote is required.
3. The SCP sends a routing number of an appropriate IP able to
play the televoting announcement. The IP plays the
announcement.
4. The IP informs the SSP that the announcement has been played
and is complete.
5. The SSP sends the completion status to the SCP
6. The SCP instructs the SSP to clear the call.
Televoting service method (2)
SCP
IP
1,3
3
4
2
SSP
SSP
Televoting service method (2)
1 SCP initiates service filtering (televoting) at the SSP
2 Subscriber dials, SSP informs SCP that the specified service
has been activated
3 SCP instructs the SSP to play an announcement (using the IP)
and release the call once the announcement has completed.
4 After a specified time, or at specific defined time intervals set
when the service was activated, the SSP reports the televote
count to the SCP.
Steps 2 and 3 may be repeated many times!
IN CS-1 Benchmark services
See Q.1219 Annex A for example service flows
Abbreviated Dialing (ABD)
Attendant (ATT)
Authentication (AUTC)
Autorisation Code (AUTZ)
Automatic Call Back (ACB)
Call Distribution (CD)
Call Forwarding (CF)
Call Forwarding on Busy/Don’t Answer
Call Gapping (GAP)
Call Hold with Announcement (CHA)
Call Limiter (LIM)
Call Logging (LOG)
Call Queuing (QUE)
Call Transfer (TRA)
Call Waiting (CW)
Closed User Group (CUG)
Consultation Calling (COC)
Customer Profile Management (CPM)
Customized Recorded Announcement (CRA)
Customized Ringing (CRG)
Destination User Prompter (DUP)
Follow-Me Diversion (FMD)
Mass Calling (MAS)
Meet-Me Conference (MMC)
Multiway Calling (MWC)
Off-Net Access (OFA)
Off-Net Calling (ONC)
One Number (ONE)
Origin Dependent Routing (ODR)
Originating Call Screening (OCS)
Originating User Prompter (OUP)
Personal Numbering (PN)
Premium Charging (PRMC)
Private Numbering Plan (PNP)
Reverse Charging (REVC)
Split Charging (SPL)
Terminating Call Screening (TCS)
Time Dependent Routing (TDR)
Types of IN signalling
• Between SSPs: To directly control circuit switched connection or
exchange information relating to a call that is in progress on a
switched circuit (56 or 64kb/s) - Circuit related
• Between SSP and SCP: To exchange control information, no
physical bearer circuit exists between the SSP and SCP. This is
non-circuit related or transaction based signalling.
• Between SSP and IP, and SCP and IP: May be ISUP, INAP or
proprietary.
Protocol Model
SSP
IP
INAP
ISUP
TCAP
ISUP
SCCP
MTP
MTP
SCP
INAP
INAP
TCAP
TCAP
SCCP
SCCP
MTP
Note: There may also be an ISDN link between the SSP and IP
ISUP
• To directly control switched circuit channels.
• Defines message formats, message sequences.
SCCP
• Signalling Connection Control Part
• A ‘thin’ protocol layer allowing data to be exchanged between
intelligent entities (sub-systems) through the SS7 network.
• Provides routing and addressing control.
• Each entity that communicates using SCCP is identified by its
point code and sub-system number (or global title).
• Communication may be session based (connection oriented
SCCP) or connectionless
TCAP (or TC)
• Transaction Capabilities Application Part
• Provides a structure for the invocation of operations at remote
intelligent entities.
• An exchange of messages is called a transaction at the SCCP
interface and a dialogue at the INAP interface.
• Unstructured dialogue - non session based, uses TC-UNI
messages
• Structured dialogue - session based, requires BEGIN,
CONTINUE, END.
• INAP uses structured dialog only.
• Operations and their results are conveyed in ‘components’
within each dialogue.
TCAP control state machines
Dialogue handling
Establishment, maintenance and close down of dialogues
Each dialogue is identified by a dialogue_id.
Component handling
One state machine per invoked operation on the invoking side
Each operation is identified by an invoke_id.
Operation timer
Controls the duration of a invocation state machine.
Communication TCAP & TCAP-User
1.
TC User
Component
Sublayer
2.
1. Single Components (primitives)
2. Collect Components
3. All collected components
of one dialog in one message
Transaction Sublayer
3.
TCAP message
SCCP
MTP
TCAP dialogue primitives
TC-Begin.Req; TC-Begin.Ind
TC-Continue.Req; TC-Continue.Ind
TC-End.Req(Basic); TC-End.Ind(Basic)
TC-End.Req(Prearranged): Local termination of the transaction
TC-User-Abort.Req; TC-User-Abort.Ind: ‘User Information’ informs about
abort reasons (normal abort, error indication)
TC-Provider-Abort.In: Sent by the transaction sub-layer of TCAP
TC-Notice.Ind: Requested SCCP service was not available
TCAP component primitives
TC-Invoke.Req / Ind
TC-Result.Last.Req / Ind
TC-User-Error.Req / Ind
TC-User-Reject.Req / Ind
TC-Local-Reject.Ind / TC-Remote-Reject.Ind: Errors detected by TCAP:
Those errors are indicated to the user. The user decides whether the error shall
be sent to the peer entity or not (controlled by sending the respective dialog
handling primitive)
TC-Cancel.Req: TCAP user requests locally the abort of a previously invoked
operation and the cancellation of the related state
TC-Cancel.Ind: Indication of an operation timer expiration to the local TCAP user.
(Interpretation by the TCAP user depends on the operation class!)
IN Conceptual Model
Four planes (Q.120x) are used to model and abstract the IN
functionality:
Q.1202 - Service Plane (SP) Uppermost, describes services
from the users perspective. Hides details of implementation from
the user
Q.1203 - Global Functional Plane (GFP) contains Service
Independent Building Blocks (SIBs), reusable components to
build services
Q.1204 - Distributed Functional Plane (DFP) models the
functionality in terms of units of network functionality, known as
Functional Entities (FEs). The basis for IN execution in the DPF
is the IN Basic Call State Model.
Q.1205 - Physical Plane (PP) Real view of the physical network.
SP/GFP
Service feature
Service
Q.1212
(Not defined!)
Service
Plane
One number
Reverse charging
Q.1213
Translate
Basic call
process
Screen
Charging
SIB
Global
Functional
Plane
SIBs
A SIB has the following characteristics:
• Exists in the Global Functional Plane.
• It is a re-useable building block, defining a complete activity.
• It has a defined interface, with a specified number of inputs and
outputs.
• It is independent of the physical implementation.
• SIBs are independent of the IN Services.
• SIBs are combined to implement a Service.
• CS-1 SIB examples: Authenticate, Charge, Log Call Information,
Screen.
• Some Service Creation Environments operate on SIBs
BCP and POI
• Special SIB called the Basic Call Process (BCP).
• This interacts with the other SIBs.
• The GFP defines the Point of Initiation (POI) and the Point of
Return (POR) between the BCP and any other SIB or sequence
of SIBs.
CS-1 Points of Initiation
CS-1 Points of Return
Call originated
Address collected
Address analysed
Call arrival
Busy
No Answer
Call acceptance
Active state
End of call
Continue with existing data
Proceed with new data
Handle as transit
Clear call
Provide call party handling
Initiate call
Freephone modeling with CS-1 SIBs
Translate
Charge_1
(Calling free
of charge)
Charge_2
(Record for
subscriber)
SIB Chain 1
POI
Address
Analyzed
BCP
Translate
SIB
Chain 2
POR
POI
Proceed Busy
with new
data
Translate
SIB
Chain 3
UI
SIB
Chain 4
POR
POI
POR
POI
POR
Proceed No AnswerProceedNo Answer Clear
with new
with new
Call
data
data
Service Features
Calling line is set free of charge
The service subscriber is to be charged
The first call attempt shall be routed to an alternative destination if the first destination is busy or does not answer, i.e.
rerouting on “busy” or “no answer”
If a re-routed call, i.e. due to “busy” or “no answer” during the first attempt, meets a “no answer” situation then an
announcement shall be played to the caller. This means that the “busy” situation shall not be monitored for during the second
attempt.
GFP/DFP (For CS-1)
Q.1213
Basic call
process
POI
SIB n
POR
SIB n
BCM
Global
Functional
Plane
SCF
Q.1214
SSF
CCF
SDF
Distributed
Functional
Plane
SRF
Functional Entity
Functional Entities
• Basic Call handling
Call Control Agent Functions (CCAF) - models the users telephone
Connection Control Function (CCF) - basic switching
Specialised Resource Function (SRF) - additional media management
• Service Execution Functions
Service Switching Functions (SSF) - interface to SCF
Service Control Function (SCF) - service logic
Service Data Function (SDF) - service data
SRF
• Service Management Functions
System Management Functions (SMF) - service provisioning, maintenance
Service Management Agent Functions (SMAF) - MMI for SMF
service Creation Environment Function (SCEF) - specification and testing
FE and SIB association (CS-1)
CCF/SCF
Authenticate
Algorithm
Charge
Compare
Distribution
Limit
Log Call Information
Queue
Screen
Service Data Mgt
Status Notification
Translate
User Interaction
Verify
Basic Call Process
SCF
SRF
SDF
DFP and the Physical Plane
Distributed
Functional
Plane
SCF
Q.1214
SRF
SDF
SSF
Functional Entity
Q.1215
SCP
SDF
SSP
INAP
Communication
IP
Physical
Plane
CS1 physical FE distribution
SCP
Voice Transport
Signaling
SMAF
SCF
SMF
SDF
IP
SCEF
Optional FE
SMP
SDF
SRF
SDP
SN
SCF
SRF
SCF
SSF
CCF
SDF
SRF
SSF
CCF
CCAF
SDF
SSP
SS7 Network
FE definition of IP and SN
Intelligent Peripheral
•
•
An IP (Intelligent Peripheral) contains the Specialized Resource Function only, i.e. an IP
provides capabilities necessary for services with user dialogues
An IP is controlled by the service logic
Service Node
•
•
•
•
A Service Node (SN) comprises all functions needed to provide services (Service Control
Function, Service Data Function, Service Switching Function, Call Control Function and
Specialized Resource Function
A Service Node is able to provide complete services independent on other networks
components
Service Nodes may be also called Intelligent Network in a Box
The mentioned functions represent the minimum function set of a Service Node. Obviously
there are additional functions useful concerning management, service creation and other
areas.
Service Node architecture
INAP to SCP
MAP to HLR
Management
SCEF
INAP to SSP
SCF
SDF
Bearer Control
(DSS1 or ISUP)
SSF/
CCF
SRF
SN features
•
Internal proprietary interfaces between its components
•
The service logic can directly access the voice channel
•
Besides voice now numerous data communication protocols and
applications may be used
•
Flexible, efficient and cheap (good cost performance ratio)
implementation of services for small service providers
•
Easy introduction into existing networks based on connection via
standard signaling protocols (EDSS1, ISUP)
•
Reduction of #7 signaling load
•
Lower traffic concentration
Example SN capabilities
• Voice messaging
subscribers record own messages which are distributed through the network
(according to a distribution list).
• Fax messaging
Record fax messages during busy hour to retransmit during off-peak charing
period.
• Short Message Service
Gateway to email networks.
• Electronic mail
Service Modelling in the CS-1 DFP
• SIBs are modelled in the DFP by interactions between
Functional entities.
• Each SIB is modelled by the SCF controlling other FE’s.
• The BCP is modelled in the DFP by the Basic Call State Model
in the CCF.
SIB n
Basic call
process
SIB n
SCF
CCF
SSF
SDF
The Basic Call State Model
•
•
•
•
BCSM
Standard definition of call processing states and events
Switch and manufacturer independent
Trigger Detection Points are pre-defined in both the Originating
Basic Call State Model OBCSM and the Termination Basic Call
State Model (TBCSM)
• Non-interruptable sequences of processing are called Points-InCall (PIC)
IN Triggers
• A normal call becomes an ‘IN call’ if a special condition is
recognised during the call handling
• Recognition of such a condition ‘triggers’ a query to an external
control component (SCP)
• Recognition takes place at pre-defined Detection Points in the
call handling, which may be armed (active) or not armed
(inactive)
• DPs may be armed statically for a long period to implement a
particular IN Service.
• DPs may be armed dynamically to report particular events and
errors.
Types of Triggers
• Two types of processing on satisfying a DP:
Suspend call processing and request instructions
Request : TDP_R
Continue Call processing and issue Notification to SCF
Notification : TDP_N
CS-1 originating BCSM
O_Abandon
10
1. O_Null & Authorise
Origination_Attempt
Orig_attempt
Authorised
6. O_Exception
1
2. Collect_info
Point in Call (PIC)
Collected_info
Detection Point (DP)
2
3. Analyse_info
Route_select_failure
4
Analysed _info
3
4. Routing_&_alerting
O_Called_party_busy
5
O_No_Answer
O_Answer
9
O_Disconnect
7
6
5. O_Active
8
O_Mid_call
OBCSM Triggers
•
DP1 : Origination_attempt_authorized
Call setup is recognized and authorized.
•
DP2 : Collected_Information
Pre-defined number of dialed digits is collected
•
DP3 : Analyzed_Information
Dialed digits are analyzed
•
DP4 : Route_Select_Failure
Routing failed : no free channel, dialed number not available, network overload
•
DP5 : O_Called_Party_Busy
Destination busy
•
DP6 : O_NO_Answer
Caller does not answer in predefined time, Service Logic specifies the “no answer time” for SSP
•
DP7 : O_Answer
Called subscriber answers: SSP receives e.g. an ANM
•
DP8 : O_Mid_Call
Signal (hook flash, F-key) recognized during call
•
DP9 : O_Disconnect
A or B side hangs up
•
DP10 : O_Abandon
Call set-up discontinued by the A-side
CS-1 Terminating BCSM
T_Abandon
7. T_Null & Authorise
termination attempt
18
Term_attempt
Authorised
12
8. Select Facility &
Present Call
Point in Call (PIC)
Detection Point (DP)
11. T_Exception
T_Called_Party_busy
13
T_No_Answer
9. T_Alerting
T_Answer
17
T_Disconnect
14
15
10. T_Active
16
T_Mid_call
TBCSM Triggers
•
DP12 : Termination_attempt_authorized
an incoming call attempt is recognized and authorized
•
DP13 : T_Called_Party_Busy
Destination busy
•
DP14 : T_No_Answer
Called party does not answer during a given time
•
DP15 : T_Answer
Called line answers, I.e. the SSP receives the ANM
•
DP16 : T_Mid_Call
Signal (e.g. hook flash, function key) is recognized during the active connection
•
DP17 : T_Disconnect
Either A-side or B-side hangs up
•
DP18 : T_Abandon
Call set-up aborted by the A-side, can happen at any time and is considered normal
Information Flows
Two methods exsist for requesting SCF processing at a DP:
DP Generic
Only one information flow is used, ‘Initial DP’. The set of
information elements (data) carried depends on the DP
encountered.
DP Specific
Dedicated information exchange for each DP. Easy to process,
less paring effort. High number of different information flows to
analyse. (Not specified for use in ETSI INAP).
Freephone Example
SSF
2
TDP-R
TC-BEGIN
Analyse_info
3
Route_&_Alert
7
Initial DP: fph, 0-800-xxxxxx
EDP-N
O_Active
9
EDP-N
Connect: call, id = xxxxx
Req BCSM event:
O_Answer, O_Disconn
TC-CONTINUE
Event: call, id = xxxxx
BCSM O_Answer, time
TC-CONTINUE
Event: call, id = xxxxx
BCSM O_Disconnect, time
TC-CONTINUE
TC-END
SCF
SDF
Operation: Initial DP
• Semantics:
Report a trigger detection
Establishes a control relationship between SSF and SCF
• Arguments:
serviceKey
calledPartyNumber
callingPartyNumber
bearerCapability
redirectingPartyId
…..
Operation: Connect
• Semantics
Transfer the determined destination number to the SSF
Continue the call set-up
• Arguments:
destinationRoutingAddress
calledPartyNumber
callingPartyNumber
redirectingPartyId
cutAndPaste
...
Parameter: Cut and Paste
•
•
Describes how the digit string should be processed.
–
The Cut&Paste value instructs the SSP to remove the first “Cut&Paste” digits from the
dialed digits.
–
The digits received from the SCP then serve as the leading digits of the destination
address which has to be formed.
–
The digits already existing at the SSP will be added at the end
Example:
–
SSP receives “123456789”
–
SCP instructs CutAndPaste = 4 and destination address = 503322
–
SSP generates destination address 503322 56789
Operation: RequestReportBCSMEvent
• Semantics:
– arming of event detection point at the SSP for call monitoring
• Arguments:
– list of elements of type BCSMEvent
– Example:
DP5 ( = busy)
DP6 ( = no answer)
…..
– Specify DP specific conditions/parameters. (e.g. timer for DP6)
Operation: EventReportBCSM
• Semantics
– Reporting of detected event detection points
• Arguments:
– eventTypeBCSM
–
eventSpecificInformationBCSM
– legID
INAP
• Allows communication between distributed IN Functional
Entities.
• Information flows defined in the DFP are implemented in the
physical plane through the SS7 INAP protocol.
• INAP is defined on a FE basis rather than a physical view.
• INAP supports interactions between:
CCF/SSF and SCF
SCF to SRF
• INAP operations are grouped into Application Service Elements
(ASE’s). An ASE may be considered as being a collection of
operations.
Capability Sets
• Capability Set = set of supported services and service features
• CS-1 Single ended/single point of control services, defined by
Q.121x. Single party (originating or terminating) controls the
INAP call.
• CS-2 Enhancement to all CS-1 structure. Defined by Q.122x.
Capability for multi-point control.
Protocol layers
Application
MAP INAP
TCAP
ISUP
TUP
SCCP
MTP Layer 3
MTP Layer 2
MTP Layer 1
Application Contexts
• Application Service Elements are grouped into Application
Contexts (AC’s).
• An AC is typically a sub-set of the total INAP and specifies the
parts of the protocol needed in the communication between two
type of IN FE’s.
• An AC also defines which operation should initiate the dialogue.
• Example Application Contexts:
• “IN-CS-1-SSF-to-SCF-Generic-AC”
SCF-activation-ASE, Connect-ASE
• “IN-CS-1-SCF-to-SSF-status-reporting-AC
Status-reporting ASE, Cancel ASE
DataKinetics INAP, Key Features
• Provides the INAP communication capability for the SCF, SSF
or SRF.
• FE independent.
• Implements the Single Association Control Function (SACF)
defined in ITU-T Q.1218 and ETS 300 374-1
• Procedural API interface.
• Tailored Suites of ASE’s (INAP operations)
• Supported ASE’s may be tailored to support any network or
operator specific IN functions.
• Supports application context negotiation
• Supports operation with ITU-T/ETSI and ANSI TCAP.
Documentation
•
•
•
•
•
Platform User Guide (Septel cP, PCCS6, SIU)
Software Environment Programmer’s Manual
SCCP Programmer’s Manual
TCAP Programmer’s Manual
INAP Programmer’s Manual
Programming Interface
• INAP is based on invoking an operation at a serving FE by the
requesting FE. These operations are invoked within a session or
“dialogue” between the two FE’s.
• Functional API library supplied with a procedural interface
manages parameter Encoding/decoding as TCAP components,
using ASN.1 rules.
• To access the ASN.1 encoded data, the user may access the
module directly. (Using MSGs).
Functional Entity Addressing
• When a dialogue is opened, the user application must supply
the SCCP address of the local and remote FE’s in the SS7
network.
• These can be included at the start of each dialogue or
configured once (at initialisation) and referenced by a local
logical code.
• Enables INAP to support more than one local FE. (Hence a SCF
and SRF may be implemented on the same stack).
• Each local FE may be handled by a different user task
(module_id).
Application Context Handling
• An Application Context (AC) is required for each dialogue
between two IN FE’s.
• AC negotiation is required at dialogue initiation to determine if
the receiving FE is able to support the requested AC.
• The INAP module can be configured to handle the AC
negotiation automatically if the supported AC’s are configured.
• If required, raw AC data may be exchanged between the INAP
module and the user allowing the user to perform the AC
negotiation.
Module Capability
•
•
•
•
•
Maximum number of FE’s = 32
Maximum number of AC’s = 32
Maximum number of simultaneous dialogues = 2048
Maximum number of simultaneous invocations = 2048
Supports all ETSI CS-1 Core INAP ACs’:
Core-INAP-CS1-SSP-to-SCP-AC
Core-INAP-CS1-ASSIST-HANDOFF-TO-SSP-TO-SCP
Core-INAP-CS1-IP-TO-SCP
Core-INAP-CS1-SSP-to-SCP-AC
Core-INAP-CS1-SCP-TO-SSP-TRAFFIC-MANAGEMENT
Core-INAP-CS1-SCP-TO-SSP-SERVICE-MANAGEMENT
Core-INAP-CS1-SSP-TO-SCP-SERVICE-MANAGEMENT
INAP Configuration
• Single message, INAP_MSG_CONFIG
user_id default application module id if no FE’s configured
TCAP_id module id used by TCAP (normally 0x14)
mngt_id, maint_id Module id for management and maintenance event indications
trace_id Module id for traced messages (debug only)
base_usr_ogdlgid 1st dialogue id that will be used by the user for outgoing dialogues
base_usr_icdlgid 1st dialogue id that will be used by INAP for incoming dialogues
base_tc_ogdlgid 1st outgoing dialogue id to send to TCAP
base_tc_icdlgid 1st incoming dialogue id expected from TCAP
nog_dialogues maximum number of outgoing dialogues to support
nig_dialogues maximum number of incoming dialogues to support
num_invokes maximum number of active invokes (operations) to support
options
ANSI or ITU-T component formats, Transparent AC handling, 14 or 24 bit point codes
• Septel-SIU
Set SCCP_LSS <protocol> to INAP
FE Configuration
• Single message per FR, INAP_MSG_CNF_FE
fe_reference (0..31). Logical identifier unique to each configured FE
FE options Local or Remote
Local FE module ID Module ID identifying the user application process
handling the local FE
FE SCCP address length number of octets of data in the lFE SCCP address
FE SCCP Address FE address formatted according to Q.713, ANSI T1.113
• Septel-SIU
INAP_FE <fe_ref> <options> <fe_addr>
AC Configuration
• Single Message per AC, INAP_MSG_CNF_AC
application context reference logical identifier referencing the supplied AC.
ac_len number of octets of data in application context.
Application Context AC data
• Septel-SIU
INAP_AC <ac_ref> <ac>
Complete configuration sequence
•
•
•
•
•
•
•
•
•
Configure Physical parameters (PCCS6)
Configure MTP3 parameters (links, link sets)
Configure SCCP
Configure SCCP Remote Signalling Points
Configure SCCP Remote sub-systems
Configure SCCP Local sub-systems
Configure INAP
Configure INAP FE’s (optional)
Configure INAP AC’s (optional)
Example configuration
sub-system number = 0x0c
module_id = 0x1d
FE identifier = 5
sub-system number = 0x0a
FE identifier = 1
Point code = 1
Local
Remote
Point code = 2
sub-system number = 0x0d
module_id = 0x2d
FE identifier = 5
sub-system number = 0x0b
FE identifier = 2
Example INAP configuration (1)
*
Issue configuration message to the SCCP module:
*
--maint_id
*
--mod_id
----SMB flags
*
----options --------pc
--SMB id
*
--sio
--mgmt_id
--SCCP inst
*
--ver
--mtp_id
----max_sif
M-t7740-i0000-fef-d33-r8000-p0083000233229e9e000000010110000000000000000000
*
*
Configure Local sub-systems
*
--mult_ind
*
--mod_id
*
--type
--ssn
*
--ver
--------spc
M-t7741-i0000-fef-d33-r8000-000031401000000000c000000000000000000000000000000000000
M-t7741-i0000-fef-d33-r8000-p00031401000000000d000000000000000000000000000000000000
*
Configure Remote SP's
M-t7741-i0000-fef-d33-r8000-p000100000000000200000000000000000000000000000000000000
*
Configure Remote sub-systems
M-t7741-i0000-fef-d33-r8000-p00020000000000020a0000000000000000000000000000000000000
M-t7741-i0000-fef-d33-r8000-p00020000000000020b0000000000000000000000000000000000000
*
Example INAP configuration (2)
*
Issue configuration message to the TCAP module:
*
--mgt_id
max_data---*
--nsap_id
----nicd
--nseq
*
--usr_id
----nogd
----bog
--ndref
*
--mod_id ----flags
----ncpt
--ninst
*
--ver
--maint_id
----ninv
----bic
--inst
M-t7780-i0000-fef-d14-r8000-p001435339e9e00000400040008000010000080000410080200ff0
*
*
Issue configuration message to the INAP module:
*
*
----base_tc_icdlg_id
*
--reserved----base_tc_ogdlg_id
*
--trace_id
options-------*
--Tcap_id
----base_usr_icdlg_id
*
--user_id
----base_usr_ogdlg_id
----num_invokes
*
--maint_id
----nic_dlg
*
--mgmt_id
----nog_dlg
M-t77f4-i0000-fef-d35-r8000-p77149e9e9e0000008000000080000400040008000000000000000
*
Example INAP configuration (3)
*
Config Remote Functional Entites
*
--------addr
*
--addr len
*
--local FE module id
*
----FE 1
----options
M-t77f7-i0001-fef-d35-r8000-p000000044302000a
M-t77f7-i0002-fef-d35-r8000-p000000044302000b
*
*
Config Local Functional Entites
M-t77f7-i0005-fef-d35-r8000-p00011d044301000c
M-t77f7-i0006-fef-d35-r8000-p00012d044301000d
*
*
*
Config Application Contexts
*
--AClen
*
reserved---------------- ----------------------AC
M-t77f6-i0000-fef-d35-r8000-p00000000000000000ba109060704000101010000
M-t77f6-i0001-fef-d35-r8000-p00000000000000000ba109060704000101010100
M-t77f6-i0002-fef-d35-r8000-p00000000000000000ba109060704000101010200
M-t77f6-i0003-fef-d35-r8000-p00000000000000000ba109060704000101010300
M-t77f6-i0004-fef-d35-r8000-p00000000000000000ba109060704000101010400
M-t77f6-i0005-fef-d35-r8000-p00000000000000000ba109060704000101010500
M-t77f6-i0006-fef-d35-r8000-p00000000000000000ba109060704000101010600
*
*
*
Example INAP configuration (4)
*
*
Send UIS (to SCCP), ssn = 0x0c and 0x0d :
*
--SSA
M-tc744-i000c-fef-d33-r8000-p010100000000
*
M-tc744-i000d-fef-d33-r8000-p010100000000
*
*
Sub-system status is maintained by SCCP, hence all sub-system
management requests are made to SCCP and are received from SCCP
(module_id 0x33)
Message based API
Message type
Value
INAP-SERVICE-REQ
0xc7f0
INAP-SERVICE-IND
0x87f1
Usage
Invoke an operation at a remote FE or respond
to a invocation received from a remote FE
Receive results or errors from operations
invoked at a remote FE
INAP_DIALOGUE_REQ 0xc7f2
Issue dialogue command
INAP_DIALOGUE-IND
Receive dialogue event
0x87f3
INAP_MSG_DLG_REQ
MESSAGE HEADER
FIELD NAME
MEANING
type
INAP_MSG_DLG_REQ (0xc7f2)
id
dialogue_ID
src
Sending module_id
dst
INAP_MODULE_ID
rsp_req
0
hclass
0
status
0
err_info
0
len
Number of bytes of user data
PARAMETER AREA
OFFSET
SIZE
NAME
0
1
Dialogue primitive type octet.
1
len - 2
Parameters in Name-Length-Data format.
len - 1
1
Set to zero indicating end of message.
INAP
Programmers
Manual details
other message
specifications
Dialogue primitive types
INAP User to INAP
Primitive
Value
Usage
INAP-OPEN-REQ
0x1
Used to open a dialogue. The INAP module
assigns resources for the dialogue and
awaits any INAP operations the user wishes
to open the dialogue with.
INAP-CLOSE-REQ
0x2
Basic End: Used to indicate that any
operations supplied should now be
transmitted to the remote FE. The dialogue
is then terminated.
Pre Arranged End: Used to indicate that the
dialogue may be terminated locally when
any active invocations have completed. Any
pending components sent to the INAP
module will discarded. The INAP module
will issue a Close Indication when the
dialogue is terminated.
INAP-DELIMIT-REQ
0x3
Used to indicate that any components
supplied should now be transmitted to the
remote FE. The dialogue remains open.
INAP-U-ABORT-REQ
0x4
Used to indicate that the user wishes to
abort this dialogue. Any outstanding
components are discarded.
INAP-OPEN-RSP
0x81
Used to accept or reject a dialogue request
from a remote FE.
Dialogue primitive types
INAP to INAP User
Primitive
Value
Usage
INAP-OPEN-IND
0x1
Used to indicate a dialogue request from a
remote FE. The user may subsequently
receive service indication messages bearing
components. The user should wait to
receive the INAP-DELIMITER-IND before
accepting the dialogue with the INAPOPEN-RSP primitive.
INAP-CLOSE-IND
0x2
Used to indicate that all the components
received have been issued to the user. The
dialogue is terminated.
INAP-DELIMITER-IND
0x3
Used to indicate that all the components
received have been sent to the user. The
dialogue remains open.
INAP-OPEN-CNF
0x81
Used to indicate that the remote FE has
accepted the user’s dialogue request.
INAP-U-ABORT-IND
0x4
Used to indicate that the remote user has
aborted the dialogue, any outstanding
components have been discarded.
INAP-P-ABORT-IND
0x5
Used to indicate that the dialogue has been
aborted because of a network error. Any
outstanding components have been
discarded.
INAP-NOTICE-IND
0x6
Used to indicate that an abnormal
component was detected.
Dialogue parameters
The INAP Programmers
Manual defines the
parameters and which
are required with each
primitive type
M
O
Mandatory
Optional
A
B
C
Exclusive OR
Exclusive OR
Conditional
Parameter
O
P
E
N
R
E
Q
Destination address
A
Originating address
B
Destination reference
A
Originating reference
B
C
L
O
S
E
–
R
E
Q
D
E
L
I
M
I
T
E
R
R
E
Q
U
A
B
O
R
T
R
E
Q
O
P
E
N
R
S
P
Result
M
Refuse reason
O
M
Release method
M
User reason
Application context name
O
Application context index
C
O
O
O
O
O
Service component primitives
INAP User to INAP
Primitive
Value
Usage
INAP-INVOKE-REQ
0x1
Used by the user application to request an
operation invocation.
INAP-RESULT-REQ
0x2
Used by the user application to provide the
successful result of an operation invocation.
INAP-ERROR-REQ
0x3
Used by the user application to provide the
unsuccessful result of an operation
invocation.
INAP-REJECT-REQ
0x4
Used by an API decode function to indicate
a "provider" problem. This occurs if the
decode function is unable to decode the
received component.
Service component primitives
INAP to INAP User
Primitive
Value
Usage
INAP-INVOKE-IND
0x1
Used by the INAP module to convey an
operation invocation to the user application.
INAP-RESULT-IND
0x2
Used by the INAP module to convey the
successful result of an operation previously
invoked by the user.
INAP-ERROR-IND
0x3
Used by the INAP module to convey the
unsuccessful result of an operation
previously invoked by the user.
Service component parameters
Component Type
Parameter
I
N
V
O
K
E
R
E
Q
R
E
S
U
L
T
R
E
Q
E
R
R
O
R
R
E
Q
R
E
J
E
C
T
R
E
Q
Invoke ID
M
M
M
M
Linked ID
O
Component
M
M
M
Op code
M
Parent Ind
O
Class
M
Timeout
M
Problem code
M
Pre-defined operation codes
/*
* SCF activation ASE
*/
#define INOP_InitialDP
(0)
/*
* Basic BCP DP ASE (ITU Q.1218 only)
*/
#define INOP_OriginationAttemptAuthorized
#define INOP_CollectedInformation
#define INOP_AnalysedInformation
#define INOP_RouteSelectFailure
#define INOP_OCalledPartyBusy
#define INOP_ONoAnswer
#define INOP_OAnswer
#define INOP_ODisconnect
#define INOP_TermAttemptAuthorized
#define INOP_TBusy
#define INOP_TNoAnswer
#define INOP_TAnswer
#define INOP_TDisconnect
(1) /* (ITU Q.1218 only) */
(2) /* (ITU Q.1218 only) */
(3) /* (ITU Q.1218 only) */
(4) /* (ITU Q.1218 only) */
(5) /* (ITU Q.1218 only) */
(6) /* (ITU Q.1218 only) */
(7) /* (ITU Q.1218 only) */
(8) /* (ITU Q.1218 only) */
(9) /* (ITU Q.1218 only) */
(10) /* (ITU Q.1218 only) */
(11) /* (ITU Q.1218 only) */
(12) /* (ITU Q.1218 only) */
(13) /* (ITU Q.1218 only) */
See in_inc.h
/*
* Advanced BCP DP ASE (ITU Q.1218 only)
*/
#define INOP_OMidCall
(14) /* (ITU Q.1218 only) */
#define INOP_TMidCall
(15) /* (ITU Q.1218 only) */
Functional API
Message buffer handling functions
IN_alloc_message Allocate a message to send to INAP
IN_free_message De-allocate message
IN_send_message Send message to INAP
Component Handling
IN_init_component
Parameters are detailed
in the INAP Programmer’s
Manual
Used to initialise component encoding/decoding. Must be called before encoding
or decoding a component. Allows the user to specify the protocol (encoding
format).
Component encoding
1. Initialise
Component
CPT
3. Service Request
Encoding Functions
2. Component
Building
Functions
MSG
Component building functions
Build Operation in Component Buffer API Functions
IN_set_operation
Write the operation code
IN_set_error
Write the error code
IN_set_result
Write the result
IN_set_component_param Write the requested parameter
All the above functions operate on the component buffer, which must be
subsequently formatted into a message
Service request encoding
Service Request Encoding
IN_code_operation_invoke Encode the component in an Invoke component
IN_code_result
Encode the component in a Result component
IN_code_error
Encode the component in an Error component
IN_code_reject
Encode the component in an Reject component
Component decoding
1. Initialise
Component
CPT
2.
Decode
Service
Indication
Functions
MSG
3. Read Component
Buffer Functions
De-code service indication
IN_get_component_type
IN_decode_operation
IN_decode_result
IN_decode_error
Obtain received component type
Decode the operation parameter
Decode a result
Decode an error component
Read component buffer
IN_get_component_type
IN_get_component_first_error
Return the type of the received component
IN_get_operation
IN_get_component_param
Get received operation code
Determine the first error encountered during
encoding
Retrieve parameter from received component
Dialogue handling API functions
Send dialogue request API functions
IN_set_dialogue_param Set a dialogue request parameter
IN_dialogue_open
Builds a dialogue open
IN_dialogue_close
Builds a dialogue close
IN_dialogue_delimit
Builds a dialogue delimit
IN_dialogue_u_abort
Builds a dialogue u_abort
IN_dialogue_open_rsp
Builds an open response dialogue primitive
Read dialogue request API functions
IN_get_dialogue_type
Determine dialogue type in received message
IN_get_dialogue_param Recover a parameter from a received dialogue
Outgoing dialogue request
INAP User
INAP
TCAP
SCCP
MTP
INAP_DLG_REQ (OPEN)
INAP_SRV_REQ (INVOKE)
TC-INVOKE
INAP_DLG_REQ (DELIMIT)
TC-BEGIN
N-UNITDATA-REQ
UDT
UDT
INAP_DLG_IND (OPEN-RSP)
INAP_SRV_IND (INVOKE)
TC-CONTINUE
TC-INVOKE
INAP_DLG_IND (DELIMIT)
INAP_DLG_IND (CLOSE)
TC-END
N-UNITDATA-IND
Opening a dialogue
Obtain a message structure, enter the parameters and send to
INAP. No message is issued to the SS7 network at this point.
h = IN_alloc_message();
IN_set_dialogue_param(INDP_dest_address, len, dptr, h);
IN_set_dialogue_param(INDP_orig_address, len, dptr, h);
IN_set_dialogue_param(INDP_applic_context_index, len, dptr, h);
IN_dialogue_open(dlg_id,h);
IN_send_message(user_id,inap_id,h);
Sending an operation
This may only be done on an opened dialogue. The user obtains a
message, initialises a component structure and sent to the INAP
module.
h = IN_alloc_message();
IN_init_component(prot_spec, cpt);
IN_set_operation(op_name, timeout, cpt);
IN_set_component_param( INPN_InvokeID, len, dptr, cpt);
IN_set_component_param( param1, len, dptr, cpt);
IN_set_component_param( param2, len, dptr, cpt);
IN_code_operation_invoke( dlg_id, cpt, h);
IN_send_message(user_id, inap_id, h);
Sending a delimit
This is built and sent in a similar method as the Open.
h = IN_alloc_message();
IN_dialogue_delimit(dlg_id,h);
IN_send_message(user_id,inap_id,h);
Receiving an Open Response
This is achieved by reading a message from the applications message
queue using GCT_receive.
h = GCT_receive();
switch (h->type)
{
case INAP_MSG_SRV_IND :
...
break;
case INAP_MSG_DLG_IND :
IN_get_dialogue_type(h, dlg_type_ptr);
switch (dlg_type_ptr)
{
case INDT_OPEN_RSP:
IN_get_dialogue_param(INDP_result,lenptr,dptr,max_len,h);
IN_get_dialogue_param(INDP_refuse_rsn,lenptr,dptr,max_len,h);
IN_get_dialogue_param(INDP_applic_context,lenptr,dptr,max_len,h);
/* Process the parameters here */
break;
}
break;
}
relm(h);
Decoding an operation
This is achieved in the same way as recovering the dialogue open
response, with a message type indicating a service indication.
h = GCT_receive();
switch (h->type)
{
case INAP_MSG_SRV_IND :
IN_get_component_type(h, &cpt_type);
switch (cpt_type)
{
case INCPT_INVOKE
:
IN_init_component(prot_spec, cpt);
IN_decode_operation(cpt, h);
IN_get_component_param(param1, lenptr, dptr, buffer_size, cpt);
IN_get_component_param(param2, lenptr, dptr, buffer_size, cpt);
/* Process Invoke parameter here */
break;
}
break;
...
}
relm(h);
Closing a dialogue
The Close request is sent to end the dialogue with the remote
system (this may be pre-arranged or basic).
m = IN_alloc_message():
IN_dialogue_close(dlg_id,m);
IN_set_dialogue_param(INDP_release_method, len, dptr, m);
IN_send_message(user_id,inap_id,m);
Other examples
• The INAP Programmers Manual Provides more API examples
and message sequence charts.
Debugging
• Message tracing
• Software events
• Maintenance events
*
Activate Output Event - Trace Mask
*
--------non_prim_mask
*
--------ip_evt_mask
*
--------op_evt_mask
M-t57fb-i0000-fef-d35-r8000-p0000000f0000000f0000007f
*
*
Active Error Event Mask
M-t57fc-i0000-fef-d35-r8000-pff00000000000007ff
*
*
Active Maintainence Event Mask
M-t57fd-i0000-fef-d35-r8000-p000000000000000001
*
INTU example program
INTU
INAP
DLG-IND (OPEN)
TC-BEGIN
SRV-IND (Invoke: Initial DP)
TC-INVOKE
DLG-IND (Delimit)
DLG-REQ (OPEN-RESPONSE)
SRV-REQ (Invoke:Connect)
TC-INVOKE
DLG-REQ (DELIMIT)
TC-CONTINUE
DLG-REQ (CLOSE)
(pre-arranged end)
TC-END (pre-arranged)
DLG-IND (CLOSE)
INTU console
H:\SYSTEM7\RUN>intu -b0x8000
INTU: Example INAP application (C) 1998-1999 DataKinetics Ltd
=============================================================
SS7-INAP-API Version 1.1
INTU module ID - 0x3d
INAP module ID - 0x35
Number of dialogues - 0x0800 (2048)
Base dialogue ID - 0x8000
Options set - 0x0300
INTU:
INTU:
INTU:
INTU:
INTU:
INTU:
INTU:
INTU:
INTU:
INTU:
INTU:
INTU:
State change for dialogue 0x8000
Dialogues: Active [1], Completed
State change for dialogue 0x8000
State change for dialogue 0x8000
State change for dialogue 0x8000
Dialogues: Active [0], Completed
State change for dialogue 0x8001
Dialogues: Active [1], Completed
State change for dialogue 0x8001
State change for dialogue 0x8001
State change for dialogue 0x8001
Dialogues: Active [0], Completed
from
[0],
from
from
from
[1],
from
[1],
from
from
from
[2],
IDLE to OPEN
Successful [0], Failed [0]
OPEN to PENDING_DELIMIT
PENDING_DELIMIT to CLOSING
CLOSING to IDLE
Successful [1], Failed [0]
IDLE to OPEN
Successful [1], Failed [0]
OPEN to PENDING_DELIMIT
PENDING_DELIMIT to CLOSING
CLOSING to IDLE
Successful [2], Failed [0]
INTU - notes
• The received service key is checked to determine if it matches a
pre-set value
• If the key matches, the service logic performs a number
translation (from one known number to another) on receipt of the
DELIMIT.
• If the called party address is not recognised, a ReleaseCall will
be sent.
ITU-T IN specifications
Principles
Q.1201
Service
plane
Q.1202
Global
Distributed
Functional Functional
Plane
Plane
Q.1203
Q.1204
Physical
Plane
Q.1205
General
Aspects
Q.1208
Vocabulary
of terms
Q.1290
INCM
Structure
Q.1200
CS-1
Structure Introduction
Q.1210
Q.1201
CS-1
GFP
Q.1213
CS-1
DFP
Q.1214
CS-1
PP
Q.1205
General
Aspects
Q.1218
User
Guide
Q.1219
CS-2
Structure Introduction
Q.1220
Q.1221
CS-2 Service CS-2
plane
GFP
Q.1221
Q.1223
CS-2
DFP
Q.1224
CS-2
PP
Q.1225
General
Aspects
Q.1228
User
Guide
Q.1229
ETSI IN specifications
ETS 300-374-1 ETSI Core INAP Part 1
ETS 300-374-2 ETSI Core INAP Part 2
ETS 300-374-3 ETSI Core INAP Part 3
Further reading
• ITU-T Q.1219
• ‘The Intelligent Network’ Uyless Black, ISBN0-13-793019-4,
Prentice Hall.
• ‘The Intelligent network Standards, Their Application to Services’
Igor Faynberg, Lawrence R. Gabuzda, Marc P. Kaplan, Nitin J.
Shah ISBN 0-07-021422-0 McGraw-Hill
• DataKinetics INAP Programmer’s Manual