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
800
Special translation
‘800’ SSP database
exchange

800 number is
Network routes call translated and
(signalling and forward routed to
voice) to special free destination
phone exchange/
server
Caller dials free-
phone 800 number
1-800-1234567 SSP SSP
PSTN

Local Local
exchange exchange

1-755-997612
 Classic IN physical Architecture
Service Control Point
Control and database SCEP/
functions SMP
Intelligent Peripheral 5
Play-back X.2
announcements Service Creation Environment
SS7 SCP Point/
Service Management Point
IP SS
7
Service administration
SS

PSTN
7

SSP SS7 SSP

Service Switching
Point - physical
circuit switching
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 SCP

call be processed?

IP 4 Announcement 3 & 6. Instructions

1. Off hook and dial SS7 Network

number
SSP SSP

7. Call progressed
through to destination
Freephone service Example

SSP

SCP Multiple
destinations

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 SCP

INAP INAP INAP

ISUP TCAP ISUP TCAP TCAP

SCCP SCCP SCCP

MTP MTP 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

TC User 1.

1. Single Components (primitives)

Component 2. Collect Components
2.
Sublayer 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 Service feature

Q.1212
Service
One number Plane
(Not defined!)
Reverse charging

Global
Translate Screen
Q.1213 Functional
Basic call
process Charging
Plane

SIB
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 Continue with existing data
Address collected Proceed with new data
Address analysed Handle as transit
Call arrival Clear call
Busy Provide call party handling
No Answer Initiate call
Call acceptance
Active state
End of call
 Freephone modeling with CS-1 SIBs
Charge_1 Charge_2
Translate (Calling free (Record for Translate Translat UI
of charge) subscriber) e
SIB Chain 1 SIB SIB SIB
Chain 2 Chain 3 Chain 4

POI POR POI POR POI POR POI POR

Address Proceed Busy Proceed No AnswerProceedNo Answer Clear
Analyzed with new with new with new Call
data data data
BCP
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)

Global
Q.1213 POI SIB n Functional
Basic call Plane
process SIB n
POR

BCM SCF
Distributed
Q.1214 SSF SDF
Functional
Plane
CCF 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 SCF SRF SDF

Authenticate
Algorithm
Charge
Compare
Distribution
Limit
Log Call Information
Queue
Screen
Service Data Mgt
Status Notification
Translate
User Interaction
Verify
Basic Call Process
 DFP and the Physical Plane

Distributed
SCF
Q.1214
Functional
SRF
SDF
Plane
SSF

Functional Entity

SCP Physical
Q.1215 Plane
SDF SSP IP

INAP
Communication
CS1 physical FE distribution
SCP SMAF
SCF
Voice Transport SMF
Signaling IP SDF
SCEF
Optional FE
SMP
SRF SDF

SDP
SN

SCF SRF
SSF SCF
SSF
CCF
CCF
SDF
CCAF SDF
SRF

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 SSF/

SSF/
CCF
SRF
(DSS1 or ISUP) CCF
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-In-
Call (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
1. O_Null & Authorise
10 Origination_Attempt 6. O_Exception

Orig_attempt
Authorised 1
Point in Call (PIC) 2. Collect_info

Collected_info 2
Detection Point (DP)
3. Analyse_info
Route_select_failure
4
Analysed _info 3 O_Called_party_busy
4. Routing_&_alerting 5
O_No_Answer

O_Answer 7 6

9 5. O_Active
O_Disconnect 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
18 termination attempt 11. T_Exception

Term_attempt
Authorised 12 T_Called_Party_busy
Point in Call (PIC) 8. Select Facility &
13
Present Call

Detection Point (DP) T_No_Answer

9. T_Alerting 14

T_Answer
15
17 10. T_Active 16 T_Mid_call

T_Disconnect
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 SCF SDF

TDP-R Initial DP: fph, 0-800-xxxxxx
2 TC-BEGIN

Analyse_info Connect: call, id = xxxxx

Req BCSM event:
O_Answer, O_Disconn
3 TC-CONTINUE
Route_&_Alert
Event: call, id = xxxxx
EDP-N BCSM O_Answer, time
7 TC-CONTINUE

O_Active Event: call, id = xxxxx

BCSM O_Disconnect, time
9 TC-CONTINUE
EDP-N
TC-END
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 sub-system number = 0x0a

module_id = 0x1d FE identifier = 1
FE identifier = 5

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 Usage

Invoke an operation at a remote FE or respond

INAP-SERVICE-REQ 0xc7f0
to a invocation received from a remote FE
Receive results or errors from operations
INAP-SERVICE-IND 0x87f1
invoked at a remote FE

INAP_DIALOGUE_REQ 0xc7f2 Issue dialogue command

INAP_DIALOGUE-IND 0x87f3 Receive dialogue event

INAP_MSG_DLG_REQ

MESSAGE HEADER

FIELD NAME MEANING

INAP
Programmers
type INAP_MSG_DLG_REQ (0xc7f2)
id dialogue_ID
Manual details
src Sending module_id other message
dst INAP_MODULE_ID specifications
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.
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 INAP-
OPEN-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

D
The INAP Programmers E
L U
Manual defines the C
I
M
-
A
O L I B O
parameters and which are P O T O P
E S E R E
required with each N
-
E
–
R
-
T
-
N
-
primitive type Parameter
R
E
R
E
R
E
R
E
R
S
Q Q Q Q P
Destination address A
M Mandatory Originating address B
O Optional
Destination reference A
Originating reference B
A Exclusive OR
Result M
B Exclusive OR
Refuse reason O
C Conditional
Release method M
User reason M
Application context name O O O O O
Application context index C 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 R R
N E E E
V S R J
O U R E
K L O C
E T R T
- - - -
R R R R
E E E E
Q Q Q 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
/*
* Basic BCP DP ASE (ITU Q.1218 only)
*/
#define INOP_OriginationAttemptAuthorized (1) /* (ITU Q.1218 only) */
#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
(0) See in_inc.h
(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) */

/*
* 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 Parameters are detailed

in the INAP Programmer’s
IN_init_component 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
2. Component
Encoding Functions
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 3. Read Component

Buffer Functions

2. Decode Service
Indication Functions

MSG
De-code service indication

IN_get_component_type Obtain received component type

IN_decode_operation Decode the operation parameter
IN_decode_result Decode a result
IN_decode_error Decode an error component
Read component buffer

IN_get_component_type Return the type of the received component

IN_get_component_first_error Determine the first error encountered during
encoding
IN_get_operation Get received operation code
IN_get_component_param 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) TC-CONTINUE N-UNITDATA-IND

INAP_SRV_IND (INVOKE) TC-INVOKE

INAP_DLG_IND (DELIMIT)

INAP_DLG_IND (CLOSE) TC-END

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) TC-END (pre-arranged)

(pre-arranged end)
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: State change for dialogue 0x8000 from IDLE to OPEN

INTU: Dialogues: Active [1], Completed [0], Successful [0], Failed [0]
INTU: State change for dialogue 0x8000 from OPEN to PENDING_DELIMIT
INTU: State change for dialogue 0x8000 from PENDING_DELIMIT to CLOSING
INTU: State change for dialogue 0x8000 from CLOSING to IDLE
INTU: Dialogues: Active [0], Completed [1], Successful [1], Failed [0]
INTU: State change for dialogue 0x8001 from IDLE to OPEN
INTU: Dialogues: Active [1], Completed [1], Successful [1], Failed [0]
INTU: State change for dialogue 0x8001 from OPEN to PENDING_DELIMIT
INTU: State change for dialogue 0x8001 from PENDING_DELIMIT to CLOSING
INTU: State change for dialogue 0x8001 from CLOSING to IDLE
INTU: Dialogues: Active [0], Completed [2], 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

Global Distributed
Service Physical General Vocabulary
INCM Structure Principles Functional Functional
plane Plane Aspects of terms
Q.1200 Q.1201 Plane Plane
Q.1202 Q.1205 Q.1208 Q.1290
Q.1203 Q.1204

CS-1 CS-1 CS-1 General User

CS-1 Structure Introduction
GFP DFP PP Aspects Guide
Q.1210 Q.1201
Q.1213 Q.1214 Q.1205 Q.1218 Q.1219

CS-2 Service CS-2 CS-2 CS-2 General User

CS-2 Structure Introduction
plane GFP DFP PP Aspects Guide
Q.1220 Q.1221
Q.1221 Q.1223 Q.1224 Q.1225 Q.1228 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