retronetworking
/
yate
12
0
Fork 2
Code Issues Pull Requests Projects Releases Wiki Activity
yate/libs/ysig/isup.cpp

6273 lines
209 KiB
C++
Raw Blame History

/**
* isup.cpp
* This file is part of the YATE Project http://YATE.null.ro
*
* Yet Another Signalling Stack - implements the support for SS7, ISDN and PSTN
*
* Yet Another Telephony Engine - a fully featured software PBX and IVR
* Copyright (C) 2004-2014 Null Team
*
* This software is distributed under multiple licenses;
* see the COPYING file in the main directory for licensing
* information for this specific distribution.
*
* This use of this software may be subject to additional restrictions.
* See the LEGAL file in the main directory for details.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
#include "yatesig.h"
#include <yatephone.h>
#include <string.h>
using namespace TelEngine;
#ifdef DEBUG
#define ISUP_HANDLE_CIC_EVENT_CONTROL
#else
//#define ISUP_HANDLE_CIC_EVENT_CONTROL
#endif
// Maximum number of mandatory parameters including two terminators
#define MAX_MANDATORY_PARAMS 16
// Timer limits and default values
#define ISUP_T7_MINVAL 20000
#define ISUP_T7_DEFVAL 20000
#define ISUP_T7_MAXVAL 30000
#define ISUP_T9_MINVAL 90000
#define ISUP_T9_DEFVAL 0
#define ISUP_T9_MAXVAL 180000
#define ISUP_T27_MINVAL 30000
#define ISUP_T27_DEFVAL 240000
#define ISUP_T27_MAXVAL 300000
#define ISUP_T34_MINVAL 2000
#define ISUP_T34_DEFVAL 3000
#define ISUP_T34_MAXVAL 4000
// Utility: check if 2 cic codes are in valid range, return range if valid, 0 otherwise
static inline int checkValidRange(int code, int extra)
{
int range = extra - code;
return (range > -256 && range < 256) ? range : 0;
}
// Adjust range and status data when needed (a new range is used)
static void adjustRangeAndStatus(char* status, unsigned int& code, unsigned int& range,
int newRange)
{
if (!(status && newRange))
return;
if (newRange > 0) {
range = (unsigned int)newRange;
status[0] = '1';
::memset(status + 1,'0',range);
}
else {
range = (unsigned int)(-newRange);
code -= range;
::memset(status,'0',range);
status[range] = '1';
}
range++;
}
// Description of each ISUP parameter
struct IsupParam {
// numeric type of the parameter
SS7MsgISUP::Parameters type;
// size in octets, zero for variable
unsigned char size;
// SS7 name of the parameter
const char* name;
// decoder callback function
bool (*decoder)(const SS7ISUP*,NamedList&,const IsupParam*,
const unsigned char*,unsigned int,const String&);
// encoder callback function
unsigned char (*encoder)(const SS7ISUP*,SS7MSU&,unsigned char*,
const IsupParam*,const NamedString*,const NamedList*,const String&);
// table data to be used by the callback
const void* data;
};
// This structure describes parameters of each ISUP message for each dialect
struct MsgParams {
// type of the message described
SS7MsgISUP::Type type;
// does the message support optional part?
bool optional;
// parameters, fixed then variable, separated/terminated by EndOfParameters
// using an array is a (moderate) waste of space
const SS7MsgISUP::Parameters params[MAX_MANDATORY_PARAMS];
};
// Nature of Address Indicator
static const TokenDict s_dict_nai[] = {
{ "subscriber", 1 },
{ "unknown", 2 },
{ "national", 3 },
{ "international", 4 },
{ "network-specific", 5 },
{ "national-routing", 6 },
{ "specific-routing", 7 },
{ "routing-with-cdn", 8 },
{ 0, 0 }
};
// Numbering Plan Indicator
static const TokenDict s_dict_numPlan[] = {
{ "unknown", 0 },
{ "isdn", 1 },
{ "data", 3 },
{ "telex", 4 },
{ "private", 5 },
{ "national", 6 },
{ 0, 0 }
};
// Address Presentation
static const TokenDict s_dict_presentation[] = {
{ "allowed", 0 },
{ "restricted", 1 },
{ "unavailable", 2 },
// aliases for restrict=...
{ "no", 0 },
{ "false", 0 },
{ "yes", 1 },
{ "true", 1 },
{ 0, 0 }
};
// Screening Indicator
static const TokenDict s_dict_screening[] = {
{ "user-provided", 0 },
{ "user-provided-passed", 1 },
{ "user-provided-failed", 2 },
{ "network-provided", 3 },
// aliases for screened=...
{ "no", 0 },
{ "false", 0 },
{ "yes", 1 },
{ "true", 1 },
{ 0, 0 }
};
// Generic number qualifier
static const TokenDict s_dict_qual[] = {
{ "dialed-digits", 0 },
{ "called-additional", 1 },
{ "caller-failed", 2 },
{ "caller-not-screened", 3 },
{ "terminating", 4 },
{ "connected-additional", 5 },
{ "caller-additional", 6 },
{ "called-original", 7 },
{ "redirecting", 8 },
{ "redirection", 9 },
{ 0, 0 }
};
// Generic name qualifier
static const TokenDict s_dict_qual_name[] = {
{ "caller" , 0x20 },
{ "called" , 0x40 },
{ "redirecting" , 0x60 },
{ "connected" , 0x80 },
{ 0, 0 }
};
// Redirection Information (Q,763 3.45) bits CBA
static const TokenDict s_dict_redir_main[] = {
{ "none", 0 },
{ "rerouted", 1 },
{ "rerouted-restrict-all", 2 },
{ "diverted", 3 },
{ "diverted-restrict-all", 4 },
{ "rerouted-restrict-number", 5 },
{ "diverted-restrict-number", 6 },
{ 0, 0 }
};
// Redirection Information (Q,763 3.45) bits HGFE or PONM
static const TokenDict s_dict_redir_reason[] = {
{ "busy", 1 },
{ "noanswer", 2 },
{ "always", 3 },
{ "deflected", 4 },
{ "diverted", 5 },
{ "offline", 6 },
{ 0, 0 }
};
// Message Compatibility Information (Q.763 3.33)
static const SignallingFlags s_flags_msgcompat[] = {
{ 0x01, 0x00, "transit" }, // End node / transit exchange
{ 0x01, 0x01, "end-node" },
{ 0x02, 0x02, "release" }, // Release call indicator
{ 0x04, 0x04, "cnf" }, // Pass on set but not possible: Send CNF / RLC
{ 0x08, 0x08, "discard" }, // Discard / pass on message
{ 0x10, 0x00, "nopass-release" }, // Pass on not possible: Release call
{ 0x10, 0x10, "nopass-discard" }, // Pass on not possible: Discard message
{ 0, 0, 0 }
};
// Parameter Compatibility Information (Q.763 3.41)
static const SignallingFlags s_flags_paramcompat[] = {
{ 0x01, 0x00, "transit" }, // End node / transit exchange
{ 0x01, 0x01, "end-node" },
{ 0x02, 0x02, "release" }, // Release call indicator
{ 0x04, 0x04, "cnf" }, // Parameter pass on set but not possible: Send CNF / RLC
{ 0x08, 0x08, "discard-msg" }, // Discard / pass on message
{ 0x18, 0x10, "discard-param" }, // Discard / pass on parameter (if not discarding message)
{ 0x60, 0x00, "nopass-release" }, // No pass on: release call
{ 0x60, 0x20, "nopass-msg" }, // No pass on: discard message
{ 0x60, 0x40, "nopass-param" }, // No pass on: discard parameter
{ 0x60, 0x60, "nopass-release" }, // Reserved, interpreted as 00
{ 0, 0, 0 }
};
// Application Transport Parameter instruction indicators (Q.763 3.82)
static const SignallingFlags s_flags_apt_indicators[] = {
{ 0x01, 0x01, "release" }, // Release call indicator
{ 0x02, 0x02, "cnf" }, // Send CNF notification
{ 0, 0, 0 }
};
// SLS special values on outbound calls
static const TokenDict s_dict_callSls[] = {
{ "auto", SS7ISUP::SlsAuto }, // Let Layer3 deal with it
{ "last", SS7ISUP::SlsLatest }, // Last SLS used
{ "cic", SS7ISUP::SlsCircuit }, // Lower bits of CIC
{ 0, 0 }
};
// Control operations
static const TokenDict s_dict_control[] = {
{ "validate", SS7MsgISUP::CVT },
{ "query", SS7MsgISUP::CQM },
{ "conttest", SS7MsgISUP::CCR },
{ "reset", SS7MsgISUP::RSC },
{ "block", SS7MsgISUP::BLK },
{ "unblock", SS7MsgISUP::UBL },
{ "release", SS7MsgISUP::RLC },
{ "parttest", SS7MsgISUP::UPT },
{ "available", SS7MsgISUP::UPA },
{ "save", SS7MsgISUP::CtrlSave },
#ifdef ISUP_HANDLE_CIC_EVENT_CONTROL
{ "circuitevent", SS7MsgISUP::CtrlCicEvent },
#endif
{ 0, 0 }
};
static const TokenDict s_dict_CRG_process[] = {
{ "confusion", SS7ISUP::Confusion },
{ "ignore", SS7ISUP::Ignore },
{ "raw", SS7ISUP::Raw },
{ "parsed", SS7ISUP::Parsed },
{ 0, 0 }
};
// Build next available parameter name
static void buildName(const NamedList& list, const IsupParam* param, const String& prefix, String& name)
{
name = prefix + param->name;
if (!list.getParam(name))
return;
// conflict - find a free index
for (unsigned int i = 1; ; i++) {
String tmp(name);
tmp << "." << i;
if (!list.getParam(tmp)) {
name = tmp;
break;
}
}
}
// Default decoder, dumps raw octets
static bool decodeRaw(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (len < 1)
return false;
String raw;
raw.hexify((void*)buf,len,' ');
DDebug(isup,DebugInfo,"decodeRaw decoded %s=%s",param->name,raw.c_str());
String preName;
buildName(list,param,prefix,preName);
list.addParam(preName,raw);
return true;
}
// Raw decoder for unknown/failed parameter, dumps raw octets
static bool decodeRawParam(const SS7ISUP* isup, NamedList& list, unsigned char value,
const unsigned char* buf, unsigned int len, const String& prefix)
{
String name("Param_");
name << value;
IsupParam p;
p.type = (SS7MsgISUP::Parameters)value;
p.size = len;
p.name = name;
p.decoder = 0;
p.encoder = 0;
p.data = 0;
return decodeRaw(isup,list,&p,buf,len,prefix);
};
// Integer decoder, interprets data as big endian integer
static bool decodeInt(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
unsigned int val = 0;
while (len--)
val = (val << 8) | (unsigned int)(*buf++);
DDebug(isup,DebugAll,"decodeInt decoded %s=%s (%u)",param->name,lookup(val,(const TokenDict*)param->data),val);
String preName;
buildName(list,param,prefix,preName);
SignallingUtils::addKeyword(list,preName,(const TokenDict*)param->data,val);
return true;
}
// Decoder for ISUP indicators (flags)
static bool decodeFlags(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
const SignallingFlags* flags = (const SignallingFlags*)param->data;
if (!flags)
return false;
String preName;
buildName(list,param,prefix,preName);
return SignallingUtils::decodeFlags(isup,list,preName,flags,buf,len);
}
// Utility function - extract just ISUP digits from a parameter
static void getDigits(String& num, unsigned char oddNum, const unsigned char* buf, unsigned int len,
bool ignoreUnk)
{
bool odd = (oddNum & 0x80) != 0;
static const char digits1[] = "0123456789\0BC\0\0.";
static const char digits2[] = "0123456789ABCDE.";
const char* digits = ignoreUnk ? digits1 : digits2;
for (unsigned int i = 0; i < len; i++) {
num += digits[buf[i] & 0x0f];
if (odd && ((i+1) == len))
break;
num += digits[buf[i] >> 4];
}
}
const char* getIsupParamName(unsigned char type);
// Decoder for message or parameter compatibility
// Q.763 3.33/3.41
static bool decodeCompat(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (!len)
return false;
String preName;
buildName(list,param,prefix,preName);
switch (param->type) {
case SS7MsgISUP::MessageCompatInformation:
SignallingUtils::decodeFlags(isup,list,preName,s_flags_msgcompat,buf,1);
if (buf[0] & 0x80) {
if (len == 1)
return true;
DDebug(isup,DebugMild,
"decodeCompat invalid len=%u for %s with first byte having ext bit set",len,param->name);
break;
}
return 0 != SignallingUtils::dumpDataExt(isup,list,preName+".more",buf+1,len-1);
case SS7MsgISUP::ParameterCompatInformation:
for (unsigned int i = 0; i < len;) {
unsigned char val = buf[i++];
if (i == len) {
Debug(isup,DebugMild,"decodeCompat unexpected end of data (len=%u) for %s",len,param->name);
return false;
}
const char* paramName = getIsupParamName(val);
String name = preName;
if (paramName)
name << "." << paramName;
else {
Debug(isup,DebugMild,"decodeCompat found unknown parameter %u for %s",val,param->name);
name << "." << (unsigned int)val;
}
SignallingUtils::decodeFlags(isup,list,name,s_flags_paramcompat,buf+i,1);
if (buf[i++] & 0x80)
continue;
unsigned int count = SignallingUtils::dumpDataExt(isup,list,name+".more",buf+i,len-i);
if (!count)
return false;
i += count;
}
decodeRaw(isup,list,param,buf,len,prefix);
return true;
default:
Debug(isup,DebugStub,"decodeCompat not implemented for %s",param->name);
}
return false;
}
// Decoder for various ISUP digit sequences (phone numbers)
static bool decodeDigits(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (len < 2)
return false;
unsigned char qualifier = 0;
if (SS7MsgISUP::GenericNumber == param->type) {
if (--len < 2)
return false;
qualifier = buf[0];
buf++;
}
unsigned char nai = buf[0] & 0x7f;
unsigned char plan = (buf[1] >> 4) & 7;
unsigned char pres = (buf[1] >> 2) & 3;
unsigned char scrn = buf[1] & 3;
String tmp;
getDigits(tmp,buf[0],buf+2,len-2,isup && isup->ignoreUnknownAddrSignals());
DDebug(isup,DebugAll,"decodeDigits decoded %s='%s' inn/ni=%u nai=%u plan=%u pres=%u scrn=%u",
param->name,tmp.c_str(),buf[1] >> 7,nai,plan,pres,scrn);
String preName;
buildName(list,param,prefix,preName);
list.addParam(preName,tmp);
if (SS7MsgISUP::GenericNumber == param->type)
SignallingUtils::addKeyword(list,preName+".qualifier",s_dict_qual,qualifier);
SignallingUtils::addKeyword(list,preName+".nature",s_dict_nai,nai);
SignallingUtils::addKeyword(list,preName+".plan",s_dict_numPlan,plan);
switch (param->type) {
case SS7MsgISUP::CalledPartyNumber:
case SS7MsgISUP::RedirectionNumber:
case SS7MsgISUP::LocationNumber:
tmp = ((buf[1] & 0x80) == 0);
list.addParam(preName+".inn",tmp);
break;
case SS7MsgISUP::CallingPartyNumber:
case SS7MsgISUP::GenericNumber:
tmp = ((buf[1] & 0x80) == 0);
list.addParam(preName+".complete",tmp);
break;
case SS7MsgISUP::LastDivertingLineIdentity:
case SS7MsgISUP::PresentationNumber:
tmp = ((buf[1] & 0x80) != 0);
list.addParam(preName+".pnp",tmp);
break;
default:
break;
}
switch (param->type) {
case SS7MsgISUP::CallingPartyNumber:
case SS7MsgISUP::RedirectingNumber:
case SS7MsgISUP::OriginalCalledNumber:
case SS7MsgISUP::LocationNumber:
case SS7MsgISUP::ConnectedNumber:
case SS7MsgISUP::GenericNumber:
case SS7MsgISUP::LastDivertingLineIdentity:
case SS7MsgISUP::PresentationNumber:
case SS7MsgISUP::CalledINNumber:
case SS7MsgISUP::OriginalCalledINNumber:
SignallingUtils::addKeyword(list,preName+".restrict",s_dict_presentation,pres);
default:
break;
}
switch (param->type) {
case SS7MsgISUP::CallingPartyNumber:
case SS7MsgISUP::LocationNumber:
case SS7MsgISUP::ConnectedNumber:
case SS7MsgISUP::GenericNumber:
case SS7MsgISUP::LastDivertingLineIdentity:
case SS7MsgISUP::PresentationNumber:
SignallingUtils::addKeyword(list,preName+".screened",s_dict_screening,scrn);
default:
break;
}
return true;
}
// Special decoder for subsequent number
static bool decodeSubseq(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (len < 1)
return false;
String tmp;
getDigits(tmp,buf[0],buf+1,len-1,isup && isup->ignoreUnknownAddrSignals());
DDebug(isup,DebugAll,"decodeSubseq decoded %s='%s'",param->name,tmp.c_str());
String preName;
buildName(list,param,prefix,preName);
list.addParam(preName,tmp);
return true;
}
// Decoder for circuit group range and status (Q.763 3.43)
static bool decodeRangeSt(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (len < 1)
return false;
String preName;
buildName(list,param,prefix,preName);
// 1st octet is the range code (range - 1)
len--;
unsigned int range = 1 + *buf++;
unsigned int octets = (range + 7) / 8;
if (octets > len) {
if (len)
Debug(isup,DebugMild,"decodeRangeSt truncating range of %u bits to %u octets!",range,len);
octets = len;
}
list.addParam(preName,String(range));
String map;
if (len) {
unsigned char mask = 1;
unsigned int r = range;
while (r--) {
map += (buf[0] & mask) ? "1" : "0";
mask <<= 1;
if (!mask) {
++buf;
if (!--octets)
break;
mask = 1;
}
}
list.addParam(preName+".map",map);
}
DDebug(isup,DebugAll,"decodeRangeSt decoded %s=%u '%s'",param->name,range,map.c_str());
return true;
}
// Decoder for generic notification indicators (Q.763 3.25)
static bool decodeNotif(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (len < 1)
return false;
String flg;
for (; len; len--) {
unsigned char val = *buf++;
const char* keyword = lookup(val & 0x7f,(const TokenDict*)param->data);
if (keyword)
flg.append(keyword,",");
else {
String tmp(0x7f & (int)val);
flg.append(tmp,",");
}
if (val & 0x80)
break;
}
DDebug(isup,DebugAll,"decodeNotif decoded %s='%s'",param->name,flg.c_str());
String preName;
buildName(list,param,prefix,preName);
list.addParam(preName,flg);
return true;
}
// Decoder for User Service Information
static bool decodeUSI(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
String preName;
buildName(list,param,prefix,preName);
return SignallingUtils::decodeCaps(isup,list,buf,len,preName,true);
}
// Decoder for cause indicators
static bool decodeCause(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
String preName;
buildName(list,param,prefix,preName);
return SignallingUtils::decodeCause(isup,list,buf,len,preName,true);
}
// Decoder for application transport parameter
static bool decodeAPT(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (len < 4) {
if (len == 3)
Debug(isup,DebugNote,"Received '%s' with no data",param->name);
return false;
}
// Field extension on more then 1 octet is not supported
if (0 == (buf[0] & buf[1] & buf[2] & 0x80)) {
Debug(isup,DebugNote,"Received %s with unsupported extension bits set to 0",
param->name);
return false;
}
// Segmentation is not supported
unsigned char si = (buf[2] & 0x40);
unsigned char segments = (buf[2] & 0x3f);
if (!si || segments) {
Debug(isup,DebugNote,"Received unsupported segmented %s (si=%u segments=%u)",
param->name,si,segments);
return false;
}
len -= 3;
// WARNING: HACK - ApplicationTransport does not follow naming convention
String preName(prefix + param->name);
String context((int)(buf[0] & 0x7f));
list.addParam(preName,context);
preName << "." << context;
// Application context identifier
SignallingUtils::dumpData(isup,list,preName,buf + 3,len);
// Instruction indicators
unsigned char inds = (buf[1] & 0x7f);
SignallingUtils::decodeFlags(isup,list,preName + ".indicators",s_flags_apt_indicators,&inds,1);
return true;
}
// Decoder for generic name
static bool decodeName(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (len < 1)
return false;
String val((const char*)buf+1,len-1);
String preName;
buildName(list,param,prefix,preName);
list.addParam(preName,val);
list.addParam(preName+".available",String::boolText((buf[0] & 0x10) == 0));
SignallingUtils::addKeyword(list,preName+".qualifier",s_dict_qual_name,buf[0] & 0xe0);
SignallingUtils::addKeyword(list,preName+".restrict",s_dict_presentation,buf[0] & 0x03);
DDebug(isup,DebugAll,"decodeName decoded %s='%s'",param->name,val.c_str());
return true;
}
// Decoder for Redirection information (Q.763 3.45)
static bool decodeRedir(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
if (len < 1)
return false;
String preName;
buildName(list,param,prefix,preName);
SignallingUtils::addKeyword(list,preName,s_dict_redir_main,buf[0] & 0x07);
unsigned int reason = buf[0] >> 4;
if (reason)
SignallingUtils::addKeyword(list,preName+".reason_original",s_dict_redir_reason,reason);
if (len > 1) {
int cnt = buf[1] & 0x07;
if (cnt)
list.addParam(preName+".counter",String(cnt));
reason = buf[1] >> 4;
if (reason)
SignallingUtils::addKeyword(list,preName+".reason",s_dict_redir_reason,reason);
}
return true;
}
// Default encoder, get hexified octets
static unsigned char encodeRaw(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList*, const String&)
{
if (!(param && val))
return 0;
DDebug(isup,DebugInfo,"encodeRaw encoding %s=%s",param->name,val->c_str());
DataBlock raw;
if (!raw.unHexify(val->c_str(),val->length(),' ')) {
DDebug(isup,DebugMild,"encodeRaw failed: invalid string");
return 0;
}
if (!raw.length() || raw.length() > 254 ||
(param->size && param->size != raw.length())) {
DDebug(isup,DebugMild,"encodeRaw failed: param size=%u data length=%u",
param->size,raw.length());
return 0;
}
if (buf) {
::memcpy(buf,raw.data(),raw.length());
return raw.length();
}
unsigned char size = (unsigned char)raw.length();
msu.append(&size,1);
msu += raw;
return size;
}
// Encoder for fixed length ISUP indicators (flags)
static unsigned char encodeFlags(const SS7ISUP* isup, SS7MSU& msu, unsigned char* buf,
const IsupParam* param, const NamedString* val, const NamedList*, const String&)
{
if (!param)
return 0;
unsigned int n = param->size;
if (!(n && param->data))
return 0;
unsigned int v = 0;
if (val)
v = SignallingUtils::encodeFlags(isup,*val,(const SignallingFlags*)param->data,param->name);
else {
// locate the defaults
const SignallingFlags* flags = (const SignallingFlags*)param->data;
while (flags->mask)
flags++;
v = flags->value;
}
DDebug(isup,DebugAll,"encodeFlags encoding %s=0x%x on %u octets",param->name,v,n);
if (!buf) {
unsigned int l = msu.length();
DataBlock dummy(0,n+1);
msu += dummy;
buf = (unsigned char*)msu.getData(l,n+1);
*buf++ = n & 0xff;
}
while (n--) {
*buf++ = v & 0xff;
v >>= 8;
}
return param->size;
}
// Encoder for fixed length big-endian integer values
static unsigned char encodeInt(const SS7ISUP* isup, SS7MSU& msu, unsigned char* buf,
const IsupParam* param, const NamedString* val, const NamedList*, const String&)
{
if (!param)
return 0;
unsigned int n = param->size;
if (!n)
return 0;
unsigned int v = 0;
if (val)
v = val->toInteger((const TokenDict*)param->data);
DDebug(isup,DebugAll,"encodeInt encoding %s=%u on %u octets",param->name,v,n);
if (!buf) {
unsigned int l = msu.length();
DataBlock dummy(0,n+1);
msu += dummy;
buf = (unsigned char*)msu.getData(l,n+1);
*buf++ = n & 0xff;
}
buf += n;
while (n--) {
*(--buf) = v & 0xff;
v >>= 8;
}
return param->size;
}
// Utility function - write digit sequences
static unsigned char setDigits(SS7MSU& msu, const char* val, unsigned char nai, int b2 = -1, int b3 = -1, int b0 = -1)
{
unsigned char buf[32];
unsigned int len = 1;
if (b0 >= 0)
buf[len++] = b0 & 0xff;
unsigned int naiPos = len++;
buf[naiPos] = nai & 0x7f;
if (b2 >= 0) {
buf[len++] = b2 & 0xff;
if (b3 >= 0)
buf[len++] = b3 & 0xff;
}
bool odd = false;
while (val && (len < sizeof(buf))) {
char c = *val++;
if (!c)
break;
unsigned char n = 0;
if (('0' <= c) && (c <= '9'))
n = c - '0';
else if ('.' == c)
n = 15;
else if ('A' == c)
n = 10;
else if ('B' == c)
n = 11;
else if ('C' == c)
n = 12;
else if ('D' == c)
n = 13;
else if ('E' == c)
n = 14;
else
continue;
odd = !odd;
if (odd)
buf[len] = n;
else
buf[len++] |= (n << 4);
}
if (odd) {
buf[naiPos] |= 0x80;
len++;
}
buf[0] = (len-1) & 0xff;
DDebug(DebugAll,"setDigits encoding %u octets (%s)",len,odd ? "odd" : "even");
DataBlock tmp(buf,len,false);
msu += tmp;
tmp.clear(false);
return buf[0];
}
// Encoder for variable length digit sequences
static unsigned char encodeDigits(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList* extra, const String& prefix)
{
if (!param || buf || param->size)
return 0;
unsigned char nai = 2;
unsigned char plan = 1;
String preName;
if (val)
preName = val->name();
else
preName = prefix + param->name;
int b0 = -1;
if (SS7MsgISUP::GenericNumber == param->type) {
b0 = 0;
if (val && extra)
b0 = 0xff & extra->getIntValue(preName+".qualifier",s_dict_qual,0);
}
if (val && extra) {
nai = extra->getIntValue(preName+".nature",s_dict_nai,nai);
plan = extra->getIntValue(preName+".plan",s_dict_numPlan,plan);
}
unsigned char b2 = (plan & 7) << 4;
switch (param->type) {
case SS7MsgISUP::CalledPartyNumber:
case SS7MsgISUP::RedirectionNumber:
case SS7MsgISUP::LocationNumber:
if (val && extra && !extra->getBoolValue(preName+".inn",true))
b2 |= 0x80;
break;
case SS7MsgISUP::CallingPartyNumber:
case SS7MsgISUP::GenericNumber:
if (val && extra && !extra->getBoolValue(preName+".complete",true))
b2 |= 0x80;
break;
case SS7MsgISUP::LastDivertingLineIdentity:
case SS7MsgISUP::PresentationNumber:
if (!val || !extra || extra->getBoolValue(preName+".pnp",true))
b2 |= 0x80;
break;
default:
break;
}
switch (param->type) {
case SS7MsgISUP::CallingPartyNumber:
case SS7MsgISUP::RedirectingNumber:
case SS7MsgISUP::OriginalCalledNumber:
case SS7MsgISUP::LocationNumber:
case SS7MsgISUP::ConnectedNumber:
case SS7MsgISUP::GenericNumber:
case SS7MsgISUP::LastDivertingLineIdentity:
case SS7MsgISUP::PresentationNumber:
case SS7MsgISUP::CalledINNumber:
case SS7MsgISUP::OriginalCalledINNumber:
if (val && extra)
b2 |= (extra->getIntValue(preName+".restrict",s_dict_presentation) & 3) << 2;
default:
break;
}
switch (param->type) {
case SS7MsgISUP::CallingPartyNumber:
case SS7MsgISUP::LocationNumber:
case SS7MsgISUP::ConnectedNumber:
case SS7MsgISUP::GenericNumber:
case SS7MsgISUP::LastDivertingLineIdentity:
case SS7MsgISUP::PresentationNumber:
if (val && extra)
b2 |= extra->getIntValue(preName+".screened",s_dict_screening) & 3;
default:
break;
}
return setDigits(msu,val ? val->c_str() : 0,nai,b2,-1,b0);
}
// Special encoder for subsequent number
static unsigned char encodeSubseq(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList*, const String&)
{
return setDigits(msu,val ? val->c_str() : 0,0);
}
// Encoder for circuit group range and status (Q.763 3.43)
static unsigned char encodeRangeSt(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList* extra, const String& prefix)
{
if (!(param && val))
return 0;
unsigned char data[34] = {1};
// 1st octet is the range code (range - 1)
// Q.763 3.43 Sent range value must be in interval 1..256
unsigned int range = val->toInteger(0);
if (range < 1 || range > 256) {
Debug(isup,DebugNote,"encodeRangeSt invalid range %s=%s",val->name().c_str(),val->safe());
return 0;
}
data[1] = range - 1;
// Next octets: status bits for the circuits given by range
NamedString* map = extra->getParam(prefix+param->name+".map");
if (map && map->length()) {
// Max status bits is 256. Relevant status bits: range
unsigned int nBits = map->length();
if (nBits > 256) {
Debug(isup,DebugNote,"encodeRangeSt truncating status bits %u to 256",map->length());
nBits = 256;
}
unsigned char* src = (unsigned char*)map->c_str();
unsigned char* dest = data + 1;
for (unsigned char crtBit = 0; nBits; nBits--, src++) {
if (!crtBit) {
data[0]++;
*++dest = 0;
}
if (*src != '0')
*dest |= (1 << crtBit);
crtBit = (crtBit < 7 ? crtBit + 1 : 0);
}
}
// Copy to msu
DDebug(isup,DebugAll,"encodeRangeSt encoding %s on %u octets",param->name,data[0]);
DataBlock tmp(data,data[0] + 1,false);
msu += tmp;
tmp.clear(false);
return data[0];
}
// Encoder for generic notification indicators (Q.763 3.25)
static unsigned char encodeNotif(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList*, const String&)
{
if (!(param && val) || buf || param->size)
return 0;
unsigned char notif[32];
unsigned int len = 0;
ObjList* lst = val->split(',',false);
ObjList* p = lst->skipNull();
for (; p; p = p->skipNext()) {
const String* s = static_cast<const String*>(p->get());
int v = s->toInteger((const TokenDict*)param->data,-1);
if (v < 0)
continue;
notif[++len] = v & 0x7f;
if (len >= sizeof(notif)-1)
break;
}
TelEngine::destruct(lst);
DDebug(isup,DebugAll,"encodeNotif encoding %s on %u octets",param->name,len);
if (!len)
return 0;
notif[len] |= 0x80;
notif[0] = len & 0xff;
DataBlock tmp(notif,len+1,false);
msu += tmp;
tmp.clear(false);
return notif[0];
}
// Encoder for User Service Information (Q.763 3.57, Q.931)
static unsigned char encodeUSI(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList* extra, const String& prefix)
{
if (!param)
return 0;
String preName;
if (val)
preName = val->name();
else
preName = prefix + param->name;
DataBlock tmp;
SignallingUtils::encodeCaps(isup,tmp,*extra,preName,true);
DDebug(isup,DebugAll,"encodeUSI encoding %s on %u octets",param->name,tmp.length());
if (tmp.length() < 1)
return 0;
msu += tmp;
return tmp.length() - 1;
}
// Encoder for cause indicators
static unsigned char encodeCause(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList* extra, const String& prefix)
{
if (!param)
return 0;
String preName;
if (val)
preName = val->name();
else
preName = prefix + param->name;
DataBlock tmp;
SignallingUtils::encodeCause(isup,tmp,*extra,preName,true);
DDebug(isup,DebugAll,"encodeCause encoding %s on %u octets",param->name,tmp.length());
if (tmp.length() < 1)
return 0;
msu += tmp;
return tmp.length() - 1;
}
// Encoder for application transport parameter
static unsigned char encodeAPT(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList* extra, const String& prefix)
{
if (!param)
return 0;
if (TelEngine::null(val)) {
if (val)
Debug(isup,DebugNote,"Failed to encode empty %s",val->name().c_str());
return 0;
}
int context = val->toInteger(-1);
if (context < 0 || context > 127) {
// Assume binary parameter representation
DataBlock data;
if (!(data.unHexify(val->c_str(),val->length(),' ') && data.length()) ||
data.length() < 4 || data.length() > 254) {
Debug(isup,DebugNote,"Failed to encode invalid %s=%s",
param->name,val->c_str());
return 0;
}
unsigned char len = data.length();
msu.append(&len,1);
msu += data;
return 1 + data.length();
}
// WARNING: HACK - ApplicationTransport does not follow naming convention
String preName(prefix + param->name);
preName << "." << context;
unsigned char hdr[4] = {0,(unsigned char)(0x80 | context),0x80,0xc0}; // c0: extension bit set, new sequence bit set
// Retrieve data. Make sure all bytes are correct and final length don't
// overflow our return value
DataBlock data;
const String& tmp = extra ? (*extra)[preName] : String::empty();
if (!(data.unHexify(tmp.c_str(),tmp.length(),' ') && data.length()) ||
data.length() > (255 - sizeof(hdr))) {
Debug(isup,DebugNote,"Failed to encode invalid %s=%s",
param->name,tmp.c_str());
return 0;
}
String indName(preName + ".indicators");
const String* inds = extra ? extra->getParam(indName) : 0;
if (inds) {
unsigned int v = SignallingUtils::encodeFlags(isup,*inds,s_flags_apt_indicators,indName);
hdr[2] |= (v & 0x7f);
}
else {
// Set default indicators value: send CNF, no call release
hdr[2] |= 0x02;
}
hdr[0] = data.length() + 3;
msu.append(hdr,sizeof(hdr));
msu += data;
return hdr[0];
}
// Encoder for Generic Name
static unsigned char encodeName(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList* extra, const String& prefix)
{
if (!(param && val) || buf || param->size)
return 0;
unsigned int len = val->length() + 1;
if (len >= 127)
return 0;
unsigned char gn[2] = { (unsigned char)len, 3 };
if (extra) {
String preName;
if (val)
preName = val->name();
else
preName = prefix + param->name;
if (!extra->getBoolValue(preName+".available",true))
gn[1] |= 0x10;
gn[1] = (gn[1] & 0x1f) |
(extra->getIntValue(preName+".qualifier",s_dict_qual_name,gn[1] & 0xe0) & 0xe0);
gn[1] = (gn[1] & 0xfc) |
(extra->getIntValue(preName+".restrict",s_dict_presentation,gn[1] & 0x03) & 0x03);
}
DataBlock tmp(gn,2);
tmp += *val;
DDebug(isup,DebugAll,"encodeName encoding %s on %u octets",param->name,tmp.length());
msu += tmp;
return len;
}
// Encoder for Redirection information (Q.763 3.45)
static unsigned char encodeRedir(const SS7ISUP* isup, SS7MSU& msu,
unsigned char* buf, const IsupParam* param, const NamedString* val,
const NamedList* extra, const String& prefix)
{
if (!(param && val) || buf || param->size)
return 0;
unsigned char ri[3] = { 2, 0, 0 };
if (extra) {
String preName;
if (val)
preName = val->name();
else
preName = prefix + param->name;
ri[1] = (extra->getIntValue(preName,s_dict_redir_main,0) & 0x07) |
((extra->getIntValue(preName+".reason_original",s_dict_redir_reason,0) & 0x0f) << 4);
ri[2] = (extra->getIntValue(preName+".counter") & 0x07) |
((extra->getIntValue(preName+".reason",s_dict_redir_reason,0) & 0x0f) << 4);
}
DataBlock tmp(ri,3,false);
msu += tmp;
tmp.clear(false);
return ri[0];
}
// Nature of Connection Indicators (Q.763 3.35)
static const SignallingFlags s_flags_naci[] = {
// TODO: add more flags
{ 0x03, 0x00, "0sat" },
{ 0x03, 0x01, "1sat" },
{ 0x03, 0x02, "2sat" },
{ 0x0c, 0x00, "cont-check-none" }, // Continuity check not required
{ 0x0c, 0x04, "cont-check-this" }, // Continuity check required on this circuit
{ 0x0c, 0x08, "cont-check-prev" }, // Continuity check performed on a previous circuit
{ 0x10, 0x10, "echodev" }, // Outgoing half echo control device included
{ 0, 0, 0 }
};
// Forward Call Indicators (Q.763 3.23)
static const SignallingFlags s_flags_fwcallind[] = {
{ 0x0001, 0x0000, "national" }, // National/international call indicator
{ 0x0001, 0x0001, "international" },
{ 0x0006, 0x0000, "e2e-none" }, // End-to-end method indicator (none available: only link-by-link)
{ 0x0006, 0x0002, "e2e-pass" }, // Pass along method available
{ 0x0006, 0x0004, "e2e-sccp" }, // SCCP along method available
{ 0x0006, 0x0006, "e2e-pass-sccp" }, // Pass along and SCCP method available
{ 0x0008, 0x0008, "interworking" }, // Interworking indicator (0: SS7 all the way)
{ 0x0010, 0x0010, "e2e-info" }, // End-to-end information available
{ 0x0020, 0x0020, "isup-path" }, // ISUP indicator (ISUP used all the way)
{ 0x00c0, 0x0000, "isup-pref" }, // ISUP preference indicator: preferred all the way
{ 0x00c0, 0x0040, "isup-notreq" }, // not required all the way
{ 0x00c0, 0x0080, "isup-req" }, // required all the way
{ 0x0100, 0x0100, "isdn-orig" }, // Originating from ISDN
{ 0x0600, 0x0000, "sccp-none" }, // SCCP method indicator: no indication
{ 0x0600, 0x0200, "sccp-less" }, // connectionless method available
{ 0x0600, 0x0400, "sccp-conn" }, // connection oriented method available
{ 0x0600, 0x0600, "sccp-less-conn" }, // connectionless and connection oriented methods available
{ 0x1000, 0x1000, "translated" }, // Number Translated (for portability)
{ 0x2000, 0x2000, "qor-routing" }, // QoR routing attempt in progress
{ 0, 0, 0 }
};
// Backward Call Indicators (Q.763 3.5)
static const SignallingFlags s_flags_bkcallind[] = {
{ 0x0003, 0x0001, "no-charge" }, // Charge indicator
{ 0x0003, 0x0002, "charge" },
{ 0x000c, 0x0004, "called-free" }, // Called party's status indicator: subscriber free
{ 0x000c, 0x0008, "called-conn" }, // Called party's status indicator: connect when free
{ 0x0030, 0x0010, "called-ordinary" }, // Called party's category indicator: ordinary subscriber
{ 0x0030, 0x0020, "called-payphone" }, // Called party's category indicator: payphone
{ 0x00c0, 0x0000, "e2e-none" }, // End-to-end method indicator (none available: only link-by-link)
{ 0x00c0, 0x0040, "e2e-pass" }, // Pass along method available
{ 0x00c0, 0x0080, "e2e-sccp" }, // SCCP along method available
{ 0x00c0, 0x00c0, "e2e-pass-sccp" }, // Pass along and SCCP method available
{ 0x0100, 0x0100, "interworking" }, // Interworking indicator (0: SS7 all the way)
{ 0x0200, 0x0200, "e2e-info" }, // End-to-end information available
{ 0x0400, 0x0400, "isup-path" }, // ISUP indicator (ISUP used all the way)
{ 0x0800, 0x0800, "hold-req" }, // Holding indicator: holding requested
{ 0x1000, 0x1000, "isdn-end" }, // Terminating in ISDN
{ 0x2000, 0x2000, "echodev" }, // Incoming half echo control device included
{ 0xc000, 0x0000, "sccp-none" }, // SCCP method indicator: no indication
{ 0xc000, 0x4000, "sccp-less" }, // connectionless method available
{ 0xc000, 0x8000, "sccp-conn" }, // connection oriented method available
{ 0xc000, 0xc000, "sccp-less-conn" }, // connectionless and connection oriented methods available
{ 0, 0, 0 }
};
// Call Diversion Information (Q.763 3.6)
static const SignallingFlags s_flags_calldivinfo[] = {
{ 0x07, 0x01, "presentation-not-allowed" },
{ 0x07, 0x02, "presentation-with-number" },
{ 0x07, 0x03, "presentation-without-number" },
{ 0x78, 0x08, "busy" },
{ 0x78, 0x10, "noanswer" },
{ 0x78, 0x18, "always" },
{ 0x78, 0x20, "deflected-alerting" },
{ 0x78, 0x28, "deflected-immediate" },
{ 0x78, 0x30, "offline" },
{ 0, 0, 0 }
};
// Optional Forward Call Indicators (Q.763 3.38)
static const SignallingFlags s_flags_optfwcallind[] = {
{ 0x03, 0x00, "non-CUG" },
{ 0x03, 0x02, "CUG+out" },
{ 0x03, 0x03, "CUG" },
{ 0x04, 0x04, "segmentation" }, // Additional info will be sent in a segmentation message
{ 0x80, 0x80, "CLIR-requested" },
{ 0, 0, 0 }
};
// Optional Backward Call Indicators (Q.763 3.37)
static const SignallingFlags s_flags_optbkcallind[] = {
{ 0x01, 0x01, "inband" },
{ 0x02, 0x02, "diversion-possible" },
{ 0x04, 0x04, "segmentation" }, // Additional info will be sent in a segmentation message
{ 0x08, 0x08, "MLPP-user" },
{ 0, 0, 0 }
};
// Event Information (Q.763 3.21)
static const SignallingFlags s_flags_eventinfo[] = {
{ 0x7f, 0x01, "ringing" },
{ 0x7f, 0x02, "progress" },
{ 0x7f, 0x03, "inband" },
{ 0x7f, 0x04, "forward-busy" },
{ 0x7f, 0x05, "forward-noanswer" },
{ 0x7f, 0x06, "forward-always" },
{ 0x80, 0x80, "restricted" },
{ 0, 0, 0 }
};
// Continuity Indicators (Q.763 3.18)
static const SignallingFlags s_flags_continuity[] = {
{ 0x01, 0x00, "failed" },
{ 0x01, 0x01, "success" },
{ 0, 0, 0 }
};
// Group Supervision Type Indicator (Q.763 3.13)
static const SignallingFlags s_flags_grptypeind[] = {
{ 0x03, 0x00, "maintenance" },
{ 0x03, 0x01, "hw-failure" },
{ 0x03, 0x02, "national" },
{ 0, 0, 0 }
};
// Access Delivery Information (Q.763 3.2)
static const SignallingFlags s_flags_accdelinfo[] = {
{ 0x01, 0x00, "setup-generated" }, // A Setup message was generated
{ 0x01, 0x01, "no-setup" }, // No Setup message generated
{ 0, 0, 0 }
};
// MCID Request or Response Indicators (Q.763 3.31 and 3.32)
static const SignallingFlags s_flags_mcid[] = {
{ 0x01, 0x01, "MCID" },
{ 0x02, 0x02, "holding" },
{ 0, 0, 0 }
};
// ANSI Circuit Validation Response Indicator
static const SignallingFlags s_flags_ansi_cvri[] = {
{ 0x03, 0x00, "failed" },
{ 0x03, 0x01, "success" },
{ 0, 0, 0 }
};
// ANSI Circuit Group Characteristics Indicator
static const SignallingFlags s_flags_ansi_cgci[] = {
{ 0x03, 0x00, "carrier-unknown" },
{ 0x03, 0x01, "carrier-analog" },
{ 0x03, 0x02, "carrier-digital" },
{ 0x03, 0x03, "carrier-mixed" },
{ 0x0c, 0x00, "seize-none" },
{ 0x0c, 0x04, "seize-odd" },
{ 0x0c, 0x08, "seize-even" },
{ 0x0c, 0x0c, "seize-all" },
{ 0x30, 0x00, "alarm-default" },
{ 0x30, 0x10, "alarm-software" },
{ 0x30, 0x20, "alarm-hardware" },
{ 0xc0, 0x00, "continuity-unknown" },
{ 0xc0, 0x40, "continuity-none" },
{ 0xc0, 0x80, "continuity-statistical" },
{ 0xc0, 0xc0, "continuity-call" },
{ 0, 0, 0 }
};
// National Forward Call Indicators (NICC ND 1007 2001 3.2.1)
static const SignallingFlags s_flags_nfci[] = {
{ 0x0001, 0x0000, "cli-blocked" }, // CLI Blocking Indicator (CBI)
{ 0x0001, 0x0001, "cli-allowed" },
{ 0x0002, 0x0002, "translated" }, // Network translated address indicator
{ 0x0004, 0x0004, "iup-priority" }, // Priority access indicator (IUP)
{ 0x0008, 0x0008, "iup-protected" }, // Protection indicator (IUP)
{ 0, 0, 0 }
};
// Calling Party Category (Q.763 3.11)
static const TokenDict s_dict_callerCat[] = {
{ "unknown", 0 }, // calling party's category is unknown
{ "operator-FR", 1 }, // operator, language French
{ "operator-EN", 2 }, // operator, language English
{ "operator-DE", 3 }, // operator, language German
{ "operator-RU", 4 }, // operator, language Russian
{ "operator-ES", 5 }, // operator, language Spanish
{ "ordinary", 10 }, // ordinary calling subscriber
{ "priority", 11 }, // calling subscriber with priority
{ "data", 12 }, // data call (voice band data)
{ "test", 13 }, // test call
{ "payphone", 15 }, // payphone
{ 0, 0 }
};
// Transmission Medium Requirement (Q.763 3.54)
static const TokenDict s_dict_mediumReq[] = {
{ "speech", 0 },
{ "64kbit", 2 },
{ "3.1khz-audio", 3 },
{ "64kb-preferred", 6 },
{ "2x64kbit", 7 },
{ "384kbit", 8 },
{ "1536kbit", 9 },
{ "1920kbit", 10 },
{ 0, 0 }
};
// Generic Notification Indicator (Q.763 3.25)
static const TokenDict s_dict_notifications[] = {
{ "user-suspended", 0x00 },
{ "user-resumed", 0x01 },
{ "bearer-service-change", 0x02 },
{ "call-completion-delay", 0x04 },
{ "conf-established", 0x42 },
{ "conf-disconnected", 0x43 },
{ "party-added", 0x44 },
{ "isolated", 0x45 },
{ "reattached", 0x46 },
{ "party-isolated", 0x47 },
{ "party-reattached", 0x48 },
{ "party-split", 0x49 },
{ "party-disconnected", 0x4a },
{ "conf-floating", 0x4b },
{ "call-waiting", 0x60 },
{ "call-diversion", 0x68 },
{ "call-transfer-alerting", 0x69 },
{ "call-transfer-active", 0x6a },
{ "remote-hold", 0x79 },
{ "remote-retrieval", 0x7a },
{ "call-diverting", 0x7b },
{ 0, 0 }
};
// Number Portability Forward Information (Q.763 3.101)
static const TokenDict s_dict_portability[] = {
{ "not-queried", 1 },
{ "called-not-ported", 2 },
{ "called-ported", 3 },
{ 0, 0 }
};
// ANSI Originating Line Info
static const TokenDict s_dict_oli[] = {
{ "normal", 0 },
{ "multiparty", 1 },
{ "ani-failure", 2 },
{ "hotel-room-id", 6 },
{ "coinless", 7 },
{ "restricted", 8 },
{ "test-call-1", 10 },
{ "aiod-listed-dn", 20 },
{ "identified-line", 23 },
{ "800-call", 24 },
{ "coin-line", 27 },
{ "restricted-hotel", 68 },
{ "test-call-2", 95 },
{ 0, 0 }
};
#define MAKE_PARAM(p,s,a,d,t) { SS7MsgISUP::p,s,#p,a,d,t }
static const IsupParam s_paramDefs[] = {
// name len decoder encoder table References
// Standard parameters, references to ITU Q.763
MAKE_PARAM(AccessDeliveryInformation, 1,decodeFlags, encodeFlags, s_flags_accdelinfo), // 3.2
MAKE_PARAM(AccessTransport, 0,0, 0, 0), // 3.3
MAKE_PARAM(AutomaticCongestionLevel, 1,decodeInt, encodeInt, 0), // 3.4
MAKE_PARAM(BackwardCallIndicators, 2,decodeFlags, encodeFlags, s_flags_bkcallind), // 3.5
MAKE_PARAM(CallDiversionInformation, 1,decodeFlags, encodeFlags, s_flags_calldivinfo), // 3.6
MAKE_PARAM(CallHistoryInformation, 2,decodeInt, encodeInt, 0), // 3.7
MAKE_PARAM(CallReference, 0,0, 0, 0), // 3.8
MAKE_PARAM(CalledPartyNumber, 0,decodeDigits, encodeDigits, 0), // 3.9
MAKE_PARAM(CallingPartyNumber, 0,decodeDigits, encodeDigits, 0), // 3.10
MAKE_PARAM(CallingPartyCategory, 1,decodeInt, encodeInt, s_dict_callerCat), // 3.11
MAKE_PARAM(CauseIndicators, 0,decodeCause, encodeCause, 0), // 3.12 Q.850-2.1
MAKE_PARAM(GroupSupervisionTypeIndicator, 1,decodeFlags, encodeFlags, s_flags_grptypeind), // 3.13
MAKE_PARAM(CircuitStateIndicator, 0,0, 0, 0), // 3.14
MAKE_PARAM(CUG_InterlockCode, 0,0, 0, 0), // 3.15
MAKE_PARAM(ConnectedNumber, 0,decodeDigits, encodeDigits, 0), // 3.16
MAKE_PARAM(ConnectionRequest, 0,0, 0, 0), // 3.17
MAKE_PARAM(ContinuityIndicators, 1,decodeFlags, encodeFlags, s_flags_continuity), // 3.18
MAKE_PARAM(EchoControlInformation, 0,0, 0, 0), // 3.19
MAKE_PARAM(EventInformation, 1,decodeFlags, encodeFlags, s_flags_eventinfo), // 3.21
MAKE_PARAM(FacilityIndicator, 1,0, 0, 0), // 3.22
MAKE_PARAM(ForwardCallIndicators, 2,decodeFlags, encodeFlags, s_flags_fwcallind), // 3.23
MAKE_PARAM(GenericDigits, 0,0, 0, 0), // 3.24
MAKE_PARAM(GenericNotification, 0,decodeNotif, encodeNotif, s_dict_notifications), // 3.25
MAKE_PARAM(GenericNumber, 0,decodeDigits, encodeDigits, 0), // 3.26
MAKE_PARAM(GenericReference, 0,0, 0, 0), // 3.27
MAKE_PARAM(InformationIndicators, 2,0, 0, 0), // 3.28
MAKE_PARAM(InformationRequestIndicators, 2,0, 0, 0), // 3.29
MAKE_PARAM(LocationNumber, 0,decodeDigits, encodeDigits, 0), // 3.30
MAKE_PARAM(MCID_RequestIndicator, 1,decodeFlags, encodeFlags, s_flags_mcid), // 3.31
MAKE_PARAM(MCID_ResponseIndicator, 1,decodeFlags, encodeFlags, s_flags_mcid), // 3.32
MAKE_PARAM(MessageCompatInformation, 0,decodeCompat, 0, 0), // 3.33
MAKE_PARAM(NatureOfConnectionIndicators, 1,decodeFlags, encodeFlags, s_flags_naci), // 3.35
MAKE_PARAM(NetworkSpecificFacilities, 0,0, 0, 0), // 3.36
MAKE_PARAM(OptionalBackwardCallIndicators, 1,decodeFlags, encodeFlags, s_flags_optbkcallind), // 3.37
MAKE_PARAM(OptionalForwardCallIndicators, 1,decodeFlags, encodeFlags, s_flags_optfwcallind), // 3.38
MAKE_PARAM(OriginalCalledNumber, 0,decodeDigits, encodeDigits, 0), // 3.39
MAKE_PARAM(OriginationISCPointCode, 0,0, 0, 0), // 3.40
MAKE_PARAM(ParameterCompatInformation, 0,decodeCompat, 0, 0), // 3.41
MAKE_PARAM(PropagationDelayCounter, 2,decodeInt, encodeInt, 0), // 3.42
MAKE_PARAM(RangeAndStatus, 0,decodeRangeSt, encodeRangeSt, 0), // 3.43
MAKE_PARAM(RedirectingNumber, 0,decodeDigits, encodeDigits, 0), // 3.44
MAKE_PARAM(RedirectionInformation, 0,decodeRedir, encodeRedir, 0), // 3.45
MAKE_PARAM(RedirectionNumber, 0,decodeDigits, encodeDigits, 0), // 3.46
MAKE_PARAM(RedirectionNumberRestriction, 0,0, 0, 0), // 3.47
MAKE_PARAM(RemoteOperations, 0,0, 0, 0), // 3.48
MAKE_PARAM(ServiceActivation, 0,0, 0, 0), // 3.49
MAKE_PARAM(SignallingPointCode, 0,0, 0, 0), // 3.50
MAKE_PARAM(SubsequentNumber, 0,decodeSubseq, encodeSubseq, 0), // 3.51
MAKE_PARAM(SuspendResumeIndicators, 1,0, 0, 0), // 3.52
MAKE_PARAM(TransitNetworkSelection, 0,0, 0, 0), // 3.53
MAKE_PARAM(TransmissionMediumRequirement, 1,decodeInt, encodeInt, s_dict_mediumReq), // 3.54
MAKE_PARAM(TransMediumRequirementPrime, 1,decodeInt, encodeInt, s_dict_mediumReq), // 3.55
MAKE_PARAM(TransmissionMediumUsed, 1,decodeInt, encodeInt, s_dict_mediumReq), // 3.56
MAKE_PARAM(UserServiceInformation, 0,decodeUSI, encodeUSI, 0), // 3.57 Q.931-4.5.5
MAKE_PARAM(UserServiceInformationPrime, 0,0, 0, 0), // 3.58
MAKE_PARAM(UserTeleserviceInformation, 0,0, 0, 0), // 3.59
MAKE_PARAM(UserToUserIndicators, 0,0, 0, 0), // 3.60
MAKE_PARAM(UserToUserInformation, 0,0, 0, 0), // 3.61
MAKE_PARAM(CCSScallIndication, 1,0, 0, 0), // 3.63
MAKE_PARAM(ForwardGVNS, 0,0, 0, 0), // 3.66
MAKE_PARAM(BackwardGVNS, 0,0, 0, 0), // 3.62
MAKE_PARAM(CalledINNumber, 0,decodeDigits, encodeDigits, 0), // 3.73
MAKE_PARAM(UID_ActionIndicators, 0,0, 0, 0), // 3.78
MAKE_PARAM(UID_CapabilityIndicators, 0,0, 0, 0), // 3.79
MAKE_PARAM(RedirectCapability, 0,0, 0, 0), // 3.96
MAKE_PARAM(RedirectCounter, 0,0, 0, 0), // 3.97
MAKE_PARAM(CCNRpossibleIndicator, 0,0, 0, 0), // 3.83
MAKE_PARAM(PivotRoutingIndicators, 0,0, 0, 0), // 3.85
MAKE_PARAM(CalledDirectoryNumber, 0,0, 0, 0), // 3.86
MAKE_PARAM(OriginalCalledINNumber, 0,0, 0, 0), // 3.87
MAKE_PARAM(CallingGeodeticLocation, 0,0, 0, 0), // 3.88
MAKE_PARAM(HTR_Information, 0,0, 0, 0), // 3.89
MAKE_PARAM(NetworkRoutingNumber, 0,0, 0, 0), // 3.90
MAKE_PARAM(QueryOnReleaseCapability, 0,0, 0, 0), // 3.91
MAKE_PARAM(PivotStatus, 0,0, 0, 0), // 3.92
MAKE_PARAM(PivotCounter, 0,0, 0, 0), // 3.93
MAKE_PARAM(PivotRoutingForwardInformation, 0,0, 0, 0), // 3.94
MAKE_PARAM(PivotRoutingBackInformation, 0,0, 0, 0), // 3.95
MAKE_PARAM(RedirectStatus, 0,0, 0, 0), // 3.98
MAKE_PARAM(RedirectForwardInformation, 0,0, 0, 0), // 3.99
MAKE_PARAM(RedirectBackwardInformation, 0,0, 0, 0), // 3.100
MAKE_PARAM(NumberPortabilityInformation, 0,decodeNotif, encodeNotif, s_dict_portability), // 3.101
// No references
MAKE_PARAM(ApplicationTransport, 0,decodeAPT, encodeAPT, 0), // 3.82
MAKE_PARAM(BusinessGroup, 0,0, 0, 0), //
MAKE_PARAM(CallModificationIndicators, 0,0, 0, 0), //
MAKE_PARAM(CarrierIdentification, 0,0, 0, 0), //
MAKE_PARAM(CircuitIdentificationName, 0,0, 0, 0), //
MAKE_PARAM(CarrierSelectionInformation, 0,0, 0, 0), //
MAKE_PARAM(ChargeNumber, 0,0, 0, 0), //
MAKE_PARAM(CircuitAssignmentMap, 0,0, 0, 0), //
MAKE_PARAM(CircuitGroupCharactIndicator, 1,decodeFlags, encodeFlags, s_flags_ansi_cgci), // T1.113 ??
MAKE_PARAM(CircuitValidationRespIndicator, 1,decodeFlags, encodeFlags, s_flags_ansi_cvri), // T1.113 ??
MAKE_PARAM(CommonLanguage, 0,0, 0, 0), //
MAKE_PARAM(CUG_CheckResponseIndicators, 0,0, 0, 0), //
MAKE_PARAM(Egress, 0,0, 0, 0), //
MAKE_PARAM(FacilityInformationIndicators, 0,0, 0, 0), //
MAKE_PARAM(FreephoneIndicators, 0,0, 0, 0), //
MAKE_PARAM(GenericName, 0,decodeName, encodeName, 0), //
MAKE_PARAM(HopCounter, 1,decodeInt, encodeInt, 0), // 3.80
MAKE_PARAM(Index, 0,0, 0, 0), //
MAKE_PARAM(Jurisdiction, 0,0, 0, 0), //
MAKE_PARAM(MLPP_Precedence, 0,0, 0, 0), //
MAKE_PARAM(NetworkTransport, 0,0, 0, 0), //
MAKE_PARAM(NotificationIndicator, 0,0, 0, 0), //
MAKE_PARAM(OperatorServicesInformation, 0,0, 0, 0), //
MAKE_PARAM(OriginatingLineInformation, 1,decodeInt, encodeInt, s_dict_oli), //
MAKE_PARAM(OutgoingTrunkGroupNumber, 0,0, 0, 0), //
MAKE_PARAM(Precedence, 0,0, 0, 0), //
MAKE_PARAM(ServiceCodeIndicator, 0,0, 0, 0), //
MAKE_PARAM(SpecialProcessingRequest, 0,0, 0, 0), //
MAKE_PARAM(TransactionRequest, 0,0, 0, 0), //
// National use (UK-ISUP), references to NICC ND 1007 2001/07
MAKE_PARAM(NationalForwardCallIndicators, 2,decodeFlags, encodeFlags, s_flags_nfci), // 3.2.1
MAKE_PARAM(NationalForwardCallIndicatorsLinkByLink,0,0, 0, 0), // 3.2.2
MAKE_PARAM(PresentationNumber, 0,decodeDigits, encodeDigits, 0), // 3.2.3
MAKE_PARAM(LastDivertingLineIdentity, 0,decodeDigits, encodeDigits, 0), // 3.2.4
MAKE_PARAM(PartialCLI, 0,0, 0, 0), // 3.2.5
MAKE_PARAM(CalledSubscribersBasicServiceMarks, 0,0, 0, 0), // 3.2.6
MAKE_PARAM(CallingSubscribersBasicServiceMarks, 0,0, 0, 0), // 3.2.7
MAKE_PARAM(CallingSubscribersOriginatingFacilMarks,0,0, 0, 0), // 3.2.8
MAKE_PARAM(CalledSubscribersTerminatingFacilMarks, 0,0, 0, 0), // 3.2.9
MAKE_PARAM(NationalInformationRequestIndicators, 0,0, 0, 0), // 3.2.10
MAKE_PARAM(NationalInformationIndicators, 0,0, 0, 0), // 3.2.11
{ SS7MsgISUP::EndOfParameters, 0, 0, 0, 0, 0 }
};
#undef MAKE_PARAM
const char* getIsupParamName(unsigned char type)
{
for (unsigned int i = 0; s_paramDefs[i].type; i++)
if (type == s_paramDefs[i].type)
return s_paramDefs[i].name;
return 0;
}
// Descriptor of ISUP message common across standards
static const MsgParams s_common_params[] = {
// call progress and release messages
{ SS7MsgISUP::ACM, true,
{
SS7MsgISUP::BackwardCallIndicators,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CON, true,
{
SS7MsgISUP::BackwardCallIndicators,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::ANM, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::REL, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::CauseIndicators,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::RLC, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::SAM, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::SubsequentNumber,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CPR, true,
{
SS7MsgISUP::EventInformation,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CNF, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::CauseIndicators,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::SUS, true,
{
SS7MsgISUP::SuspendResumeIndicators,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::RES, true,
{
SS7MsgISUP::SuspendResumeIndicators,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::INR, true,
{
SS7MsgISUP::InformationRequestIndicators,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::INF, true,
{
SS7MsgISUP::InformationIndicators,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
// circuit group reset and acknowledgement
{ SS7MsgISUP::GRS, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::RangeAndStatus,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::GRA, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::RangeAndStatus,
SS7MsgISUP::EndOfParameters
}
},
// circuit group query
{ SS7MsgISUP::CQM, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::RangeAndStatus,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CQR, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::RangeAndStatus,
SS7MsgISUP::CircuitStateIndicator,
SS7MsgISUP::EndOfParameters
}
},
// circuit group blocking, unblocking and acknowledgement
{ SS7MsgISUP::CGB, false,
{
SS7MsgISUP::GroupSupervisionTypeIndicator,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::RangeAndStatus,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CGA, false,
{
SS7MsgISUP::GroupSupervisionTypeIndicator,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::RangeAndStatus,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CGU, false,
{
SS7MsgISUP::GroupSupervisionTypeIndicator,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::RangeAndStatus,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CUA, false,
{
SS7MsgISUP::GroupSupervisionTypeIndicator,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::RangeAndStatus,
SS7MsgISUP::EndOfParameters
}
},
// circuit related messages - most without parameters, only CIC
{ SS7MsgISUP::BLK, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::BLA, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::UBL, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::UBA, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CCR, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::LPA, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::OLM, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::RSC, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::UEC, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::COT, false,
{
SS7MsgISUP::ContinuityIndicators,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
// user part test and response
{ SS7MsgISUP::UPT, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::UPA, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
// application transport
{ SS7MsgISUP::APM, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
// facility
{ SS7MsgISUP::FACR, true,
{
SS7MsgISUP::FacilityIndicator,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::FAA, true,
{
SS7MsgISUP::FacilityIndicator,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::FRJ, true,
{
SS7MsgISUP::FacilityIndicator,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::CauseIndicators,
SS7MsgISUP::EndOfParameters
}
},
// miscellaneous
{ SS7MsgISUP::USR, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::UserToUserInformation,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::Unknown, false, { SS7MsgISUP::EndOfParameters } }
};
// Descriptor of ITU-T version of ISUP messages
static const MsgParams s_itu_params[] = {
{ SS7MsgISUP::IAM, true,
{
SS7MsgISUP::NatureOfConnectionIndicators,
SS7MsgISUP::ForwardCallIndicators,
SS7MsgISUP::CallingPartyCategory,
SS7MsgISUP::TransmissionMediumRequirement,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::CalledPartyNumber,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::Unknown, false, { SS7MsgISUP::EndOfParameters } }
};
// Descriptor of ANSI version of ISUP messages
static const MsgParams s_ansi_params[] = {
{ SS7MsgISUP::IAM, true,
{
SS7MsgISUP::NatureOfConnectionIndicators,
SS7MsgISUP::ForwardCallIndicators,
SS7MsgISUP::CallingPartyCategory,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::UserServiceInformation,
SS7MsgISUP::CalledPartyNumber,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::RLC, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::EXM, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CVT, false,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::CVR, true,
{
SS7MsgISUP::CircuitValidationRespIndicator,
SS7MsgISUP::CircuitGroupCharactIndicator,
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
},
{ SS7MsgISUP::Unknown, false, { SS7MsgISUP::EndOfParameters } }
};
// Descriptor for decoding of compatibility parameters of unsupported messages
// with only optional parameters (all new messages should be like this)
static const MsgParams s_compatibility = {
SS7MsgISUP::Unknown, true,
{
SS7MsgISUP::EndOfParameters,
SS7MsgISUP::EndOfParameters
}
};
// Generic decode helper function for a single parameter
static bool decodeParam(const SS7ISUP* isup, NamedList& list, const IsupParam* param,
const unsigned char* buf, unsigned int len, const String& prefix)
{
DDebug(isup,DebugAll,"decodeParam(%p,%p,%p,%u) type=0x%02x, size=%u, name='%s'",
&list,param,buf,len,param->type,param->size,param->name);
if (param->size && (param->size != len))
return false;
if (param->decoder)
return param->decoder(isup,list,param,buf,len,prefix);
return decodeRaw(isup,list,param,buf,len,prefix);
}
// Generic encode helper function for a single mandatory parameter
static unsigned char encodeParam(const SS7ISUP* isup, SS7MSU& msu,
const IsupParam* param, const NamedList* params, ObjList& exclude,
const String& prefix, unsigned char* buf = 0)
{
DDebug(isup,DebugAll,"encodeParam (mand) (%p,%p,%p,%p) type=0x%02x, size=%u, name='%s'",
&msu,param,params,buf,param->type,param->size,param->name);
// variable length must not receive fixed buffer
if (buf && !param->size)
return 0;
NamedString* val = params ? params->getParam(prefix+param->name) : 0;
if (val)
exclude.append(val)->setDelete(false);
if (param->encoder)
return param->encoder(isup,msu,buf,param,val,params,prefix);
return encodeRaw(isup,msu,buf,param,val,params,prefix);
}
// Generic encode helper for a single optional parameter
static unsigned char encodeParam(const SS7ISUP* isup, SS7MSU& msu,
const IsupParam* param, const NamedString* val,
const NamedList* extra, const String& prefix)
{
DDebug(isup,DebugAll,"encodeParam (opt) (%p,%p,%p,%p) type=0x%02x, size=%u, name='%s'",
&msu,param,val,extra,param->type,param->size,param->name);
// add the parameter type now but remember the old length
unsigned int len = msu.length();
unsigned char tmp = param->type;
msu.append(&tmp,1);
unsigned char size = 0;
if (param->encoder)
size = param->encoder(isup,msu,0,param,val,extra,prefix);
else
size = encodeRaw(isup,msu,0,param,val,extra,prefix);
if (!size) {
Debug(isup,DebugMild,"Unwinding type storage for failed parameter %s",param->name);
msu.truncate(len);
}
return size;
}
// Locate the description for a parameter by type
static const IsupParam* getParamDesc(SS7MsgISUP::Parameters type)
{
const IsupParam* param = s_paramDefs;
for (; param->type != SS7MsgISUP::EndOfParameters; param++) {
if (param->type == type)
return param;
}
return 0;
}
// Locate the description for a parameter by name
static const IsupParam* getParamDesc(const String& name)
{
const IsupParam* param = s_paramDefs;
for (; param->type != SS7MsgISUP::EndOfParameters; param++) {
if (name == param->name)
return param;
}
return 0;
}
// Locate the description table for a message according to protocol type
static const MsgParams* getIsupParams(SS7PointCode::Type type, SS7MsgISUP::Type msg)
{
const MsgParams* params = 0;
switch (type) {
case SS7PointCode::ITU:
params = s_itu_params;
break;
case SS7PointCode::ANSI:
case SS7PointCode::ANSI8:
params = s_ansi_params;
break;
default:
return 0;
}
// search first in specific table
for (; params->type != SS7MsgISUP::Unknown; params++) {
if (params->type == msg)
return params;
}
// then search in common table
for (params = s_common_params; params->type != SS7MsgISUP::Unknown; params++) {
if (params->type == msg)
return params;
}
return 0;
}
// Hexify a list of isup parameter values/names
static void hexifyIsupParams(String& s, const String& list)
{
if (!list)
return;
ObjList* l = list.split(',',false);
unsigned int len = l->count();
if (len) {
unsigned char* buf = new unsigned char[len];
len = 0;
for (ObjList* o = l->skipNull(); o; o = o->skipNext()) {
String* str = static_cast<String*>(o->get());
int val = str->toInteger(-1);
if (val < 0) {
const IsupParam* p = getParamDesc(*str);
if (p)
val = p->type;
}
if (val >= 0 && val < 256) {
// avoid duplicates
for (unsigned int i = 0; i < len; i++) {
if ((unsigned char)val == buf[i]) {
val = -1;
break;
}
}
if (val >= 0)
buf[len++] = (unsigned char)val;
}
}
if (len)
s.hexify(buf,len,' ');
delete[] buf;
}
TelEngine::destruct(l);
}
// Check if an unhandled messages has only optional parameters
#define MAKE_CASE(x) case SS7MsgISUP::x:
static bool hasOptionalOnly(SS7MsgISUP::Type msg)
{
switch (msg) {
MAKE_CASE(IAM)
MAKE_CASE(SAM)
MAKE_CASE(INR)
MAKE_CASE(INF)
MAKE_CASE(COT)
MAKE_CASE(ACM)
MAKE_CASE(CON)
MAKE_CASE(REL)
MAKE_CASE(SUS)
MAKE_CASE(RES)
MAKE_CASE(CCR)
MAKE_CASE(RSC)
MAKE_CASE(BLK)
MAKE_CASE(UBL)
MAKE_CASE(BLA)
MAKE_CASE(UBA)
MAKE_CASE(GRS)
MAKE_CASE(CGB)
MAKE_CASE(CGU)
MAKE_CASE(CGA)
MAKE_CASE(CUA)
MAKE_CASE(FACR)
MAKE_CASE(FAA)
MAKE_CASE(FRJ)
MAKE_CASE(LPA)
MAKE_CASE(PAM)
MAKE_CASE(GRA)
MAKE_CASE(CQM)
MAKE_CASE(CQR)
MAKE_CASE(CPR)
MAKE_CASE(USR)
MAKE_CASE(UEC)
MAKE_CASE(CNF)
MAKE_CASE(OLM)
return false;
default:
return true;
}
}
#undef MAKE_CASE
#define MAKE_NAME(x) { #x, SS7MsgISUP::x }
static const TokenDict s_names[] = {
// this list must be kept in synch with the header
MAKE_NAME(IAM),
MAKE_NAME(SAM),
MAKE_NAME(INR),
MAKE_NAME(INF),
MAKE_NAME(COT),
MAKE_NAME(ACM),
MAKE_NAME(CON),
MAKE_NAME(FOT),
MAKE_NAME(ANM),
MAKE_NAME(REL),
MAKE_NAME(SUS),
MAKE_NAME(RES),
MAKE_NAME(RLC),
MAKE_NAME(CCR),
MAKE_NAME(RSC),
MAKE_NAME(BLK),
MAKE_NAME(UBL),
MAKE_NAME(BLA),
MAKE_NAME(UBA),
MAKE_NAME(GRS),
MAKE_NAME(CGB),
MAKE_NAME(CGU),
MAKE_NAME(CGA),
MAKE_NAME(CGBA), // alias
MAKE_NAME(CUA),
MAKE_NAME(CMR),
MAKE_NAME(CMC),
MAKE_NAME(CMRJ),
MAKE_NAME(FACR),
MAKE_NAME(FAA),
MAKE_NAME(FRJ),
MAKE_NAME(FAD),
MAKE_NAME(FAI),
MAKE_NAME(LPA),
MAKE_NAME(CSVR),
MAKE_NAME(CSVS),
MAKE_NAME(DRS),
MAKE_NAME(PAM),
MAKE_NAME(GRA),
MAKE_NAME(CQM),
MAKE_NAME(CQR),
MAKE_NAME(CPR),
MAKE_NAME(CPG), // alias
MAKE_NAME(USR),
MAKE_NAME(UEC),
MAKE_NAME(UCIC), // alias
MAKE_NAME(CNF),
MAKE_NAME(OLM),
MAKE_NAME(CRG),
MAKE_NAME(NRM),
MAKE_NAME(FAC),
MAKE_NAME(UPT),
MAKE_NAME(UPA),
MAKE_NAME(IDR),
MAKE_NAME(IRS),
MAKE_NAME(SGM),
MAKE_NAME(LOP),
MAKE_NAME(APM),
MAKE_NAME(PRI),
MAKE_NAME(SDN),
MAKE_NAME(CRA),
MAKE_NAME(CRM),
MAKE_NAME(CVR),
MAKE_NAME(CVT),
MAKE_NAME(EXM),
{ 0, 0 }
};
#undef MAKE_NAME
const TokenDict* SS7MsgISUP::names()
{
return s_names;
}
void SS7MsgISUP::toString(String& dest, const SS7Label& label, bool params,
const void* raw, unsigned int rawLen) const
{
const char* enclose = "\r\n-----";
dest = enclose;
dest << "\r\n" << name() << " [cic=" << m_cic << " label=" << label << ']';
if (raw && rawLen) {
String tmp;
tmp.hexify((void*)raw,rawLen,' ');
dest << " " << tmp;
}
if (params) {
unsigned int n = m_params.length();
for (unsigned int i = 0; i < n; i++) {
NamedString* s = m_params.getParam(i);
if (s)
dest << "\r\n " << s->name() << "='" << *s << "'";
}
}
dest << enclose;
}
/**
* Helper functions used to transmit responses
*/
// Push down the protocol stack a RLC (Release Complete) message
// @param msg Optional received message to copy release parameters. Ignored if reason is valid
static int transmitRLC(SS7ISUP* isup, unsigned int cic, const SS7Label& label, bool recvLbl,
const char* reason = 0, const char* diagnostic = 0, const char* location = 0)
{
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::RLC,cic);
if (!TelEngine::null(reason)) {
m->params().addParam("CauseIndicators",reason);
m->params().addParam("CauseIndicators.location",location,false);
m->params().addParam("CauseIndicators.diagnostic",diagnostic,false);
}
return isup->transmitMessage(m,label,recvLbl);
}
// Push down the protocol stack a CNF (Confusion) message
static int transmitCNF(SS7ISUP* isup, unsigned int cic, const SS7Label& label, bool recvLbl,
const char* reason, const char* diagnostic = 0, const char* location = 0)
{
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::CNF,cic);
if (reason)
m->params().addParam("CauseIndicators",reason);
if (!location)
location = isup->location();
m->params().addParam("CauseIndicators.location",location,false);
m->params().addParam("CauseIndicators.diagnostic",diagnostic,false);
return isup->transmitMessage(m,label,recvLbl);
}
// Utility used to check for called number completion
static inline bool isCalledIncomplete(const NamedList& l, const String& p = "CalledPartyNumber")
{
return !l[p].endsWith(".");
}
// Fill call release or cnf flags from message compatibility info
static void getMsgCompat(SS7MsgISUP* msg, bool& release, bool& cnf)
{
if (!msg)
return;
String* msgCompat = msg->params().getParam(YSTRING("MessageCompatInformation"));
if (msgCompat) {
ObjList* l = msgCompat->split(',',false);
// Use a while() to make sure the list is destroyed
do {
release = (0 != l->find("release"));
if (release)
break;
// Discard the message (no pass on). Check if CNF should be sent
if (l->find("discard")) {
cnf = (0 != l->find("cnf"));
break;
}
// Pass on set: we didn't passed on the message. Check REL/CNF
release = (0 != l->find("nopass-release"));
cnf = !release && l->find("cnf");
} while(false);
TelEngine::destruct(l);
}
else
cnf = true;
}
static void setCallsTerminate(ObjList& lst, bool gracefully, const char* reason = 0,
const char* diagnostic = 0, const char* location = 0)
{
for (ObjList* o = lst.skipNull(); o; o = o->skipNext()) {
SS7ISUPCall* call = static_cast<SS7ISUPCall*>(o->get());
call->setTerminate(gracefully,reason,diagnostic,location);
}
}
/**
* SS7ISUPCall
*/
SS7ISUPCall::SS7ISUPCall(SS7ISUP* controller, SignallingCircuit* cic,
const SS7PointCode& local, const SS7PointCode& remote, bool outgoing,
int sls, const char* range, bool testCall)
: SignallingCall(controller,outgoing),
m_state(Null),
m_testCall(testCall),
m_circuit(cic),
m_cicRange(range),
m_terminate(false),
m_gracefully(true),
m_circuitChanged(false),
m_circuitTesting(false),
m_inbandAvailable(false),
m_replaceCounter(3),
m_iamMsg(0),
m_sgmMsg(0),
m_relMsg(0),
m_sentSamDigits(0),
m_relTimer(300000), // Q.764: T5 - 5..15 minutes
m_iamTimer(ISUP_T7_DEFVAL), // Setup, Testing: Q.764: T7 - 20..30 seconds
// Releasing: Q.764: T1: 15..60 seconds
m_sgmRecvTimer(ISUP_T34_DEFVAL), // Q.764: T34 - 2..4 seconds
m_contTimer(ISUP_T27_DEFVAL), // Q.764: T27 - 4 minutes
m_anmTimer(0) // Q.764 T9 Q.118: 1.5 - 3 minutes, not always used
{
if (!(controller && m_circuit)) {
Debug(isup(),DebugWarn,
"SS7ISUPCall(%u). No call controller or circuit. Terminate [%p]",
id(),this);
setTerminate(true,m_circuit ? "temporary-failure" : "congestion");
return;
}
isup()->setLabel(m_label,local,remote,sls);
if (isup()->m_t7Interval)
m_iamTimer.interval(isup()->m_t7Interval);
if (isup()->m_t9Interval)
m_anmTimer.interval(isup()->m_t9Interval);
if (isup()->m_t27Interval)
m_contTimer.interval(isup()->m_t27Interval);
if (isup()->m_t34Interval)
m_sgmRecvTimer.interval(isup()->m_t34Interval);
m_replaceCounter = isup()->m_replaceCounter;
if (isup()->debugAt(DebugAll)) {
String tmp;
tmp << m_label;
Debug(isup(),DebugAll,"Call(%u) direction=%s routing-label=%s range=%s [%p]",
id(),(outgoing ? "outgoing" : "incoming"),tmp.c_str(),m_cicRange.safe(),this);
}
}
SS7ISUPCall::~SS7ISUPCall()
{
TelEngine::destruct(m_iamMsg);
TelEngine::destruct(m_sgmMsg);
const char* timeout = 0;
if (m_relTimer.started())
timeout = " (release timed out)";
else if (m_contTimer.started())
timeout = " (T27 timed out)";
releaseComplete(true,0,0,0 != timeout);
Debug(isup(),!timeout ? DebugAll : DebugNote,
"Call(%u) destroyed with reason='%s'%s [%p]",
id(),m_reason.safe(),TelEngine::c_safe(timeout),this);
TelEngine::destruct(m_relMsg);
if (controller()) {
if (!timeout)
controller()->releaseCircuit(m_circuit);
else
isup()->startCircuitReset(m_circuit,m_relTimer.started() ? "T5" : "T16");
}
else
TelEngine::destruct(m_circuit);
}
// Stop waiting for a SGM (Segmentation) message when another message is
// received by the controller
void SS7ISUPCall::stopWaitSegment(bool discard)
{
Lock mylock(this);
if (!m_sgmMsg)
return;
m_sgmRecvTimer.stop();
if (discard)
TelEngine::destruct(m_sgmMsg);
}
// Helper functions called in getEvent
inline static bool timeout(SS7ISUP* isup, SS7ISUPCall* call, SignallingTimer& timer,
const Time& when, const char* req, bool stop = true)
{
if (!timer.timeout(when.msec()))
return false;
if (stop)
timer.stop();
Debug(isup,DebugNote,"Call(%u). %s timed out [%p]",call->id(),req,call);
return true;
}
// Get an event from this call
SignallingEvent* SS7ISUPCall::getEvent(const Time& when)
{
Lock mylock(this,SignallingEngine::maxLockWait());
if (m_lastEvent || m_state == Released || !mylock.locked())
return 0;
SS7MsgISUP* msg = 0;
while (true) {
if (m_terminate) {
if (m_state < Releasing && m_state > Null)
if (m_gracefully)
m_lastEvent = release();
else
m_lastEvent = releaseComplete(false,0);
else if (m_state == Null || m_state == Released) {
m_gracefully = false;
m_lastEvent = releaseComplete(false,0);
}
m_terminate = false;
break;
}
// Check if waiting for SGM
// Stop if: timeout, the controller stopped the timer or received a message other then SGM
if (m_sgmMsg) {
msg = static_cast<SS7MsgISUP*>(dequeue(false));
if (!msg && !m_sgmRecvTimer.timeout(when.msec()) && m_sgmRecvTimer.started())
return 0;
msg = ((msg && msg->type() == SS7MsgISUP::SGM) ? static_cast<SS7MsgISUP*>(dequeue()) : 0);
processSegmented(msg,m_sgmRecvTimer.timeout(when.msec()));
break;
}
// Process received messages
msg = static_cast<SS7MsgISUP*>(dequeue());
if (msg && validMsgState(false,msg->type(),(msg->params().getParam(YSTRING("BackwardCallIndicators")) != 0)))
switch (msg->type()) {
case SS7MsgISUP::IAM:
case SS7MsgISUP::CCR:
case SS7MsgISUP::COT:
case SS7MsgISUP::ACM:
case SS7MsgISUP::EXM:
case SS7MsgISUP::CPR:
case SS7MsgISUP::ANM:
case SS7MsgISUP::CON:
case SS7MsgISUP::CRG:
m_sgmMsg = msg;
{
const char* sgmParam = "OptionalBackwardCallIndicators";
if (msg->type() == SS7MsgISUP::IAM) {
copyParamIAM(msg);
setOverlapped(isCalledIncomplete(msg->params()));
sgmParam = "OptionalForwardCallIndicators";
}
// Check segmentation. Keep the message and start timer if segmented
if (SignallingUtils::hasFlag(msg->params(),sgmParam,"segmentation")) {
m_sgmRecvTimer.start(when.msec());
return 0;
}
}
msg = 0;
processSegmented(0,false);
break;
case SS7MsgISUP::SAM:
setOverlapped(isCalledIncomplete(msg->params(),"SubsequentNumber"));
msg->params().addParam("tone",msg->params().getValue(YSTRING("SubsequentNumber")));
msg->params().addParam("dialing",String::boolText(true));
m_lastEvent = new SignallingEvent(SignallingEvent::Info,msg,this);
break;
case SS7MsgISUP::RLC:
m_gracefully = false;
if (m_state < Releasing) {
setReason(0,msg);
m_location = isup()->location();
m_lastEvent = release(0,msg);
}
else {
m_relTimer.stop();
m_lastEvent = releaseComplete(false,msg);
}
break;
case SS7MsgISUP::REL:
if (m_state < Releasing) {
m_relTimer.stop();
m_lastEvent = releaseComplete(false,msg);
}
else
transmitRLC(isup(),msg->cic(),m_label,false);
break;
case SS7MsgISUP::SGM:
DDebug(isup(),DebugInfo,"Call(%u). Received late 'SGM' [%p]",id(),this);
break;
case SS7MsgISUP::SUS:
m_lastEvent = new SignallingEvent(SignallingEvent::Suspend,msg,this);
break;
case SS7MsgISUP::RES:
m_lastEvent = new SignallingEvent(SignallingEvent::Resume,msg,this);
break;
case SS7MsgISUP::APM:
m_lastEvent = new SignallingEvent(SignallingEvent::Generic,msg,this);
break;
default: ;
Debug(isup(),DebugStub,"Call(%u). Unhandled '%s' message in getEvent() [%p]",
id(),msg->name(),this);
}
break;
}
if (msg)
msg->deref();
// No events: check timeouts
if (!m_lastEvent) {
switch (m_state) {
case Testing:
case Setup:
if (timeout(isup(),this,m_iamTimer,when,"IAM")) {
m_contTimer.stop();
if (m_circuitTesting) {
if (m_iamMsg)
setReason("bearer-cap-not-available",0);
else {
setTerminate(true,"bearer-cap-not-available");
break;
}
}
else
setReason("timeout",0);
m_lastEvent = release();
break;
}
if (timeout(isup(),this,m_contTimer,when,"T27",false)) {
m_gracefully = false;
m_lastEvent = releaseComplete(false,0,0,true);
}
break;
case Releasing:
if (timeout(isup(),this,m_relTimer,when,"REL",false))
m_lastEvent = releaseComplete(false,0,"noresponse",true);
else if (timeout(isup(),this,m_iamTimer,when,"T1")) {
m_iamTimer.stop();
m_iamTimer.start(when.msec());
transmitREL();
}
break;
default:
if (outgoing() && m_anmTimer.started() && m_state >= Accepted &&
m_state < Answered && timeout(isup(),this,m_anmTimer,when,"T9")) {
setReason("noresponse",0,0,isup()->location());
m_lastEvent = release();
}
}
}
// Reset overlapped if our state is greater then Setup
if (m_state > Setup)
setOverlapped(false,false);
// Check circuit event
if (!m_lastEvent && m_circuit) {
SignallingCircuitEvent* cicEvent = m_circuit->getEvent(when);
if (cicEvent) {
if (isup())
m_lastEvent = isup()->processCircuitEvent(cicEvent,this);
TelEngine::destruct(cicEvent);
}
}
if (m_lastEvent)
XDebug(isup(),DebugNote,"Call(%u). Raising event (%p,'%s') [%p]",
id(),m_lastEvent,m_lastEvent->name(),this);
return m_lastEvent;
}
// Helper that copies all parameters starting with a capital letter
static void copyUpper(NamedList& dest, const NamedList& src)
{
static const Regexp r("^[A-Z][A-Za-z0-9_.]\\+$");
unsigned int n = src.length();
for (unsigned int i = 0; i < n; i++) {
const NamedString* p = src.getParam(i);
if (!p || !r.matches(p->name()))
continue;
dest.setParam(p->name(),*p);
}
}
// Send an event to this call
bool SS7ISUPCall::sendEvent(SignallingEvent* event)
{
Lock mylock(this);
if (!event)
return false;
if (m_terminate || m_state == Released) {
mylock.drop();
delete event;
return false;
}
bool result = false;
switch (event->type()) {
case SignallingEvent::NewCall:
if (validMsgState(true,SS7MsgISUP::IAM)) {
if (!event->message()) {
DDebug(isup(),DebugNote,
"Call(%u). No parameters for outgoing call [%p]",id(),this);
setTerminate(true,"temporary-failure");
break;
}
m_iamMsg = new SS7MsgISUP(SS7MsgISUP::IAM,id());
copyParamIAM(m_iamMsg,true,event->message());
// Update overlap
String* called = m_iamMsg->params().getParam(YSTRING("CalledPartyNumber"));
if (called && (called->length() > isup()->m_maxCalledDigits)) {
// Longer than maximum digits allowed - send remainder with SAM
m_samDigits = called->substr(isup()->m_maxCalledDigits);
*called = called->substr(0,isup()->m_maxCalledDigits);
setOverlapped(true);
}
else
setOverlapped(isCalledIncomplete(m_iamMsg->params()));
result = transmitIAM();
}
break;
case SignallingEvent::Progress:
case SignallingEvent::Ringing:
if (validMsgState(true,SS7MsgISUP::CPR)) {
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::CPR,id());
m->params().addParam("EventInformation",
event->type() == SignallingEvent::Ringing ? "ringing": "progress");
bool inband = m_inbandAvailable;
if (event->message()) {
copyUpper(m->params(),event->message()->params());
m_inbandAvailable = m_inbandAvailable ||
event->message()->params().getBoolValue(YSTRING("earlymedia"));
inband = event->message()->params().getBoolValue(YSTRING("send-inband"),m_inbandAvailable);
}
if (inband && !outgoing())
SignallingUtils::appendFlag(m->params(),"OptionalBackwardCallIndicators","inband");
m_state = Ringing;
mylock.drop();
result = transmitMessage(m);
}
break;
case SignallingEvent::Accept:
if (validMsgState(true,SS7MsgISUP::ACM)) {
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::ACM,id());
bool inband = m_inbandAvailable;
if (event->message()) {
copyUpper(m->params(),event->message()->params());
m_inbandAvailable = m_inbandAvailable ||
event->message()->params().getBoolValue(YSTRING("earlymedia"));
inband = event->message()->params().getBoolValue(YSTRING("send-inband"),m_inbandAvailable);
}
if (inband && !outgoing())
SignallingUtils::appendFlag(m->params(),"OptionalBackwardCallIndicators","inband");
m_state = Accepted;
mylock.drop();
result = transmitMessage(m);
}
break;
case SignallingEvent::Answer:
if (validMsgState(true,SS7MsgISUP::ANM)) {
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::ANM,id());
if (event->message())
copyUpper(m->params(),event->message()->params());
m_state = Answered;
mylock.drop();
result = transmitMessage(m);
}
break;
case SignallingEvent::Release:
if (validMsgState(true,SS7MsgISUP::REL)) {
release(event);
result = true;
}
break;
case SignallingEvent::Generic:
if (event->message()) {
const String& oper = event->message()->params()[YSTRING("operation")];
if (oper == "charge") {
if (!validMsgState(true,SS7MsgISUP::CRG))
break;
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::CRG,id());
copyUpper(m->params(),event->message()->params());
mylock.drop();
result = transmitMessage(m);
break;
}
if (oper != "transport")
break;
if (!validMsgState(true,SS7MsgISUP::APM))
break;
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::APM,id());
copyUpper(m->params(),event->message()->params());
mylock.drop();
result = transmitMessage(m);
}
break;
case SignallingEvent::Suspend:
if (event->message()) {
if (!validMsgState(true,SS7MsgISUP::SUS))
break;
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::SUS,id());
copyUpper(m->params(),event->message()->params());
mylock.drop();
result = transmitMessage(m);
}
break;
case SignallingEvent::Resume:
if (event->message()) {
if (!validMsgState(true,SS7MsgISUP::RES))
break;
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::RES,id());
copyUpper(m->params(),event->message()->params());
mylock.drop();
result = transmitMessage(m);
}
break;
case SignallingEvent::Info:
if (validMsgState(true,SS7MsgISUP::SAM)) {
mylock.drop();
transmitSAM(event->message()->params().getValue(YSTRING("tone")));
result = true;
break;
}
//case SignallingEvent::Message:
//case SignallingEvent::Transfer:
case SignallingEvent::Charge:
if (event->message()) {
if (!validMsgState(true,SS7MsgISUP::CRG))
break;
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::CRG,id());
copyUpper(m->params(),event->message()->params());
mylock.drop();
result = transmitMessage(m);
}
break;
default:
DDebug(isup(),DebugStub,
"Call(%u). sendEvent not implemented for '%s' [%p]",
id(),event->name(),this);
}
// Reset overlapped if our state is greater then Setup
if (m_state > Setup)
setOverlapped(false,false);
XDebug(isup(),DebugAll,"Call(%u). Event (%p,'%s') sent. Result: %s [%p]",
id(),event,event->name(),String::boolText(result),this);
mylock.drop();
delete event;
return result;
}
// Get reserved circuit or this object
void* SS7ISUPCall::getObject(const String& name) const
{
if (name == YSTRING("SignallingCircuit"))
return m_circuit;
if (name == YSTRING("SS7ISUPCall"))
return (void*)this;
return SignallingCall::getObject(name);
}
// Check if the circuit can be replaced
// Returns true unless the counter is already zero
bool SS7ISUPCall::canReplaceCircuit()
{
if (m_replaceCounter <= 0)
return false;
m_replaceCounter--;
return true;
}
// Replace the circuit reserved for this call. Release the already reserved circuit.
// Retransmit the initial IAM request on success.
// On failure set the termination flag and release the new circuit if valid
bool SS7ISUPCall::replaceCircuit(SignallingCircuit* circuit, SS7MsgISUP* msg)
{
Lock mylock(this);
clearQueue();
if (m_state > Setup || !circuit || !outgoing()) {
Debug(isup(),DebugNote,"Call(%u). Failed to replace circuit [%p]",id(),this);
m_iamTimer.stop();
if (controller()) {
controller()->releaseCircuit(m_circuit);
controller()->releaseCircuit(circuit);
}
setTerminate(false,"congestion");
TelEngine::destruct(msg);
return false;
}
transmitMessage(msg);
unsigned int oldId = id();
if (controller())
controller()->releaseCircuit(m_circuit);
m_circuit = circuit;
Debug(isup(),DebugNote,"Call(%u). Circuit replaced by %u [%p]",oldId,id(),this);
m_circuitChanged = true;
return transmitIAM();
}
// Stop timers. Send a RLC (Release Complete) message if it should terminate gracefully
// Decrease the object's refence count and generate a Release event if not final
// @param final True if called from destructor
// @param msg Received message with parameters if any
// @param reason Optional release reason
SignallingEvent* SS7ISUPCall::releaseComplete(bool final, SS7MsgISUP* msg, const char* reason,
bool timeout)
{
if (timeout)
m_gracefully = false;
m_iamTimer.stop();
setReason(reason,msg);
stopWaitSegment(true);
if (m_state == Released)
return 0;
if (isup() && m_gracefully) {
int sls = transmitRLC(isup(),id(),m_label,false);
if (sls != -1 && m_label.sls() == 255)
m_label.setSls(sls);
}
m_state = Released;
if (final)
return 0;
// Return event and decrease reference counter
bool create = (msg == 0);
if (create)
msg = new SS7MsgISUP(SS7MsgISUP::RLC,id());
if (m_circuit)
m_circuit->disconnect();
msg->params().setParam("reason",m_reason);
SignallingEvent* event = new SignallingEvent(SignallingEvent::Release,msg,this);
// deref() msg if created here. If received, it will be deref()'d in getEvent()
if (create)
msg->deref();
deref();
DDebug(isup(),DebugInfo,"Call(%u). Released with reason '%s' [%p]",
id(),m_reason.safe(),this);
return event;
}
// Helper function to copy parameters
inline void param(NamedList& dest, NamedList& src, const String& destParam,
const String& srcParam, const char* defVal)
{
const char* val = src.getValue(srcParam,src.getValue(destParam,defVal));
if ((val != defVal) || !dest.getParam(destParam))
dest.setParam(destParam,val);
}
// Initialize/set IAM message parameters
// @param msg Valid ISUP message
// @param outgoing Message direction: true for outgoing
// @param sigMsg Valid signalling message with parameters if outgoing
bool SS7ISUPCall::copyParamIAM(SS7MsgISUP* msg, bool outgoing, SignallingMessage* sigMsg)
{
NamedList& dest = msg->params();
if (outgoing) {
NamedList& src = sigMsg->params();
copyUpper(dest,src);
param(dest,src,"CalledPartyNumber","called","");
param(dest,src,"CalledPartyNumber.inn","inn",String::boolText(isup()->m_inn));
param(dest,src,"CalledPartyNumber.nature","callednumtype",isup()->m_numType);
param(dest,src,"CalledPartyNumber.plan","callednumplan",isup()->m_numPlan);
param(dest,src,"CallingPartyCategory","callercategory",isup()->m_callerCat);
param(dest,src,"CallingPartyNumber","caller","");
param(dest,src,"CallingPartyNumber.nature","callernumtype",isup()->m_numType);
param(dest,src,"CallingPartyNumber.plan","callernumplan",isup()->m_numPlan);
param(dest,src,"CallingPartyNumber.restrict","callerpres",isup()->m_numPresentation);
param(dest,src,"CallingPartyNumber.screened","callerscreening",isup()->m_numScreening);
param(dest,src,"CallingPartyNumber.complete","complete","true");
m_format = src.getValue(YSTRING("format"),isup()->format());
dest.setParam("UserServiceInformation",m_format);
return true;
}
// Incoming call
m_format = dest.getValue(YSTRING("UserServiceInformation"),isup()->format());
dest.setParam("format",m_format);
dest.setParam("caller",dest.getValue(YSTRING("CallingPartyNumber")));
//dest.setParam("callername",dest.getValue(""));
dest.setParam("callernumtype",dest.getValue(YSTRING("CallingPartyNumber.nature")));
dest.setParam("callernumplan",dest.getValue(YSTRING("CallingPartyNumber.plan")));
dest.setParam("callerpres",dest.getValue(YSTRING("CallingPartyNumber.restrict")));
dest.setParam("callerscreening",dest.getValue(YSTRING("CallingPartyNumber.screened")));
dest.setParam("called",dest.getValue(YSTRING("CalledPartyNumber")));
dest.setParam("callednumtype",dest.getValue(YSTRING("CalledPartyNumber.nature")));
dest.setParam("callednumplan",dest.getValue(YSTRING("CalledPartyNumber.plan")));
dest.setParam("inn",dest.getValue(YSTRING("CalledPartyNumber.inn")));
if (m_label.sls() != 0xff)
dest.setParam("sls",String((unsigned int)m_label.sls()));
return true;
}
// If already releasing, set termination flag. Otherwise, send REL (Release) message
// @param event Event with the parameters. 0 if release is started on unspecified interworking
SignallingEvent* SS7ISUPCall::release(SignallingEvent* event, SS7MsgISUP* msg)
{
m_iamTimer.stop();
if (event)
setReason(0,event->message());
else
setReason("interworking",0);
stopWaitSegment(true);
XDebug(isup(),DebugAll,"Call(%u). Releasing call with reason '%s' [%p]",
id(),m_reason.safe(),this);
if (!isup() || m_state >= Releasing) {
m_terminate = true;
return 0;
}
m_iamTimer.interval(isup() ? isup()->m_t1Interval : 1);
m_relTimer.interval(isup() ? isup()->m_t5Interval : 1);
m_iamTimer.start();
m_relTimer.start();
m_state = Releasing;
transmitREL((event && event->message()) ? &(event->message()->params()) : 0);
if (event)
return 0;
bool create = (msg == 0);
if (create)
msg = new SS7MsgISUP(SS7MsgISUP::REL,id());
msg->params().setParam("reason",m_reason);
SignallingEvent* ev = new SignallingEvent(SignallingEvent::Release,msg,this);
// deref() msg if created here. If received, it will be deref()'d in getEvent()
if (create)
TelEngine::destruct(msg);
return ev;
}
// Set termination reason from received text or message
void SS7ISUPCall::setReason(const char* reason, SignallingMessage* msg,
const char* diagnostic, const char* location)
{
if (!m_reason.null())
return;
if (reason) {
m_reason = reason;
m_diagnostic = diagnostic;
m_location = location;
}
else if (msg) {
m_reason = msg->params().getValue(YSTRING("CauseIndicators"),msg->params().getValue(YSTRING("reason")));
m_diagnostic = msg->params().getValue(YSTRING("CauseIndicators.diagnostic"),diagnostic);
m_location = msg->params().getValue(YSTRING("CauseIndicators.location"),location);
}
}
// Accept send/receive messages in current state based on call direction
bool SS7ISUPCall::validMsgState(bool send, SS7MsgISUP::Type type, bool hasBkwCallInd)
{
bool handled = true;
switch (type) {
case SS7MsgISUP::CCR: // Continuity check
if (m_state == Testing && send == outgoing())
return true;
// fall through
case SS7MsgISUP::IAM: // Initial address
if (m_state != Null || send != outgoing())
break;
return true;
case SS7MsgISUP::COT: // Continuity
if (m_state != Testing || send != outgoing())
break;
return true;
case SS7MsgISUP::ACM: // Address complete
case SS7MsgISUP::EXM: // Exit Message (ANSI)
if (m_state != Setup || send == outgoing())
break;
return true;
case SS7MsgISUP::CPR: // Call progress
if (m_state < (hasBkwCallInd ? Setup : Accepted) || m_state >= Releasing)
break;
return true;
case SS7MsgISUP::CON: // Connect
// CON can be sent/received on not accepted calls
if (m_state == Setup && send != outgoing())
return true;
case SS7MsgISUP::ANM: // Answer
if (m_state < (hasBkwCallInd ? Setup : Accepted) || m_state >= Answered || send == outgoing())
break;
return true;
case SS7MsgISUP::SAM: // Subsequent address
if (m_state != Setup || !m_overlap || send != outgoing())
break;
return true;
case SS7MsgISUP::REL: // Release
if (send && m_state >= Releasing)
break;
// fall through
case SS7MsgISUP::RLC: // Release complete
case SS7MsgISUP::CRG: // Charging
if (m_state == Null || m_state == Released)
break;
return true;
case SS7MsgISUP::SUS: // Suspend
case SS7MsgISUP::RES: // Resume
if (m_state != Answered)
break;
return true;
case SS7MsgISUP::SGM: // Segmentation
case SS7MsgISUP::APM: // Application Transport
return true;
default:
handled = false;
}
Debug(isup(),handled?DebugNote:DebugStub,
"Call(%u). Can't %s %smessage '%s' in state %u [%p]",
id(),send?"send":"accept",handled?"":"unhandled ",
SS7MsgISUP::lookup(type,""),m_state,this);
return false;
}
// Connect or test the reserved circuit. Return false if it fails.
// Return true if this call is a signalling only one
bool SS7ISUPCall::connectCircuit(const char* special)
{
bool ok = signalOnly();
if (TelEngine::null(special))
special = 0;
if (m_circuit && !ok) {
u_int64_t t = Time::msecNow();
if (special) {
m_circuit->updateFormat(m_format,0);
ok = m_circuit->setParam("special_mode",special) &&
m_circuit->status(SignallingCircuit::Special);
}
else
ok = m_circuit->connected() || m_circuit->connect(m_format);
t = Time::msecNow() - t;
if (t > 100) {
int level = DebugInfo;
if (t > 300)
level = DebugMild;
else if (t > 200)
level = DebugNote;
Debug(isup(),level,"Call(%u). Spent %u ms connecting circuit [%p]",
id(),(unsigned int)t,this);
}
#ifdef DEBUG
else
Debug(isup(),DebugAll,"Call(%u). Spent %u ms connecting circuit [%p]",
id(),(unsigned int)t,this);
#endif
}
if (!ok)
Debug(isup(),DebugMild,"Call(%u). Circuit %s failed (format='%s')%s [%p]",
id(),(special ? special : "connect"),
m_format.safe(),(m_circuit ? "" : ". No circuit"),this);
if (m_sgmMsg) {
if (m_circuitChanged) {
m_sgmMsg->params().setParam("circuit-change","true");
m_circuitChanged = false;
}
m_sgmMsg->params().setParam("format",m_format);
}
return ok;
}
// Transmit the IAM message. Start IAM timer if not started
bool SS7ISUPCall::transmitIAM()
{
if (!m_iamTimer.started())
m_iamTimer.start();
if (!m_iamMsg)
return false;
if (needsTesting(m_iamMsg)) {
if (m_circuitTesting && !(isup() && isup()->m_continuity)) {
Debug(isup(),DebugWarn,"Call(%u). Continuity check requested but not configured [%p]",
id(),this);
return false;
}
m_state = Testing;
if (m_circuitTesting && !connectCircuit("test:" + isup()->m_continuity))
return false;
Debug(isup(),DebugNote,"Call(%u). %s continuity check [%p]",
id(),(m_circuitTesting ? "Executing" : "Forwarding"),this);
}
else
m_state = Setup;
m_iamMsg->m_cic = id();
m_iamMsg->ref();
// Reset SAM digits: this might be a re-send
m_sentSamDigits = 0;
bool ok = transmitMessage(m_iamMsg);
if (ok && m_overlap)
transmitSAM();
return ok;
}
// Transmit SAM digits
bool SS7ISUPCall::transmitSAM(const char* extra)
{
if (!m_overlap)
return false;
m_samDigits << extra;
while (m_samDigits.length() > m_sentSamDigits) {
unsigned int send = m_samDigits.length() - m_sentSamDigits;
if (send > isup()->m_maxCalledDigits)
send = isup()->m_maxCalledDigits;
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::SAM,id());
String number = m_samDigits.substr(m_sentSamDigits,send);
m->params().addParam("SubsequentNumber",number);
bool complete = !isCalledIncomplete(m->params(),"SubsequentNumber");
bool ok = transmitMessage(m);
if (ok) {
m_sentSamDigits += send;
if (complete) {
if (m_samDigits.length() > m_sentSamDigits)
Debug(isup(),DebugNote,
"Call(%u). Completed number sending remaining='%s' [%p]",
id(),m_samDigits.substr(m_sentSamDigits).c_str(),this);
// Reset overlap sending
setOverlapped(false);
break;
}
}
else {
Debug(isup(),DebugNote,"Call(%u). Failed to send SAM with '%s' [%p]",
id(),number.c_str(),this);
complete = false;
break;
}
}
return true;
}
// (Re)transmit REL. Create and populate the message if needed
// Remember sls
bool SS7ISUPCall::transmitREL(const NamedList* params)
{
if (!isup())
return false;
if (!m_relMsg) {
m_relMsg = new SS7MsgISUP(SS7MsgISUP::REL,id());
if (m_reason)
m_relMsg->params().addParam("CauseIndicators",m_reason);
m_relMsg->params().addParam("CauseIndicators.diagnostic",m_diagnostic,false);
m_relMsg->params().addParam("CauseIndicators.location",m_location,false);
if (params)
copyUpper(m_relMsg->params(),*params);
}
// transmitMessage will dereference message so make sure we preserve it
m_relMsg->ref();
int sls = isup()->transmitMessage(m_relMsg,m_label,false);
if (sls != -1 && m_label.sls() == 255)
m_label.setSls(sls);
return sls != -1;
}
bool SS7ISUPCall::needsTesting(const SS7MsgISUP* msg)
{
if ((m_state >= Testing) || !msg)
return false;
const String* naci = msg->params().getParam(YSTRING("NatureOfConnectionIndicators"));
if (!naci)
return false;
ObjList* list = naci->split(',',false);
m_circuitTesting = (0 != list->find("cont-check-this"));
bool checkIt = m_circuitTesting || (0 != list->find("cont-check-prev"));
TelEngine::destruct(list);
return checkIt;
}
// Stop waiting for a SGM (Segmentation) message. Copy parameters to
// the pending segmented message if sgm is valid.
// Change call state and set m_lastEvent
SignallingEvent* SS7ISUPCall::processSegmented(SS7MsgISUP* sgm, bool timeout)
{
if (sgm)
if (sgm->type() == SS7MsgISUP::SGM) {
// Copy parameters from SGM as defined in Q.763 - Table 49
// (Segmentation message) and Q.764 - 2.1.12 (re-assembly)
#define COPY_PARAM(param) \
m_sgmMsg->params().copyParam(sgm->params(),param); \
m_sgmMsg->params().copyParam(sgm->params(),param,'.');
COPY_PARAM(YSTRING("AccessTranport"))
COPY_PARAM(YSTRING("UserToUserInformation"))
COPY_PARAM(YSTRING("MessageCompatInformation"))
COPY_PARAM(YSTRING("GenericDigits"))
COPY_PARAM(YSTRING("GenericNotification"))
COPY_PARAM(YSTRING("GenericNumber"))
#undef COPY_PARAM
}
else
Debug(isup(),DebugStub,"Call(%u). stopWaitSegment() called with non-SGM message !!! [%p]",
id(),this);
else if (timeout)
Debug(isup(),DebugMild,"Call(%u). Segment waiting message '%s' timed out [%p]",
id(),m_sgmMsg->name(),this);
m_sgmRecvTimer.stop();
// Raise event, connect the reserved circuit, change call state
m_iamTimer.stop();
switch (m_sgmMsg->type()) {
case SS7MsgISUP::COT:
{
const String* cont = m_sgmMsg->params().getParam(YSTRING("ContinuityIndicators"));
bool ok = cont && (*cont == YSTRING("success"));
if (ok) {
Debug(isup(),DebugNote,"Call(%u). Continuity check succeeded [%p]",
id(),this);
m_circuitTesting = false;
}
else {
Debug(isup(),DebugWarn,"Call(%u). Continuity check failed [%p]",
id(),this);
m_contTimer.start();
break;
}
if (!(ok && m_iamMsg)) {
m_lastEvent = new SignallingEvent(SignallingEvent::Info,m_sgmMsg,this);
break;
}
}
TelEngine::destruct(m_sgmMsg);
m_sgmMsg = m_iamMsg;
m_iamMsg = 0;
// intentionally fall through
case SS7MsgISUP::IAM:
if (needsTesting(m_sgmMsg)) {
m_state = Testing;
if (m_circuitTesting && !(isup() && isup()->m_continuity)) {
Debug(isup(),DebugWarn,"Call(%u). Continuity check requested but not configured [%p]",
id(),this);
setTerminate(true,"service-not-implemented",0,isup()->location());
break;
}
if (m_circuitTesting && !connectCircuit(isup()->m_continuity)) {
setTerminate(true,"bearer-cap-not-available",0,isup()->location());
break;
}
Debug(isup(),DebugNote,"Call(%u). Waiting for continuity check [%p]",
id(),this);
// Save message for later
m_iamMsg = m_sgmMsg;
m_sgmMsg = 0;
return 0;
}
m_state = Setup;
if (!connectCircuit() && isup() &&
(isup()->mediaRequired() >= SignallingCallControl::MediaAlways)) {
setTerminate(true,"bearer-cap-not-available",0,isup()->location());
break;
}
m_sgmMsg->params().setParam("overlapped",String::boolText(m_overlap));
m_lastEvent = new SignallingEvent(SignallingEvent::NewCall,m_sgmMsg,this);
break;
case SS7MsgISUP::CCR:
if (m_state < Testing) {
m_state = Testing;
if (!(isup() && isup()->m_continuity)) {
Debug(isup(),DebugWarn,"Call(%u). Continuity check requested but not configured [%p]",
id(),this);
setTerminate(true,"service-not-implemented",0,isup()->location());
break;
}
m_circuitTesting = true;
if (!connectCircuit(isup()->m_continuity)) {
setTerminate(true,"bearer-cap-not-available",0,isup()->location());
break;
}
Debug(isup(),DebugNote,"Call(%u). Continuity test only [%p]",
id(),this);
}
else if (!m_circuitTesting) {
setTerminate(true,"wrong-state-message",0,isup()->location());
break;
}
m_contTimer.stop();
m_iamTimer.start();
if (isup()->m_confirmCCR)
transmitMessage(new SS7MsgISUP(SS7MsgISUP::LPA,id()));
break;
case SS7MsgISUP::ACM:
m_state = Accepted;
if (!connectCircuit() && isup() &&
(isup()->mediaRequired() >= SignallingCallControl::MediaAlways)) {
setReason("bearer-cap-not-available",0,0,isup()->location());
m_lastEvent = release();
break;
}
m_lastEvent = 0;
m_inbandAvailable = m_inbandAvailable ||
SignallingUtils::hasFlag(m_sgmMsg->params(),"OptionalBackwardCallIndicators","inband");
if (isup() && isup()->m_earlyAcm) {
// If the called party is known free report ringing
// If it may become free or there is inband audio report progress
bool ring = SignallingUtils::hasFlag(m_sgmMsg->params(),"BackwardCallIndicators","called-free");
if (m_inbandAvailable || ring || SignallingUtils::hasFlag(m_sgmMsg->params(),"BackwardCallIndicators","called-conn")) {
m_sgmMsg->params().setParam("earlymedia",String::boolText(m_inbandAvailable));
m_lastEvent = new SignallingEvent(ring ? SignallingEvent::Ringing : SignallingEvent::Progress,m_sgmMsg,this);
}
}
if (!m_lastEvent) {
m_sgmMsg->params().setParam("earlymedia",String::boolText(m_inbandAvailable));
m_lastEvent = new SignallingEvent(SignallingEvent::Accept,m_sgmMsg,this);
}
// intentionally fall through
case SS7MsgISUP::EXM:
// Start T9 timer
if (m_anmTimer.interval() && !m_anmTimer.started())
m_anmTimer.start();
break;
case SS7MsgISUP::CPR:
m_state = Ringing;
if (!connectCircuit() && isup() &&
(isup()->mediaRequired() >= SignallingCallControl::MediaRinging)) {
setTerminate(true,"bearer-cap-not-available",0,isup()->location());
break;
}
m_inbandAvailable = m_inbandAvailable ||
SignallingUtils::hasFlag(m_sgmMsg->params(),"OptionalBackwardCallIndicators","inband") ||
SignallingUtils::hasFlag(m_sgmMsg->params(),"EventInformation","inband");
m_sgmMsg->params().setParam("earlymedia",String::boolText(m_inbandAvailable));
m_lastEvent = new SignallingEvent(
SignallingUtils::hasFlag(m_sgmMsg->params(),"EventInformation","ringing")
? SignallingEvent::Ringing : SignallingEvent::Progress,
m_sgmMsg,this);
break;
case SS7MsgISUP::ANM:
case SS7MsgISUP::CON:
m_state = Answered;
m_anmTimer.stop();
if (!connectCircuit() && isup() &&
(isup()->mediaRequired() >= SignallingCallControl::MediaAnswered)) {
setTerminate(true,"bearer-cap-not-available",0,isup()->location());
break;
}
m_lastEvent = new SignallingEvent(SignallingEvent::Answer,m_sgmMsg,this);
break;
case SS7MsgISUP::CRG:
m_lastEvent = new SignallingEvent(SignallingEvent::Charge,m_sgmMsg,this);
break;
default:
Debug(isup(),DebugStub,"Call(%u). Segment waiting message is '%s' [%p]",
id(),m_sgmMsg->name(),this);
}
TelEngine::destruct(m_sgmMsg);
return m_lastEvent;
}
// Transmit message. Set routing label's link if not already set
bool SS7ISUPCall::transmitMessage(SS7MsgISUP* msg)
{
if (!msg || !isup()) {
TelEngine::destruct(msg);
return false;
}
DDebug(isup(),DebugAll,"Call(%u). Transmitting messsage (%s,%p) [%p]",
id(),msg->name(),msg,this);
int sls = isup()->transmitMessage(msg,m_label,false);
if (sls == -1)
return false;
if (m_label.sls() == 255)
m_label.setSls(sls);
return true;
}
SS7ISUP* SS7ISUPCall::isup() const
{
return static_cast<SS7ISUP*>(SignallingCall::controller());
}
// Set overlapped flag. Output a debug message
void SS7ISUPCall::setOverlapped(bool on, bool numberComplete)
{
if (m_overlap == on)
return;
m_overlap = on;
const char* reason = on ? "" : (numberComplete ? " (number complete)" : " (state changed)");
Debug(isup(),DebugAll,"Call(%u). Overlapped dialing is %s%s [%p]",
id(),String::boolText(on),reason,this);
}
/**
* SS7ISUP
*/
SS7ISUP::SS7ISUP(const NamedList& params, unsigned char sio)
: SignallingComponent(params.safe("SS7ISUP"),&params,"ss7-isup"),
SignallingCallControl(params,"isup."),
SS7Layer4(sio,&params),
m_cicLen(2),
m_type(SS7PointCode::Other),
m_defPoint(0),
m_remotePoint(0),
m_sls(255),
m_earlyAcm(true),
m_inn(false),
m_defaultSls(SlsLatest),
m_maxCalledDigits(16),
m_confirmCCR(true),
m_dropOnUnknown(true),
m_ignoreGRSSingle(false),
m_ignoreCGBSingle(false),
m_ignoreCGUSingle(false),
m_duplicateCGB(false),
m_ignoreUnkDigits(true),
m_l3LinkUp(false),
m_chargeProcessType(Confusion),
m_t1Interval(15000), // Q.764 T1 15..60 seconds
m_t5Interval(300000), // Q.764 T5 5..15 minutes
m_t7Interval(ISUP_T7_DEFVAL), // Q.764 T7 20..30 seconds
m_t9Interval(0), // Q.764 T9 Q.118 1.5 - 3 minutes, not always used
m_t12Interval(20000), // Q.764 T12 (BLK) 15..60 seconds
m_t13Interval(300000), // Q.764 T13 (BLK global) 5..15 minutes
m_t14Interval(20000), // Q.764 T14 (UBL) 15..60 seconds
m_t15Interval(300000), // Q.764 T15 (UBL global) 5..15 minutes
m_t16Interval(20000), // Q.764 T16 (RSC) 15..60 seconds
m_t17Interval(300000), // Q.764 T17 5..15 minutes
m_t18Interval(20000), // Q.764 T18 (CGB) 15..60 seconds
m_t19Interval(300000), // Q.764 T19 (CGB global) 5..15 minutes
m_t20Interval(20000), // Q.764 T20 (CGU) 15..60 seconds
m_t21Interval(300000), // Q.764 T21 (CGU global) 5..15 minutes
m_t27Interval(ISUP_T27_DEFVAL), // Q.764 T27 4 minutes
m_t34Interval(ISUP_T34_DEFVAL), // Q.764 T34 2..4 seconds
m_uptTimer(0),
m_userPartAvail(true),
m_uptMessage(SS7MsgISUP::UPT),
m_uptCicCode(0),
m_cicWarnLevel(DebugMild),
m_replaceCounter(3),
m_rscTimer(0),
m_rscCic(0),
m_rscSpeedup(0),
m_lockTimer(2000),
m_lockGroup(true),
m_printMsg(false),
m_extendedDebug(false)
{
#ifdef DEBUG
if (debugAt(DebugAll)) {
String tmp;
params.dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugAll,"SS7ISUP::SS7ISUP(%p) [%p]%s",
&params,this,tmp.c_str());
}
#endif
const char* stype = params.getValue(YSTRING("pointcodetype"));
m_type = SS7PointCode::lookup(stype);
if (m_type == SS7PointCode::Other) {
Debug(this,DebugWarn,"Invalid point code type '%s'",c_safe(stype));
return;
}
if (m_type == SS7PointCode::ITU)
m_defaultSls = SlsCircuit;
m_format = params.getValue(YSTRING("format"));
if (-1 == lookup(m_format,SignallingUtils::dict(1,0),-1))
switch (m_type) {
case SS7PointCode::ANSI:
case SS7PointCode::ANSI8:
case SS7PointCode::Japan:
case SS7PointCode::Japan5:
m_format = "mulaw";
break;
default:
m_format = "alaw";
}
const char* rpc = params.getValue(YSTRING("remotepointcode"));
m_remotePoint = new SS7PointCode(0,0,0);
if (!(m_remotePoint->assign(rpc,m_type) && m_remotePoint->pack(m_type))) {
Debug(this,DebugMild,"Invalid remotepointcode='%s'",rpc);
TelEngine::destruct(m_remotePoint);
}
m_lockGroup = params.getBoolValue(YSTRING("lockgroup"),m_lockGroup);
m_earlyAcm = params.getBoolValue(YSTRING("earlyacm"),m_earlyAcm);
m_inn = params.getBoolValue(YSTRING("inn"),m_inn);
m_numPlan = params.getValue(YSTRING("numplan"));
if (-1 == lookup(m_numPlan,s_dict_numPlan,-1))
m_numPlan = "unknown";
m_numType = params.getValue(YSTRING("numtype"));
if (-1 == lookup(m_numType,s_dict_nai,-1))
m_numType = "unknown";
m_numPresentation = params.getValue(YSTRING("presentation"));
if (-1 == lookup(m_numPresentation,s_dict_presentation,-1))
m_numPresentation = "allowed";
m_numScreening = params.getValue(YSTRING("screening"));
if (-1 == lookup(m_numScreening,s_dict_screening,-1))
m_numScreening = "user-provided";
m_callerCat = params.getValue(YSTRING("callercategory"));
if (-1 == lookup(m_callerCat,s_dict_callerCat,-1))
m_callerCat = "ordinary";
m_rscTimer.interval(params,"channelsync",60,300,true,true);
m_rscInterval = m_rscTimer.interval();
// Remote user part test
m_uptTimer.interval(params,"userparttest",10,60,true,true);
if (m_uptTimer.interval())
m_userPartAvail = false;
else
m_lockTimer.start();
// Timers
m_t7Interval = SignallingTimer::getInterval(params,"t7",ISUP_T7_MINVAL,ISUP_T7_DEFVAL,ISUP_T7_MAXVAL,false);
m_t9Interval = SignallingTimer::getInterval(params,"t9",ISUP_T9_MINVAL,ISUP_T9_DEFVAL,ISUP_T9_MAXVAL,true);
m_t27Interval = SignallingTimer::getInterval(params,"t27",ISUP_T27_MINVAL,ISUP_T27_DEFVAL,ISUP_T27_MAXVAL,false);
m_t34Interval = SignallingTimer::getInterval(params,"t34",ISUP_T34_MINVAL,ISUP_T34_DEFVAL,ISUP_T34_MAXVAL,false);
m_continuity = params.getValue(YSTRING("continuity"));
m_confirmCCR = params.getBoolValue(YSTRING("confirm_ccr"),true);
m_dropOnUnknown = params.getBoolValue(YSTRING("drop_unknown"),true);
m_ignoreGRSSingle = params.getBoolValue(YSTRING("ignore-grs-single"));
m_ignoreCGBSingle = params.getBoolValue(YSTRING("ignore-cgb-single"));
m_ignoreCGUSingle = params.getBoolValue(YSTRING("ignore-cgu-single"));
m_duplicateCGB = params.getBoolValue(YSTRING("duplicate-cgb"),
(SS7PointCode::ANSI == m_type || SS7PointCode::ANSI8 == m_type));
m_chargeProcessType = (ChargeProcess)params.getIntValue(YSTRING("charge-process"),s_dict_CRG_process,m_chargeProcessType);
int testMsg = params.getIntValue(YSTRING("parttestmsg"),s_names,SS7MsgISUP::UPT);
switch (testMsg) {
case SS7MsgISUP::CVT:
if (SS7PointCode::ANSI != m_type && SS7PointCode::ANSI8 != m_type)
break;
// fall through
case SS7MsgISUP::RSC:
case SS7MsgISUP::UBL:
case SS7MsgISUP::UPT:
m_uptMessage = (SS7MsgISUP::Type)testMsg;
}
m_replaceCounter = params.getIntValue(YSTRING("max_replaces"),3,0,31);
m_ignoreUnkDigits = params.getBoolValue(YSTRING("ignore-unknown-digits"),true);
m_defaultSls = params.getIntValue(YSTRING("sls"),s_dict_callSls,m_defaultSls);
m_maxCalledDigits = params.getIntValue(YSTRING("maxcalleddigits"),m_maxCalledDigits);
if (m_maxCalledDigits < 1)
m_maxCalledDigits = 16;
setDebug(params.getBoolValue(YSTRING("print-messages"),false),
params.getBoolValue(YSTRING("extended-debug"),false));
if (debugAt(DebugInfo)) {
String s;
s << "pointcode-type=" << stype;
s << " format=" << m_format;
s << " plan/type/pres/screen=" << m_numPlan << "/" << m_numType << "/"
<< m_numPresentation << "/" << m_numScreening;
s << " caller-category=" << m_callerCat;
s << " remote-pointcode=";
if (m_remotePoint)
s << *m_remotePoint;
else
s << "missing";
s << " SIF/SSF=" << (unsigned int)sif() << "/" << (unsigned int)ssf();
s << " lockcircuits=" << params.getValue(YSTRING("lockcircuits"));
s << " userpartavail=" << String::boolText(m_userPartAvail);
s << " lockgroup=" << String::boolText(m_lockGroup);
s << " mediareq=" << lookup(m_mediaRequired,s_mediaRequired);
const char* sls = lookup(m_defaultSls,s_dict_callSls);
s << " outboundsls=";
if (sls)
s << sls;
else
s << m_defaultSls;
if (m_continuity)
s << " continuity=" << m_continuity;
Debug(this,DebugInfo,"ISUP Call Controller %s [%p]",s.c_str(),this);
}
}
SS7ISUP::~SS7ISUP()
{
cleanup();
if (m_remotePoint)
m_remotePoint->destruct();
Debug(this,DebugInfo,"ISUP Call Controller destroyed [%p]",this);
}
bool SS7ISUP::initialize(const NamedList* config)
{
#ifdef DEBUG
String tmp;
if (config && debugAt(DebugAll))
config->dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugInfo,"SS7ISUP::initialize(%p) [%p]%s",config,this,tmp.c_str());
#endif
if (config) {
debugLevel(config->getIntValue(YSTRING("debuglevel_isup"),
config->getIntValue(YSTRING("debuglevel"),-1)));
setDebug(config->getBoolValue(YSTRING("print-messages"),false),
config->getBoolValue(YSTRING("extended-debug"),false));
m_lockGroup = config->getBoolValue(YSTRING("lockgroup"),m_lockGroup);
m_earlyAcm = config->getBoolValue(YSTRING("earlyacm"),m_earlyAcm);
m_continuity = config->getValue(YSTRING("continuity"),m_continuity);
m_confirmCCR = config->getBoolValue(YSTRING("confirm_ccr"),true);
m_dropOnUnknown = config->getBoolValue(YSTRING("drop_unknown"),true);
m_ignoreGRSSingle = config->getBoolValue(YSTRING("ignore-grs-single"));
m_ignoreCGBSingle = config->getBoolValue(YSTRING("ignore-cgb-single"));
m_ignoreCGUSingle = config->getBoolValue(YSTRING("ignore-cgu-single"));
m_duplicateCGB = config->getBoolValue(YSTRING("duplicate-cgb"),
(SS7PointCode::ANSI == m_type || SS7PointCode::ANSI8 == m_type));
int testMsg = config->getIntValue(YSTRING("parttestmsg"),s_names,SS7MsgISUP::UPT);
switch (testMsg) {
case SS7MsgISUP::CVT:
if (SS7PointCode::ANSI != m_type && SS7PointCode::ANSI8 != m_type)
break;
// fall through
case SS7MsgISUP::RSC:
case SS7MsgISUP::UBL:
case SS7MsgISUP::UPT:
m_uptMessage = (SS7MsgISUP::Type)testMsg;
}
m_replaceCounter = config->getIntValue(YSTRING("max_replaces"),3,0,31);
m_ignoreUnkDigits = config->getBoolValue(YSTRING("ignore-unknown-digits"),true);
m_defaultSls = config->getIntValue(YSTRING("sls"),s_dict_callSls,m_defaultSls);
m_chargeProcessType = (ChargeProcess)config->getIntValue(YSTRING("charge-process"),s_dict_CRG_process,m_chargeProcessType);
m_mediaRequired = (MediaRequired)config->getIntValue(YSTRING("needmedia"),
s_mediaRequired,m_mediaRequired);
// Timers
m_t7Interval = SignallingTimer::getInterval(*config,"t7",ISUP_T7_MINVAL,ISUP_T7_DEFVAL,ISUP_T7_MAXVAL,false);
m_t9Interval = SignallingTimer::getInterval(*config,"t9",ISUP_T9_MINVAL,ISUP_T9_DEFVAL,ISUP_T9_MAXVAL,true);
m_t27Interval = SignallingTimer::getInterval(*config,"t27",ISUP_T27_MINVAL,ISUP_T27_DEFVAL,ISUP_T27_MAXVAL,false);
m_t34Interval = SignallingTimer::getInterval(*config,"t34",ISUP_T34_MINVAL,ISUP_T34_DEFVAL,ISUP_T34_MAXVAL,false);
}
m_cicWarnLevel = DebugMild;
return SS7Layer4::initialize(config);
}
const char* SS7ISUP::statusName() const
{
if (exiting())
return "Exiting";
if (!m_l3LinkUp)
return "Layer 3 down";
if (!m_userPartAvail)
return "Remote unavailable";
if (!m_defPoint)
return "No local PC set";
if (!m_remotePoint)
return "No remote PC set";
return "Operational";
}
void SS7ISUP::attach(SS7Layer3* network)
{
SS7Layer4::attach(network);
m_l3LinkUp = network && network->operational();
}
// Append a point code to the list of point codes serviced by this controller
// Set default point code
bool SS7ISUP::setPointCode(SS7PointCode* pc, bool def)
{
if (!(pc && pc->pack(m_type)))
return false;
Lock mylock(this);
// Force default if we are not having one or the list is empty
def = def || !m_defPoint || !m_pointCodes.skipNull();
// Force not default if the received point code is the same as the default one
if (def && m_defPoint && *m_defPoint == *pc)
def = false;
SS7PointCode* p = hasPointCode(*pc);
if (def)
m_defPoint = p ? p : pc;
String tmp;
tmp << (def ? *m_defPoint : *pc);
if (!p) {
m_pointCodes.append(pc);
DDebug(this,DebugAll,"Added new point code '%s'%s",tmp.safe(),def?". Set to default":"");
}
else {
TelEngine::destruct(pc);
if (def)
Debug(this,DebugAll,"Set default point code '%s'",tmp.safe());
}
return true;
}
// Add all point codes described in a parameter list
unsigned int SS7ISUP::setPointCode(const NamedList& params)
{
unsigned int count = 0;
unsigned int n = params.length();
bool hadDef = false;
for (unsigned int i= 0; i < n; i++) {
NamedString* ns = params.getParam(i);
if (!ns)
continue;
bool defPc = false;
if (ns->name() == YSTRING("defaultpointcode"))
defPc = true;
else if (ns->name() != YSTRING("pointcode"))
continue;
SS7PointCode* pc = new SS7PointCode(0,0,0);
if (pc->assign(*ns,m_type) && setPointCode(pc,defPc && !hadDef)) {
count++;
if (defPc) {
if (hadDef)
Debug(this,DebugMild,"Added point code '%s' as non-default",ns->safe());
else
hadDef = true;
}
}
else {
Debug(this,DebugWarn,"Invalid '%s'='%s' in parameters '%s'",
ns->name().c_str(),ns->safe(),params.safe());
TelEngine::destruct(pc);
}
}
return count;
}
// Check if the given point code is serviced by this controller
SS7PointCode* SS7ISUP::hasPointCode(const SS7PointCode& pc)
{
Lock mylock(this);
for (ObjList* o = m_pointCodes.skipNull(); o; o = o->skipNext()) {
SS7PointCode* p = static_cast<SS7PointCode*>(o->get());
if (*p == pc)
return p;
}
return 0;
}
SS7MSU* SS7ISUP::createMSU(SS7MsgISUP::Type type, unsigned char ssf,
const SS7Label& label, unsigned int cic, const NamedList* params) const
{
return buildMSU(type,sif() | (ssf & 0xf0),label,cic,params);
}
// Make an outgoing call
SignallingCall* SS7ISUP::call(SignallingMessage* msg, String& reason)
{
if (!msg) {
reason = "noconn";
return 0;
}
if (exiting() || !m_l3LinkUp) {
Debug(this,DebugInfo,"Denying outgoing call request, reason: %s.",
exiting() ? "exiting" : "L3 down");
TelEngine::destruct(msg);
reason = "net-out-of-order";
return 0;
}
if (!m_userPartAvail) {
Debug(this,DebugNote,"Remote User Part is unavailable");
TelEngine::destruct(msg);
reason = "noconn";
return 0;
}
SS7PointCode dest;
SignallingCircuit* cic = 0;
const char* range = msg->params().getValue(YSTRING("circuits"));
reason.clear();
Lock mylock(this);
// Check
while (true) {
if (!m_defPoint) {
Debug(this,DebugNote,"Source point code is missing");
reason = "noconn";
break;
}
String pc = msg->params().getValue(YSTRING("calledpointcode"));
if (!(dest.assign(pc,m_type) && dest.pack(m_type))) {
if (!m_remotePoint) {
Debug(this,DebugNote,
"Destination point code is missing (calledpointcode=%s)",pc.safe());
reason = "noconn";
break;
}
dest = *m_remotePoint;
}
for (int attempts = 3; attempts; attempts--) {
if (!reserveCircuit(cic,range,SignallingCircuit::LockLockedBusy)) {
Debug(this,DebugNote,"Can't reserve circuit");
break;
}
SS7ISUPCall* call2 = findCall(cic->code());
if (!call2)
break;
Debug(this,DebugWarn,"Circuit %u is already used by call %p",
cic->code(),call2);
TelEngine::destruct(cic);
}
if (!cic)
reason = "congestion";
break;
}
SS7ISUPCall* call = 0;
if (reason.null()) {
String* cicParams = msg->params().getParam(YSTRING("circuit_parameters"));
if (cicParams) {
NamedList* p = YOBJECT(NamedList,cicParams);
if (p)
cic->setParams(*p);
}
int sls = msg->params().getIntValue(YSTRING("sls"),s_dict_callSls,m_defaultSls);
switch (sls) {
case SlsCircuit:
if (cic) {
sls = cic->code();
break;
}
// fall through
case SlsLatest:
sls = m_sls;
break;
}
call = new SS7ISUPCall(this,cic,*m_defPoint,dest,true,sls,range);
call->ref();
m_calls.append(call);
SignallingEvent* event = new SignallingEvent(SignallingEvent::NewCall,msg,call);
// (re)start RSC timer if not currently reseting
if (!m_rscCic && m_rscTimer.interval())
m_rscTimer.start();
// Drop lock and send the event
mylock.drop();
if (!event->sendEvent()) {
call->setTerminate(false,"failure");
TelEngine::destruct(call);
reason = "failure";
}
}
TelEngine::destruct(msg);
return call;
}
// Converts an ISUP message to a Message Signal Unit and push it down the protocol stack
// The given message is consumed
int SS7ISUP::transmitMessage(SS7MsgISUP* msg, const SS7Label& label, bool recvLbl, int sls)
{
if (!msg)
return -1;
const SS7Label* p = &label;
SS7Label tmp;
if (recvLbl) {
switch (sls) {
case SlsCircuit:
sls = msg->cic();
break;
case SlsLatest:
sls = m_sls;
break;
case SlsDefault:
sls = label.sls();
break;
}
tmp.assign(label.type(),label.opc(),label.dpc(),sls,label.spare());
p = &tmp;
}
lock();
SS7MSU* msu = createMSU(msg->type(),ssf(),*p,msg->cic(),&msg->params());
if (m_printMsg && debugAt(DebugInfo)) {
String tmp;
void* data = 0;
unsigned int len = 0;
if (m_extendedDebug && msu) {
unsigned int offs = 2 + label.length() + m_cicLen;
data = msu->getData(offs);
len = data ? msu->length() - offs : 0;
}
msg->toString(tmp,*p,debugAt(DebugAll),data,len);
Debug(this,DebugInfo,"Sending message (%p)%s",msg,tmp.c_str());
}
else if (debugAt(DebugAll)) {
String tmp;
tmp << *p;
Debug(this,DebugAll,"Sending message '%s' cic=%u label=%s",
msg->name(),msg->cic(),tmp.c_str());
}
sls = -1;
if (msu && m_l3LinkUp) {
unlock();
sls = transmitMSU(*msu,*p,p->sls());
lock();
if ((m_sls == 255) && (sls != -1))
m_sls = (unsigned char)sls;
}
unlock();
#ifdef XDEBUG
if (sls == -1)
Debug(this,DebugMild,"Failed to send message (%p): '%s'",msg,msg->name());
#endif
TelEngine::destruct(msu);
TelEngine::destruct(msg);
return sls;
}
void SS7ISUP::cleanup(const char* reason)
{
ObjList terminate;
lock();
for (ObjList* o = m_calls.skipNull(); o; o = o->skipNext()) {
SS7ISUPCall* call = static_cast<SS7ISUPCall*>(o->get());
if (call->ref())
terminate.append(call);
}
releaseCircuit(m_rscCic);
m_rscTimer.stop();
unlock();
setCallsTerminate(terminate,true,reason);
clearCalls();
}
// Remove all links with other layers. Disposes the memory
void SS7ISUP::destroyed()
{
lock();
clearCalls();
unlock();
SignallingCallControl::attach(0);
SS7Layer4::destroyed();
}
// Utility: find a pending (un)block message for a given circuit
static bool findPendingMsgTimerLock(ObjList& list, unsigned int code)
{
for (ObjList* o = list.skipNull(); o; o = o->skipNext()) {
SignallingMessageTimer* m = static_cast<SignallingMessageTimer*>(o->get());
SS7MsgISUP* msg = static_cast<SS7MsgISUP*>(m->message());
if (!msg || code < msg->cic())
continue;
if (msg->type() == SS7MsgISUP::BLK || msg->type() == SS7MsgISUP::UBL) {
if (msg->cic() == code)
return true;
continue;
}
if (msg->type() != SS7MsgISUP::CGB && msg->type() != SS7MsgISUP::CGU)
continue;
const String& map = msg->params()[YSTRING("RangeAndStatus.map")];
if (map[code - msg->cic()] == '1')
return true;
}
return false;
}
void SS7ISUP::timerTick(const Time& when)
{
Lock mylock(this,SignallingEngine::maxLockWait());
if (!(mylock.locked() && m_l3LinkUp && circuits()))
return;
// Test remote user part
if (m_remotePoint && !m_userPartAvail && m_uptTimer.interval()) {
if (m_uptTimer.started()) {
if (!m_uptTimer.timeout(when.msec()))
return;
DDebug(this,DebugNote,"%s timed out. Retransmitting",lookup(m_uptMessage,s_names));
}
ObjList* o = circuits()->circuits().skipNull();
SignallingCircuit* cic = o ? static_cast<SignallingCircuit*>(o->get()) : 0;
m_uptCicCode = cic ? cic->code() : 1;
SS7MsgISUP* msg = new SS7MsgISUP(m_uptMessage,m_uptCicCode);
SS7Label label(m_type,*m_remotePoint,*m_defPoint,
(m_defaultSls == SlsCircuit) ? m_uptCicCode : m_sls);
m_uptTimer.start(when.msec());
mylock.drop();
transmitMessage(msg,label,false);
return;
}
// Blocking/unblocking circuits
if (m_lockTimer.timeout(when.msec())) {
DDebug(this,DebugAll,"Re-checking local lock sending");
m_lockTimer.stop();
mylock.drop();
sendLocalLock(when);
return;
}
// Pending messages
ObjList reInsert;
ObjList sendMsgs;
ObjList rsc;
while (true) {
SignallingMessageTimer* m = m_pending.timeout(when);
if (!m)
break;
SS7MsgISUP* msg = static_cast<SS7MsgISUP*>(m->message());
if (!msg) {
TelEngine::destruct(m);
continue;
}
if (msg->type() != SS7MsgISUP::RSC &&
msg->type() != SS7MsgISUP::REL &&
msg->type() != SS7MsgISUP::CGB &&
msg->type() != SS7MsgISUP::CGU &&
msg->type() != SS7MsgISUP::BLK &&
msg->type() != SS7MsgISUP::UBL) {
Debug(this,DebugStub,"Unhandled pending message '%s'",msg->name());
TelEngine::destruct(m);
continue;
}
// Global timer timed out: set retransmission timer from it
if (m->global().timeout(when.msec())) {
if (msg->type() != SS7MsgISUP::REL) {
m->interval(m->global().interval());
m->global().stop();
m->global().interval(0);
msg->params().setParam("isup_alert_maint",String::boolText(true));
}
else {
Debug(this,DebugNote,"Pending operation '%s' cic=%u timed out",
msg->name(),msg->cic());
SignallingCircuit* c = circuits() ? circuits()->find(msg->cic()) : 0;
TelEngine::destruct(m);
if (c && c->ref())
rsc.append(c)->setDelete(false);
continue;
}
}
// Check if message is still in use
if (msg->type() == SS7MsgISUP::CGB || msg->type() == SS7MsgISUP::CGU) {
String* map = msg->params().getParam(YSTRING("RangeAndStatus.map"));
bool ok = !TelEngine::null(map);
String removedCics;
if (ok) {
unsigned int nCics = 0;
int flg = 0;
int flgReset = 0;
if ((msg->params()[YSTRING("GroupSupervisionTypeIndicator")] == YSTRING("hw-failure"))) {
flg = SignallingCircuit::LockLocalHWFail;
flgReset = SignallingCircuit::LockingHWFail;
}
else {
flg = SignallingCircuit::LockLocalMaint;
flgReset = SignallingCircuit::LockingMaint;
}
int on = (msg->type() == SS7MsgISUP::CGB) ? flg : 0;
char* s = (char*)map->c_str();
for (unsigned int i = 0; i < map->length(); i++) {
if (s[i] == '0')
continue;
unsigned int code = msg->cic() + i;
SignallingCircuit* cic = circuits()->find(code);
if (cic && (on == cic->locked(flg))) {
nCics++;
continue;
}
// Don't reset locking flag if there is another operation in progress
if (cic && !(findPendingMsgTimerLock(m_pending,code) ||
findPendingMsgTimerLock(reInsert,code)) && cic->locked(flgReset)) {
cic->resetLock(flgReset);
Debug(this,DebugNote,"Pending %s reset flag=0x%x cic=%u current=0x%x",
msg->name(),flgReset,code,cic->locked());;
}
s[i] = '0';
removedCics.append(String(code),",");
}
if (nCics)
msg->params().setParam("RangeAndStatus",String(nCics));
else
ok = false;
}
if (!ok) {
Debug(this,DebugNote,"Removed empty pending operation '%s' cic=%u",
msg->name(),msg->cic());
TelEngine::destruct(m);
continue;
}
if (removedCics)
Debug(this,DebugAll,"Removed cics=%s from pending operation '%s' map cic=%u",
removedCics.c_str(),msg->name(),msg->cic());
}
else if (msg->type() == SS7MsgISUP::BLK || msg->type() == SS7MsgISUP::UBL) {
// We set the following param when sending BLK/UBL for HW fail reason
bool maint = !msg->params().getBoolValue(YSTRING("isup_pending_block_hwfail"));
int flg = maint ? SignallingCircuit::LockLocalMaint : SignallingCircuit::LockLocalHWFail;
int on = (msg->type() == SS7MsgISUP::BLK) ? flg : 0;
SignallingCircuit* cic = circuits()->find(msg->cic());
if (!cic || on != cic->locked(flg)) {
flg = maint ? SignallingCircuit::LockingMaint : SignallingCircuit::LockingHWFail;
// Don't reset locking flag if there is another operation in progress
if (cic && !(findPendingMsgTimerLock(m_pending,msg->cic()) ||
findPendingMsgTimerLock(reInsert,msg->cic())) && cic->locked(flg)) {
cic->resetLock(flg);
Debug(this,DebugNote,"Pending %s reset flag=0x%x cic=%u current=0x%x",
msg->name(),flg,cic->code(),cic->locked());
}
Debug(this,DebugNote,"Removed empty pending operation '%s' cic=%u",
msg->name(),msg->cic());
TelEngine::destruct(m);
continue;
}
}
bool alert = msg->params().getBoolValue(YSTRING("isup_alert_maint"));
const char* reason = msg->params().getValue(YSTRING("isup_pending_reason"),"");
Debug(this,!alert ? DebugAll : DebugMild,
"Pending operation '%s' cic=%u reason='%s' timed out",
msg->name(),msg->cic(),reason);
if (alert) {
// TODO: alert maintenance
}
msg->ref();
reInsert.append(m)->setDelete(false);
sendMsgs.append(msg)->setDelete(false);
}
// Re-insert
ObjList* o = reInsert.skipNull();
ObjList* oRsc = rsc.skipNull();
if (o || oRsc) {
for (; o; o = o->skipNext())
m_pending.add(static_cast<SignallingMessageTimer*>(o->get()),when);
mylock.drop();
transmitMessages(sendMsgs);
for (; oRsc; oRsc = oRsc->skipNext()) {
SignallingCircuit* c = static_cast<SignallingCircuit*>(oRsc->get());
c->resetLock(SignallingCircuit::Resetting);
startCircuitReset(c,"T5");
}
return;
}
// Circuit reset disabled ?
if (!m_rscTimer.interval())
return;
if (m_rscTimer.started()) {
if (!m_rscTimer.timeout(when.msec()))
return;
m_rscTimer.stop();
if (m_rscCic) {
Debug(this,DebugMild,"Circuit reset timed out for cic=%u",m_rscCic->code());
m_rscCic->resetLock(SignallingCircuit::Resetting);
releaseCircuit(m_rscCic);
return;
}
}
if (m_rscSpeedup && !--m_rscSpeedup) {
Debug(this,DebugNote,"Reset interval back to %u ms",m_rscInterval);
m_rscTimer.interval(m_rscInterval);
}
m_rscTimer.start(when.msec());
// Pick the next circuit to reset. Ignore circuits locally locked or busy
if (m_defPoint && m_remotePoint &&
reserveCircuit(m_rscCic,0,SignallingCircuit::LockLocal | SignallingCircuit::LockBusy)) {
// Avoid already resetting cic
if (!findPendingMessage(SS7MsgISUP::RSC,m_rscCic->code())) {
m_rscCic->setLock(SignallingCircuit::Resetting);
SS7MsgISUP* msg = new SS7MsgISUP(SS7MsgISUP::RSC,m_rscCic->code());
SS7Label label(m_type,*m_remotePoint,*m_defPoint,
(m_defaultSls == SlsCircuit) ? m_rscCic->code() : m_sls);
DDebug(this,DebugNote,"Periodic restart on cic=%u",m_rscCic->code());
mylock.drop();
transmitMessage(msg,label,false);
}
else
releaseCircuit(m_rscCic);
}
}
// Process a component control request
bool SS7ISUP::control(NamedList& params)
{
String* ret = params.getParam(YSTRING("completion"));
const String* oper = params.getParam(YSTRING("operation"));
const char* cmp = params.getValue(YSTRING("component"));
int cmd = oper ? oper->toInteger(s_dict_control,-1) : -1;
if (ret) {
if (oper && (cmd < 0))
return false;
String part = params.getValue(YSTRING("partword"));
if (cmp) {
if (toString() != cmp)
return false;
for (const TokenDict* d = s_dict_control; d->token; d++)
Module::itemComplete(*ret,d->token,part);
return true;
}
return Module::itemComplete(*ret,toString(),part);
}
if (!(cmp && toString() == cmp))
return false;
Lock mylock(this);
if (!m_remotePoint)
return TelEngine::controlReturn(&params,false);
unsigned int code1 = 1;
if (circuits()) {
ObjList* o = circuits()->circuits().skipNull();
if (o) {
SignallingCircuit* cic = static_cast<SignallingCircuit*>(o->get());
if (cic)
code1 = cic->code();
}
}
switch (cmd) {
case SS7MsgISUP::UPT:
case SS7MsgISUP::CVT:
{
unsigned int code = params.getIntValue(YSTRING("circuit"),code1);
SS7MsgISUP* msg = new SS7MsgISUP((SS7MsgISUP::Type)cmd,code);
SS7Label label(m_type,*m_remotePoint,*m_defPoint,m_sls);
mylock.drop();
transmitMessage(msg,label,false);
}
return TelEngine::controlReturn(&params,true);
case SS7MsgISUP::CQM:
{
unsigned int code = params.getIntValue(YSTRING("circuit"),code1);
unsigned int range = params.getIntValue(YSTRING("range"),1);
SS7MsgISUP* msg = new SS7MsgISUP(SS7MsgISUP::CQM,code);
msg->params().addParam("RangeAndStatus",String(range));
SS7Label label(m_type,*m_remotePoint,*m_defPoint,m_sls);
mylock.drop();
transmitMessage(msg,label,false);
}
return TelEngine::controlReturn(&params,true);
case SS7MsgISUP::CCR:
{
unsigned int code = params.getIntValue(YSTRING("circuit"),code1);
// TODO: create a test call, not just send CCR
SS7MsgISUP* msg = 0;
const String& ok = params[YSTRING("success")];
if (ok.isBoolean()) {
msg = new SS7MsgISUP(SS7MsgISUP::COT,code);
msg->params().addParam("ContinuityIndicators",
ok.toBoolean() ? "success" : "failed");
}
else
msg = new SS7MsgISUP(SS7MsgISUP::CCR,code);
SS7Label label(m_type,*m_remotePoint,*m_defPoint,m_sls);
mylock.drop();
transmitMessage(msg,label,false);
}
return TelEngine::controlReturn(&params,true);
case SS7MsgISUP::RSC:
if (0 == (m_rscSpeedup = circuits() ? circuits()->count() : 0))
return TelEngine::controlReturn(&params,false);
// Temporarily speed up reset interval to 10s or as provided
m_rscTimer.interval(params,"interval",2,10,false,true);
Debug(this,DebugNote,"Fast reset of %u circuits every %u ms",
m_rscSpeedup,(unsigned int)m_rscTimer.interval());
if (m_rscTimer.started())
m_rscTimer.start(Time::msecNow());
return TelEngine::controlReturn(&params,true);
case SS7MsgISUP::BLK:
case SS7MsgISUP::UBL:
return TelEngine::controlReturn(&params,handleCicBlockCommand(params,cmd == SS7MsgISUP::BLK));
case SS7MsgISUP::RLC:
{
int code = params.getIntValue(YSTRING("circuit"));
if (code <= 0)
return TelEngine::controlReturn(&params,false);
SignallingMessageTimer* pending = findPendingMessage(SS7MsgISUP::RSC,code,true);
if (pending) {
resetCircuit((unsigned int)code,false,false);
TelEngine::destruct(pending);
SS7Label label(m_type,*m_remotePoint,*m_defPoint,m_sls);
mylock.drop();
transmitRLC(this,code,label,false);
}
else {
RefPointer<SS7ISUPCall> call;
findCall(code,call);
if (!call)
return TelEngine::controlReturn(&params,false);
mylock.drop();
call->setTerminate(true,params.getValue(YSTRING("reason"),"normal"));
}
}
return TelEngine::controlReturn(&params,true);
case SS7MsgISUP::UPA:
if (!m_userPartAvail) {
const char* oldStat = statusName();
m_uptTimer.stop();
m_userPartAvail = true;
m_lockTimer.start();
if (statusName() != oldStat) {
NamedList params("");
params.addParam("from",toString());
params.addParam("type","trunk");
params.addParam("operational",String::boolText(m_l3LinkUp));
params.addParam("available",String::boolText(m_userPartAvail));
params.addParam("text",statusName());
engine()->notify(this,params);
}
}
return TelEngine::controlReturn(&params,true);
case SS7MsgISUP::CtrlSave:
setVerify(true,true);
return TelEngine::controlReturn(&params,true);
#ifdef ISUP_HANDLE_CIC_EVENT_CONTROL
case SS7MsgISUP::CtrlCicEvent:
return TelEngine::controlReturn(&params,handleCicEventCommand(params));
#endif
}
mylock.drop();
return SignallingComponent::control(params);
}
// Process a notification generated by the attached network layer
void SS7ISUP::notify(SS7Layer3* link, int sls)
{
if (!(link && network()))
return;
Lock mylock(this);
SS7Route::State state = m_remotePoint ?
network()->getRouteState(m_type,*m_remotePoint) : SS7Route::Unknown;
bool linkTmp = m_l3LinkUp;
bool partAvail = m_userPartAvail;
const char* oldStat = statusName();
// Copy linkset operational state
m_l3LinkUp = network()->operational();
// Reset remote user part's availability state if supported
// Force UPT re-send
if (m_uptTimer.interval() && (!m_l3LinkUp || (SS7Route::Prohibited == state))) {
m_uptTimer.stop();
m_userPartAvail = false;
}
Debug(this,DebugInfo,
"L3 '%s' sls=%d is %soperational.%s Route is %s. Remote User Part is %savailable",
link->toString().safe(),sls,
(link->operational() ? "" : "not "),
(network() == link ? "" : (m_l3LinkUp ? " L3 is up." : " L3 is down.")),
SS7Route::stateName(state),
(m_userPartAvail ? "" : "un"));
if (linkTmp != m_l3LinkUp || partAvail != m_userPartAvail) {
NamedList params("");
params.addParam("from",toString());
params.addParam("type","trunk");
params.addParam("operational",String::boolText(m_l3LinkUp));
params.addParam("available",String::boolText(m_userPartAvail));
params.addParam("link",link->toString());
if (statusName() != oldStat)
params.addParam("text",statusName());
engine()->notify(this,params);
}
}
SS7MSU* SS7ISUP::buildMSU(SS7MsgISUP::Type type, unsigned char sio,
const SS7Label& label, unsigned int cic, const NamedList* params) const
{
// Special treatment for charge message
// Check if it is in raw format
if (type == SS7MsgISUP::CRG && params && params->getParam(YSTRING("Charge")))
return encodeRawMessage(type,sio,label,cic,(*params)[YSTRING("Charge")]);
if (type == SS7MsgISUP::PAM && params)
return encodeRawMessage(type,sio,label,cic,(*params)[YSTRING("PassAlong")]);
// see what mandatory parameters we should put in this message
const MsgParams* msgParams = getIsupParams(label.type(),type);
if (!msgParams) {
if (!hasOptionalOnly(type)) {
const char* name = SS7MsgISUP::lookup(type);
if (name)
Debug(this,DebugWarn,"No parameter table for ISUP MSU type %s [%p]",name,this);
else
Debug(this,DebugWarn,"Cannot create ISUP MSU type 0x%02x [%p]",type,this);
return 0;
}
msgParams = &s_compatibility;
}
unsigned int len = m_cicLen + 1;
const SS7MsgISUP::Parameters* plist = msgParams->params;
SS7MsgISUP::Parameters ptype;
// first add the length of mandatory fixed parameters
while ((ptype = *plist++) != SS7MsgISUP::EndOfParameters) {
const IsupParam* param = getParamDesc(ptype);
if (!param) {
// this is fatal as we don't know the length
Debug(this,DebugCrit,"Missing description of fixed ISUP parameter 0x%02x [%p]",ptype,this);
return 0;
}
if (!param->size) {
Debug(this,DebugCrit,"Invalid (variable) description of fixed ISUP parameter 0x%02x [%p]",ptype,this);
return 0;
}
len += param->size;
}
// initialize the pointer array offset just past the mandatory fixed part
unsigned int ptr = label.length() + 1 + len;
// then add one pointer octet to each mandatory variable parameter
while ((ptype = *plist++) != SS7MsgISUP::EndOfParameters) {
const IsupParam* param = getParamDesc(ptype);
if (!param) {
// this is fatal as we won't be able to populate later
Debug(this,DebugCrit,"Missing description of variable ISUP parameter 0x%02x [%p]",ptype,this);
return 0;
}
if (param->size)
Debug(this,DebugMild,"Invalid (fixed) description of variable ISUP parameter 0x%02x [%p]",ptype,this);
len++;
}
// finally add a pointer to the optional part only if supported by type
if (msgParams->optional)
len++;
SS7MSU* msu = new SS7MSU(sio,label,0,len);
unsigned char* d = msu->getData(label.length()+1,len);
unsigned int i = m_cicLen;
while (i--) {
*d++ = cic & 0xff;
cic >>= 8;
}
*d++ = type;
#ifdef XDEBUG
if (params && debugAt(DebugAll)) {
String tmp;
params->dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugAll,"SS7ISUP::buildMSU params:%s",
tmp.c_str());
}
#endif
ObjList exclude;
plist = msgParams->params;
String prefix = params->getValue(YSTRING("message-prefix"));
// first populate with mandatory fixed parameters
while ((ptype = *plist++) != SS7MsgISUP::EndOfParameters) {
const IsupParam* param = getParamDesc(ptype);
if (!param) {
Debug(this,DebugFail,"Stage 2: no description of fixed ISUP parameter 0x%02x [%p]",ptype,this);
continue;
}
if (!param->size) {
Debug(this,DebugFail,"Stage 2: Invalid (variable) description of fixed ISUP parameter %s [%p]",param->name,this);
continue;
}
if (!encodeParam(this,*msu,param,params,exclude,prefix,d))
Debug(this,DebugCrit,"Could not encode fixed ISUP parameter %s [%p]",param->name,this);
d += param->size;
}
// now populate with mandatory variable parameters
for (; (ptype = *plist++) != SS7MsgISUP::EndOfParameters; ptr++) {
const IsupParam* param = getParamDesc(ptype);
if (!param) {
Debug(this,DebugFail,"Stage 2: no description of variable ISUP parameter 0x%02x [%p]",ptype,this);
continue;
}
if (param->size) {
Debug(this,DebugFail,"Stage 2: Invalid (fixed) description of variable ISUP parameter %s [%p]",param->name,this);
continue;
}
// remember the offset this parameter will actually get stored
len = msu->length();
unsigned char size = encodeParam(this,*msu,param,params,exclude,prefix);
d = msu->getData(0,len+1);
if (!(size && d)) {
Debug(this,DebugCrit,"Could not encode variable ISUP parameter %s [%p]",param->name,this);
continue;
}
if ((d[len] != size) || (msu->length() != (len+1+size))) {
Debug(this,DebugCrit,"Invalid encoding variable ISUP parameter %s (len=%u size=%u stor=%u) [%p]",
param->name,len,size,d[len],this);
continue;
}
// store pointer to parameter
d[ptr] = len - ptr;
}
if (msgParams->optional && params) {
// remember the offset past last mandatory == first optional parameter
len = msu->length();
// optional parameters are possible - try to set anything left in the message
unsigned int n = params->length();
for (unsigned int i = 0; i < n; i++) {
NamedString* ns = params->getParam(i);
if (!ns || exclude.find(ns))
continue;
if (prefix && !ns->name().startsWith(prefix))
continue;
String tmp(ns->name());
tmp >> prefix.c_str();
static const Regexp s_suffix("\\.[0-9]\\+$");
if (tmp.matches(s_suffix)) {
tmp.assign(tmp,tmp.matchOffset());
// WARNING: HACK - ApplicationTransport does not follow naming convention
if (tmp == YSTRING("ApplicationTransport"))
continue;
}
const IsupParam* param = getParamDesc(tmp);
unsigned char size = 0;
if (param)
size = encodeParam(this,*msu,param,ns,params,prefix);
else if (tmp.startSkip("Param_",false)) {
int val = tmp.toInteger(-1);
if (val >= 0 && val <= 255) {
IsupParam p;
p.name = tmp;
p.type = (SS7MsgISUP::Parameters)val;
p.size = 0;
p.encoder = 0;
size = encodeParam(this,*msu,&p,ns,params,prefix);
}
}
if (!size)
continue;
if (len) {
d = msu->getData(0,len+1);
d[ptr] = len - ptr;
len = 0;
}
}
if (!len) {
// we stored some optional parameters so we need to put the terminator
DataBlock tmp(0,1);
*msu += tmp;
}
}
return msu;
}
SS7MSU* SS7ISUP::encodeRawMessage(SS7MsgISUP::Type type, unsigned char sio,
const SS7Label& label, unsigned int cic, const String& param) const
{
DataBlock raw;
if (!raw.unHexify(param.c_str(),param.length(),' ')) {
DDebug(this,DebugMild,"Encode raw charge failed: invalid string");
return 0;
}
if (raw.length() > 254) {
DDebug(this,DebugMild,"Encode raw charge failed: data length=%u",
raw.length());
return 0;
}
SS7MSU* msu = new SS7MSU(sio,label,0,m_cicLen + 1);
unsigned char* d = msu->getData(label.length()+1,m_cicLen + 1);
unsigned int i = m_cicLen;
while (i--) {
*d++ = cic & 0xff;
cic >>= 8;
}
*d++ = type;
*msu += raw;
return msu;
}
// Decode a buffer to a list of parameters
bool SS7ISUP::decodeMessage(NamedList& msg,
SS7MsgISUP::Type msgType, SS7PointCode::Type pcType,
const unsigned char* paramPtr, unsigned int paramLen)
{
String msgTypeName((int)msgType);
const char* msgName = SS7MsgISUP::lookup(msgType,msgTypeName);
#ifdef XDEBUG
String tmp;
tmp.hexify((void*)paramPtr,paramLen,' ');
Debug(this,DebugAll,"Decoding msg=%s len=%u: %s [%p]",
msgName,paramLen,tmp.c_str(),this);
#else
DDebug(this,DebugAll,"Decoding msg=%s len=%u [%p]",
msgName,paramLen,this);
#endif
// see what parameters we expect for this message
const MsgParams* params = getIsupParams(pcType,msgType);
if (!params) {
if (hasOptionalOnly(msgType)) {
Debug(this,DebugNote,"Unsupported message %s, decoding compatibility [%p]",msgName,this);
params = &s_compatibility;
}
else if (msgType != SS7MsgISUP::PAM) {
Debug(this,DebugWarn,"Unsupported message %s or point code type [%p]",msgName,this);
return false;
}
else if (!paramLen) {
// PAM message must have at least 1 byte for message type
Debug(this,DebugNote,"Empty %s [%p]",msgName,this);
return false;
}
}
// Get parameter prefix
String prefix = msg.getValue(YSTRING("message-prefix"));
// Add protocol and message type
if (!msg.getValue(prefix+"protocol-type")) {
switch (pcType) {
case SS7PointCode::ITU:
msg.setParam(prefix+"protocol-type","itu-t");
break;
case SS7PointCode::ANSI:
case SS7PointCode::ANSI8:
msg.setParam(prefix+"protocol-type","ansi");
break;
default: ;
}
}
msg.addParam(prefix+"message-type",msgName);
// Special decoder for PAM
if (msgType == SS7MsgISUP::PAM) {
String raw;
raw.hexify((void*)paramPtr,paramLen,' ');
msg.addParam(prefix + "PassAlong",raw);
return true;
}
// Decode raw CRG if specified
if (msgType == SS7MsgISUP::CRG && getChargeProcessType() != Parsed) {
String raw;
raw.hexify((void*)paramPtr,paramLen,' ');
msg.addParam(prefix + "Charge",raw);
return true;
}
String unsupported;
const SS7MsgISUP::Parameters* plist = params->params;
SS7MsgISUP::Parameters ptype;
// first decode any mandatory fixed parameters the message should have
while ((ptype = *plist++) != SS7MsgISUP::EndOfParameters) {
const IsupParam* param = getParamDesc(ptype);
if (!param) {
// this is fatal as we don't know the length
Debug(this,DebugCrit,"Missing description of fixed ISUP parameter 0x%02x [%p]",ptype,this);
return false;
}
if (!param->size) {
Debug(this,DebugCrit,"Invalid (variable) description of fixed ISUP parameter %s [%p]",param->name,this);
return false;
}
if (paramLen < param->size) {
Debug(this,DebugWarn,"Truncated ISUP message! [%p]",this);
return false;
}
if (!decodeParam(this,msg,param,paramPtr,param->size,prefix)) {
Debug(this,DebugWarn,"Could not decode fixed ISUP parameter %s [%p]",param->name,this);
decodeRaw(this,msg,param,paramPtr,param->size,prefix);
SignallingUtils::appendFlag(unsupported,param->name);
}
paramPtr += param->size;
paramLen -= param->size;
} // while ((ptype = *plist++)...
bool mustWarn = true;
// next decode any mandatory variable parameters the message should have
while ((ptype = *plist++) != SS7MsgISUP::EndOfParameters) {
mustWarn = false;
const IsupParam* param = getParamDesc(ptype);
if (!param) {
// we could skip over unknown mandatory variable length but it's still bad
Debug(this,DebugCrit,"Missing description of variable ISUP parameter 0x%02x [%p]",ptype,this);
return false;
}
if (param->size)
Debug(this,DebugMild,"Invalid (fixed) description of variable ISUP parameter %s [%p]",param->name,this);
unsigned int offs = paramPtr[0];
if ((offs < 1) || (offs >= paramLen)) {
Debug(this,DebugWarn,"Invalid offset %u (len=%u) ISUP parameter %s [%p]",
offs,paramLen,param->name,this);
return false;
}
unsigned int size = paramPtr[offs];
if ((size < 1) || (offs+size >= paramLen)) {
Debug(this,DebugWarn,"Invalid size %u (ofs=%u, len=%u) ISUP parameter %s [%p]",
size,offs,paramLen,param->name,this);
return false;
}
if (!decodeParam(this,msg,param,paramPtr+offs+1,size,prefix)) {
Debug(this,DebugWarn,"Could not decode variable ISUP parameter %s (size=%u) [%p]",
param->name,size,this);
decodeRaw(this,msg,param,paramPtr+offs+1,size,prefix);
SignallingUtils::appendFlag(unsupported,param->name);
}
paramPtr++;
paramLen--;
} // while ((ptype = *plist++)...
// now decode the optional parameters if the message supports them
if (params->optional) {
unsigned int offs = paramLen ? paramPtr[0] : 0;
if (offs >= paramLen) {
if (paramLen) {
Debug(this,DebugWarn,"Invalid ISUP optional offset %u (len=%u) [%p]",
offs,paramLen,this);
return false;
}
Debug(this,DebugMild,"ISUP message %s lacking optional parameters [%p]",
msgName,this);
}
else if (offs) {
mustWarn = true;
// advance pointer past mandatory parameters
paramPtr += offs;
paramLen -= offs;
while (paramLen) {
ptype = (SS7MsgISUP::Parameters)(*paramPtr++);
paramLen--;
if (ptype == SS7MsgISUP::EndOfParameters)
break;
if (paramLen < 2) {
Debug(this,DebugWarn,"Only %u octets while decoding optional ISUP parameter 0x%02x [%p]",
paramLen,ptype,this);
return false;
}
unsigned int size = *paramPtr++;
paramLen--;
if ((size < 1) || (size >= paramLen)) {
Debug(this,DebugWarn,"Invalid size %u (len=%u) ISUP optional parameter 0x%02x [%p]",
size,paramLen,ptype,this);
return false;
}
const IsupParam* param = getParamDesc(ptype);
if (!param) {
Debug(this,DebugMild,"Unknown optional ISUP parameter 0x%02x (size=%u) [%p]",ptype,size,this);
decodeRawParam(this,msg,ptype,paramPtr,size,prefix);
SignallingUtils::appendFlag(unsupported,String((unsigned int)ptype));
}
else if (!decodeParam(this,msg,param,paramPtr,size,prefix)) {
Debug(this,DebugWarn,"Could not decode optional ISUP parameter %s (size=%u) [%p]",param->name,size,this);
decodeRaw(this,msg,param,paramPtr,size,prefix);
SignallingUtils::appendFlag(unsupported,param->name);
}
paramPtr += size;
paramLen -= size;
} // while (paramLen)
} // else if (offs)
else
paramLen = 0;
}
if (unsupported)
msg.addParam(prefix + "parameters-unsupported",unsupported);
String release,cnf,npRelease;
String pCompat(prefix + "ParameterCompatInformation.");
unsigned int n = msg.length();
for (unsigned int i = 0; i < n; i++) {
NamedString* ns = msg.getParam(i);
if (!(ns && ns->name().startsWith(pCompat) && !ns->name().endsWith(".more")))
continue;
ObjList* l = ns->split(',',false);
for (ObjList* ol = l->skipNull(); ol; ol = ol->skipNext()) {
String* s = static_cast<String*>(ol->get());
if (*s == YSTRING("release")) {
SignallingUtils::appendFlag(release,ns->name().substr(pCompat.length()));
break;
}
if (*s == YSTRING("cnf"))
SignallingUtils::appendFlag(cnf,ns->name().substr(pCompat.length()));
if (*s == YSTRING("nopass-release"))
SignallingUtils::appendFlag(npRelease,ns->name().substr(pCompat.length()));
}
TelEngine::destruct(l);
}
if (release)
msg.setParam(prefix + "parameters-unhandled-release",release);
if (cnf)
msg.setParam(prefix + "parameters-unhandled-cnf",cnf);
if (npRelease)
msg.setParam(prefix + "parameters-nopass-release",npRelease);
if (paramLen && mustWarn)
Debug(this,DebugWarn,"Got %u garbage octets after message type 0x%02x [%p]",
paramLen,msgType,this);
return true;
}
// Encode an ISUP list of parameters to a buffer
bool SS7ISUP::encodeMessage(DataBlock& buf, SS7MsgISUP::Type msgType, SS7PointCode::Type pcType,
const NamedList& params, unsigned int* cic)
{
unsigned int circuit = cic ? *cic : 0;
SS7Label label(pcType,1,1,1);
SS7MSU* msu = buildMSU(msgType,1,label,circuit,&params);
if (!msu)
return false;
unsigned int start = 1 + label.length() + (cic ? 0 : m_cicLen);
buf.assign(((char*)msu->data()) + start,msu->length() - start);
TelEngine::destruct(msu);
return true;
}
// Process parameter compatibility lists
// Terminate an existing call or send CNF
// Return true if any parameter compatibility was handled
bool SS7ISUP::processParamCompat(const NamedList& list, unsigned int cic, bool* callReleased)
{
if (!cic)
return true;
const String& prefix = list[YSTRING("message-prefix")];
// Release call params
String relCall = list[prefix + "parameters-unhandled-release"];
relCall.append(list[prefix + "parameters-nopass-release"],",");
if (relCall) {
Lock lock(this);
SS7ISUPCall* call = findCall(cic);
Debug(this,DebugNote,
"Terminating call (%p) on cic=%u: unknown/unhandled params='%s' [%p]",
call,cic,relCall.c_str(),this);
String diagnostic;
hexifyIsupParams(diagnostic,relCall);
if (call) {
lock.drop();
call->setTerminate(true,"unknown-ie",diagnostic,m_location);
}
else if (m_remotePoint) {
// No call: make sure the circuit is released at remote party
SS7Label label(m_type,*m_remotePoint,*m_defPoint,
(m_defaultSls == SlsCircuit) ? cic : m_sls);
lock.drop();
transmitRLC(this,cic,label,false,"unknown-ie",diagnostic,m_location);
}
if (callReleased)
*callReleased = true;
return true;
}
// Send CNF params
const String& cnf = list[prefix + "parameters-unhandled-cnf"];
if (!cnf)
return false;
DDebug(this,DebugAll,"processParamCompat() cic=%u sending CNF for '%s' [%p]",
cic,cnf.c_str(),this);
String diagnostic;
hexifyIsupParams(diagnostic,cnf);
if (diagnostic && m_remotePoint) {
SS7Label label(m_type,*m_remotePoint,*m_defPoint,
(m_defaultSls == SlsCircuit) ? cic : m_sls);
transmitCNF(this,cic,label,false,"unknown-ie",diagnostic,m_location);
}
return !diagnostic.null();
}
HandledMSU SS7ISUP::receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls)
{
if (msu.getSIF() != sif() || !hasPointCode(label.dpc()) || !handlesRemotePC(label.opc()))
return HandledMSU::Rejected;
// we should have at least 2 bytes CIC and 1 byte message type
const unsigned char* s = msu.getData(label.length()+1,3);
if (!s) {
Debug(this,DebugNote,"Got short MSU");
return false;
}
unsigned int len = msu.length()-label.length()-1;
unsigned int cic = s[0] | (s[1] << 8);
SS7MsgISUP::Type type = (SS7MsgISUP::Type)s[2];
String name = SS7MsgISUP::lookup(type);
if (!name) {
String tmp;
tmp.hexify((void*)s,len,' ');
Debug(this,DebugMild,"Received unknown ISUP type 0x%02x, cic=%u, length %u: %s",
type,cic,len,tmp.c_str());
name = (int)type;
}
if (!(circuits() && circuits()->find(cic))) {
Debug(this,m_cicWarnLevel,"Received ISUP type 0x%02x (%s) for unknown cic=%u",
type,name.c_str(),cic);
m_cicWarnLevel = DebugAll;
return HandledMSU::NoCircuit;
}
bool ok = processMSU(type,cic,s+3,len-3,label,network,sls);
if (!ok && debugAt(DebugMild)) {
String tmp;
tmp.hexify((void*)s,len,' ');
Debug(this,DebugMild,"Unhandled ISUP type %s, cic=%u, length %u: %s",
name.c_str(),cic,len,tmp.c_str());
}
return ok;
}
bool SS7ISUP::processMSU(SS7MsgISUP::Type type, unsigned int cic,
const unsigned char* paramPtr, unsigned int paramLen,
const SS7Label& label, SS7Layer3* network, int sls)
{
XDebug(this,DebugAll,"SS7ISUP::processMSU(%u,%u,%p,%u,%p,%p,%d) [%p]",
type,cic,paramPtr,paramLen,&label,network,sls,this);
SS7MsgISUP* msg = new SS7MsgISUP(type,cic);
if (!SS7MsgISUP::lookup(type)) {
String tmp;
tmp.hexify(&type,1);
msg->params().assign("Message_" + tmp);
}
if (!decodeMessage(msg->params(),type,label.type(),paramPtr,paramLen)) {
TelEngine::destruct(msg);
return false;
}
if (m_printMsg && debugAt(DebugInfo)) {
String tmp;
msg->toString(tmp,label,debugAt(DebugAll),
m_extendedDebug ? paramPtr : 0,paramLen);
Debug(this,DebugInfo,"Received message (%p)%s",msg,tmp.c_str());
}
else if (debugAt(DebugAll)) {
String tmp;
tmp << label;
Debug(this,DebugAll,"Received message '%s' cic=%u label=%s",
msg->name(),msg->cic(),tmp.c_str());
}
// TODO: check parameters-unsupported vs. ParameterCompatInformation
// Check if we expected some response to UPT
// Ignore
if (!m_userPartAvail && m_uptTimer.started()) {
m_uptTimer.stop();
const char* oldStat = statusName();
m_userPartAvail = true;
m_lockTimer.start();
Debug(this,DebugInfo,"Remote user part is available");
if (statusName() != oldStat) {
NamedList params("");
params.addParam("from",toString());
params.addParam("type","trunk");
params.addParam("operational",String::boolText(m_l3LinkUp));
params.addParam("available",String::boolText(m_userPartAvail));
params.addParam("text",statusName());
engine()->notify(this,params);
}
if (msg->cic() == m_uptCicCode &&
(msg->type() == SS7MsgISUP::UPA ||
msg->type() == SS7MsgISUP::CVR ||
msg->type() == SS7MsgISUP::CNF ||
msg->type() == SS7MsgISUP::UEC)) {
m_uptCicCode = 0;
TelEngine::destruct(msg);
return true;
}
}
switch (msg->type()) {
case SS7MsgISUP::IAM:
case SS7MsgISUP::SAM:
case SS7MsgISUP::ACM:
case SS7MsgISUP::EXM:
case SS7MsgISUP::CPR:
case SS7MsgISUP::ANM:
case SS7MsgISUP::CON:
case SS7MsgISUP::REL:
case SS7MsgISUP::SGM:
case SS7MsgISUP::CCR:
case SS7MsgISUP::COT:
case SS7MsgISUP::APM:
case SS7MsgISUP::SUS:
case SS7MsgISUP::RES:
processCallMsg(msg,label,sls);
break;
case SS7MsgISUP::CRG:
switch (getChargeProcessType()) {
case Confusion:
processControllerMsg(msg,label,sls);
case Ignore:
break;
default:
processCallMsg(msg,label,sls);
}
break;
case SS7MsgISUP::RLC:
if (m_rscCic && m_rscCic->code() == msg->cic())
processControllerMsg(msg,label,sls);
else {
SignallingMessageTimer* m = findPendingMessage(SS7MsgISUP::RSC,msg->cic(),true);
if (m) {
DDebug(this,DebugAll,"RSC confirmed for pending cic=%u",msg->cic());
resetCircuit(msg->cic(),false,false);
TelEngine::destruct(m);
}
else
processCallMsg(msg,label,sls);
}
break;
default:
processControllerMsg(msg,label,sls);
}
TelEngine::destruct(msg);
return true;
}
// MTP notification that remote user part is unavailable
void SS7ISUP::receivedUPU(SS7PointCode::Type type, const SS7PointCode node,
SS7MSU::Services part, unsigned char cause, const SS7Label& label, int sls)
{
if (part != sif() || !handlesRemotePC(node))
return;
if (!(m_userPartAvail && m_uptTimer.interval()))
return;
const char* oldStat = statusName();
Debug(this,DebugNote,"Remote User Part is unavailable (received UPU)");
m_userPartAvail = false;
m_uptTimer.start();
if (statusName() != oldStat) {
NamedList params("");
params.addParam("from",toString());
params.addParam("type","trunk");
params.addParam("operational",String::boolText(m_l3LinkUp));
params.addParam("available",String::boolText(m_userPartAvail));
params.addParam("text",statusName());
engine()->notify(this,params);
}
}
// Process an event received from a non-reserved circuit
SignallingEvent* SS7ISUP::processCircuitEvent(SignallingCircuitEvent*& event,
SignallingCall* call)
{
if (!event)
return 0;
SignallingEvent* ev = 0;
switch (event->type()) {
case SignallingCircuitEvent::Alarm:
case SignallingCircuitEvent::NoAlarm:
if (event->circuit()) {
lock();
bool block = (event->type() == SignallingCircuitEvent::Alarm);
bool blocked = (0 != event->circuit()->locked(SignallingCircuit::LockLocalHWFail));
// Avoid notifying the same state
if (block != blocked) {
event->circuit()->hwLock(block,false,true,true);
if (!m_lockTimer.started())
m_lockTimer.start();
if (block)
cicHwBlocked(event->circuit()->code(),String("1"));
}
unlock();
ev = new SignallingEvent(event,call);
}
break;
case SignallingCircuitEvent::Dtmf:
if (event->getValue(YSTRING("tone"))) {
SignallingMessage* msg = new SignallingMessage(event->c_str());
msg->params().addParam("tone",event->getValue(YSTRING("tone")));
msg->params().addParam("inband",event->getValue(YSTRING("inband"),String::boolText(true)));
ev = new SignallingEvent(SignallingEvent::Info,msg,call);
TelEngine::destruct(msg);
}
break;
default:
ev = new SignallingEvent(event,call);
}
TelEngine::destruct(event);
return ev;
}
// Initiate a circuit reset
bool SS7ISUP::startCircuitReset(SignallingCircuit*& cic, const String& timer)
{
if (!cic)
return false;
bool ok = false;
do {
Lock lock(this);
// Check if the circuit can be reset
// Do nothing on locally locked circuit: this would clear our lock
// state at remote side. See Q.764 2.9.3.1
if (cic->locked(SignallingCircuit::LockLocal)) {
Debug(this,DebugNote,
"Failed to start reset on locally locked circuit (cic=%u timer=%s) [%p]",
cic->code(),timer.c_str(),this);
ok = SignallingCallControl::releaseCircuit(cic);
break;
}
// Check if there is any management operation in progress on the cic
if (cic->locked(SignallingCircuit::LockBusy))
break;
bool relTimeout = (timer == "T5");
Debug(this,!relTimeout ? DebugAll : DebugNote,
"Starting circuit %u reset on timer %s [%p]",
cic->code(),timer.c_str(),this);
// TODO: alert maintenance if T5 timer expired
SignallingMessageTimer* m = 0;
if (relTimeout)
m = new SignallingMessageTimer(m_t17Interval);
else
m = new SignallingMessageTimer(m_t16Interval,m_t17Interval);
m = m_pending.add(m);
if (m) {
cic->setLock(SignallingCircuit::Resetting);
SS7MsgISUP* msg = new SS7MsgISUP(SS7MsgISUP::RSC,cic->code());
msg->params().addParam("isup_pending_reason",timer,false);
if (relTimeout)
msg->params().addParam("isup_alert_maint",String::boolText(true));
msg->ref();
m->message(msg);
lock.drop();
ok = true;
SS7Label label;
if (setLabel(label,msg->cic()))
transmitMessage(msg,label,false);
}
else {
Debug(this,DebugNote,
"Failed to add circuit %u reset to pending messages timer=%s [%p]",
cic->code(),timer.c_str(),this);
ok = SignallingCallControl::releaseCircuit(cic);
}
} while (false);
TelEngine::destruct(cic);
return ok;
}
// Process call related messages
void SS7ISUP::processCallMsg(SS7MsgISUP* msg, const SS7Label& label, int sls)
{
// Find a call for this message, create a new one or drop the message
RefPointer<SS7ISUPCall> call;
findCall(msg->cic(),call);
const char* reason = 0;
while (true) {
#define DROP_MSG(res) { reason = res; break; }
// Avoid cic == 0
if (!msg->cic())
DROP_MSG("invalid CIC")
// non IAM message. Drop it if there is no call for it
if ((msg->type() != SS7MsgISUP::IAM) && (msg->type() != SS7MsgISUP::CCR)) {
if (!call) {
if (msg->type() == SS7MsgISUP::REL)
DROP_MSG("no call")
if (msg->type() != SS7MsgISUP::RLC) {
// Initiate circuit reset
SignallingCircuit* cic = 0;
String s(msg->cic());
if (reserveCircuit(cic,0,SignallingCircuit::LockLockedBusy,&s))
startCircuitReset(cic,"T16");
}
return;
}
break;
}
// IAM or CCR message
SignallingCircuit* circuit = 0;
// Check collision
if (call) {
// If existing call is an incoming one, drop the message (retransmission ?)
if (!call->outgoing()) {
if (msg->type() == SS7MsgISUP::CCR)
break;
else
DROP_MSG("retransmission")
}
Debug(this,DebugNote,"Incoming call %u collide with existing outgoing",msg->cic());
// *** See Q.764 2.9.1.4
// Drop the request if the outgoing call already received some response or
// the destination point code is greater then the originating and the CIC is even
if (call->state() > SS7ISUPCall::Setup)
DROP_MSG("collision - outgoing call responded")
// The greater point code should have the even circuit
unsigned int dpc = label.dpc().pack(label.type());
unsigned int opc = label.opc().pack(label.type());
bool controlling = (dpc > opc);
bool even = (0 == (msg->cic() % 2));
if (controlling == even)
DROP_MSG("collision - we control the CIC")
// Accept the incoming request. Change the call's circuit
reserveCircuit(circuit,call->cicRange(),SignallingCircuit::LockLockedBusy);
call->replaceCircuit(circuit);
circuit = 0;
call = 0;
}
int flags = SignallingCircuit::LockLockedBusy;
// Q.764 2.8.2 - accept test calls even if the remote side is blocked
// Q.764 2.8.2.3 (xiv) - unblock remote side of the circuit for non-test calls
if ((msg->type() == SS7MsgISUP::CCR) ||
(msg->params()[YSTRING("CallingPartyCategory")] == YSTRING("test"))) {
Debug(this,DebugInfo,"Received test call on circuit %u",msg->cic());
flags = 0;
}
else {
circuit = circuits() ? circuits()->find(msg->cic()) : 0;
if (circuit && circuit->locked(SignallingCircuit::LockRemote)) {
Debug(this,DebugNote,"Unblocking remote circuit %u on IAM request",msg->cic());
circuit->hwLock(false,true,0!=circuit->locked(SignallingCircuit::LockRemoteHWFail),false);
circuit->maintLock(false,true,0!=circuit->locked(SignallingCircuit::LockRemoteMaint),false);
m_verifyEvent = true;
}
circuit = 0;
}
String s(msg->cic());
if (reserveCircuit(circuit,0,flags,&s,true)) {
call = new SS7ISUPCall(this,circuit,label.dpc(),label.opc(),false,label.sls(),
0,msg->type() == SS7MsgISUP::CCR);
m_calls.append(call);
break;
}
// Congestion: send REL
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::REL,msg->cic());
m->params().addParam("CauseIndicators","congestion");
transmitMessage(m,label,true);
DROP_MSG("can't reserve circuit")
#undef DROP_MSG
}
if (!reason) {
msg->ref();
call->enqueue(msg);
}
else {
if (msg->type() != SS7MsgISUP::IAM && msg->type() != SS7MsgISUP::RLC)
transmitRLC(this,msg->cic(),label,true);
if (msg->type() != SS7MsgISUP::RLC)
Debug(this,DebugNote,"'%s' with cic=%u: %s",msg->name(),msg->cic(),reason);
}
}
unsigned int getRangeAndStatus(NamedList& nl, unsigned int minRange, unsigned int maxRange,
unsigned int maxMap = 0, String** map = 0, unsigned int nCicsMax = 0)
{
unsigned int range = nl.getIntValue(YSTRING("RangeAndStatus"));
if (range < minRange || range > maxRange)
return 0;
if (!maxMap)
return range;
NamedString* ns = nl.getParam(YSTRING("RangeAndStatus.map"));
if (!ns || ns->length() > maxMap || ns->length() < range)
return 0;
if (map) {
if (nCicsMax) {
// Check the number of bits set to 1 (circuits affected)
for (unsigned int i = 0; i < ns->length(); i++) {
if ((*ns)[i] != '1')
continue;
if (!nCicsMax)
return 0;
nCicsMax--;
}
}
*map = ns;
}
return range;
}
// Retrieve maintenance/hwfail type indicator
// Return false if invalid
static bool getGrpTypeInd(SS7ISUP* isup, SS7MsgISUP* msg, bool& hwFail, NamedString** ns = 0)
{
if (!msg)
return false;
NamedString* s = msg->params().getParam(YSTRING("GroupSupervisionTypeIndicator"));
if (s) {
if (ns)
*ns = s;
hwFail = (*s == YSTRING("hw-failure"));
if (hwFail || (*s == YSTRING("maintenance")))
return true;
}
Debug(isup,DebugNote,"%s with unknown/unsupported GroupSupervisionTypeIndicator=%s [%p]",
msg->name(),TelEngine::c_safe(s),isup);
return false;
}
// Utility: set invalid-ie reason and diagnostic
static inline void setInvalidIE(unsigned char ie, const char*& reason, String& diagnostic)
{
reason = "invalid-ie";
diagnostic.hexify(&ie,1);
}
// Process controller related messages
// Q.764 2.1.12: stop waiting for SGM if message is not: COT,BLK,BLA,UBL,UBA,CGB,CGA,CGU,CUA,CQM,CQR
void SS7ISUP::processControllerMsg(SS7MsgISUP* msg, const SS7Label& label, int sls)
{
const char* reason = 0;
String diagnostic;
bool impl = true;
bool stopSGM = false;
// TODO: Check if segmentation should stop for all affected circuits received withing range (CGB,GRS, ...)
switch (msg->type()) {
case SS7MsgISUP::CNF: // Confusion
// TODO: check if this message was received in response to RSC, UBL, UBK, CGB, CGU
Debug(this,DebugNote,"%s with cic=%u cause='%s' diagnostic='%s'",
msg->name(),msg->cic(),
msg->params().getValue(YSTRING("CauseIndicators")),
msg->params().getValue(YSTRING("CauseIndicators.diagnostic")));
stopSGM = true;
break;
case SS7MsgISUP::RLC: // Release Complete
// Response to RSC: reset local lock flags. Release m_rscCic
resetCircuit(msg->cic(),false,false);
break;
case SS7MsgISUP::RSC: // Reset Circuit
if (resetCircuit(msg->cic(),true,true)) {
// Send BLK on previously blocked cic: Q.764 2.9.3.1 c)
lock();
SignallingCircuit* cic = circuits() ? circuits()->find(msg->cic()) : 0;
SS7MsgISUP* m = 0;
if (cic && cic->locked(SignallingCircuit::LockLocalMaint) &&
!cic->locked(SignallingCircuit::LockingMaint))
m = buildCicBlock(cic,true,true);
unlock();
if (m)
transmitMessage(m,label,true);
transmitRLC(this,msg->cic(),label,true);
}
else
reason = "unknown-channel";
stopSGM = true;
break;
case SS7MsgISUP::GRS: // Circuit Group Reset
stopSGM = true;
{
// Q.763 3.43 min=1 max=31
unsigned int n = getRangeAndStatus(msg->params(),1,31);
if (!n) {
Debug(this,DebugNote,"%s with invalid range %s",msg->name(),
msg->params().getValue(YSTRING("RangeAndStatus")));
break;
}
else if (n == 1 && m_ignoreGRSSingle) {
Debug(this,DebugAll,"Ignoring %s with range 1",msg->name());
break;
}
String map('0',n);
char* d = (char*)map.c_str();
for (unsigned int i = 0; i < n; i++)
if (!resetCircuit(msg->cic()+i,true,true))
d[i] = '1';
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::GRA,msg->cic());
m->params().addParam("RangeAndStatus",String(n));
m->params().addParam("RangeAndStatus.map",map);
transmitMessage(m,label,true);
}
break;
case SS7MsgISUP::UBL: // Unblocking
if (blockCircuit(msg->cic(),false,true,false,true,true))
transmitMessage(new SS7MsgISUP(SS7MsgISUP::UBA,msg->cic()),label,true);
else
reason = "unknown-channel";
break;
case SS7MsgISUP::BLK: // Blocking
if (blockCircuit(msg->cic(),true,true,false,true,true)) {
transmitMessage(new SS7MsgISUP(SS7MsgISUP::BLA,msg->cic()),label,true);
// Replace circuit for outgoing call in initial state
replaceCircuit(msg->cic(),String('1'));
}
else
reason = "unknown-channel";
break;
case SS7MsgISUP::UBA: // Unblocking Acknowledgement
case SS7MsgISUP::BLA: // Blocking Acknowledgement
{
bool block = (msg->type() == SS7MsgISUP::BLA);
SS7MsgISUP::Type type = block ? SS7MsgISUP::BLK : SS7MsgISUP::UBL;
SignallingMessageTimer* t = findPendingMessage(type,msg->cic(),true);
if (t) {
SS7MsgISUP* m = static_cast<SS7MsgISUP*>(t->message());
bool hw = m && m->params().getBoolValue(YSTRING("isup_pending_block_hwfail"));
DDebug(this,m ? DebugAll : DebugNote,"%s confirmed for pending cic=%u",
block ? "BLK" : "UBL",msg->cic());
TelEngine::destruct(t);
blockCircuit(msg->cic(),block,false,hw,true,false,true);
sendLocalLock();
}
else
reason = "wrong-state-message";
}
break;
case SS7MsgISUP::CGA: // Circuit Group Blocking Acknowledgement
case SS7MsgISUP::CUA: // Circuit Group Unblocking Acknowledgement
// Q.763 3.43 range can be 1..256. Max bits set to 1 should be 32
// Bit: 0-no indication 1-block/unblock
{
bool hwFail = false;
NamedString* grpSuperType = 0;
if (!getGrpTypeInd(this,msg,hwFail,&grpSuperType))
break;
String* srcMap = 0;
unsigned int nCics = getRangeAndStatus(msg->params(),1,256,256,&srcMap,32);
if (!nCics) {
Debug(this,DebugNote,"%s (%s) cic=%u with invalid range %s or map=%s",
msg->name(),grpSuperType->c_str(),msg->cic(),
msg->params().getValue(YSTRING("RangeAndStatus")),
msg->params().getValue(YSTRING("RangeAndStatus.map")));
break;
}
bool block = (msg->type() == SS7MsgISUP::CGA);
lock();
// Check for correct response: same msg type, circuit code, type indicator, circuit map
SS7MsgISUP::Type type = block ? SS7MsgISUP::CGB : SS7MsgISUP::CGU;
SignallingMessageTimer* t = findPendingMessage(type,msg->cic(),
grpSuperType->name(),*grpSuperType);
if (!t) {
Debug(this,DebugNote,"%s (%s) cic=%u: no request for it in our queue",
msg->name(),grpSuperType->c_str(),msg->cic());
unlock();
break;
}
SS7MsgISUP* m = static_cast<SS7MsgISUP*>(t->message());
String map;
while (m) {
// Check map
map = m->params()[YSTRING("RangeAndStatus.map")];
if (!map)
break;
if (map.length() != nCics) {
map.clear();
break;
}
for (unsigned int i = 0; i < map.length(); i++)
if (map[i] == '0' && (*srcMap)[i] != '0') {
map.clear();
break;
}
break;
}
if (map) {
DDebug(this,DebugAll,"%s (%s) confirmed for pending cic=%u",
m->name(),grpSuperType->c_str(),msg->cic());
m_pending.remove(t);
}
unlock();
if (!map) {
Debug(this,DebugNote,"%s (%s) cic=%u with unnacceptable range %s or map=%s",
msg->name(),grpSuperType->c_str(),msg->cic(),
msg->params().getValue(YSTRING("RangeAndStatus")),
msg->params().getValue(YSTRING("RangeAndStatus.map")));
break;
}
for (unsigned int i = 0; i < map.length(); i++)
if (map[i] != '0')
blockCircuit(msg->cic()+i,block,false,hwFail,true,false,true);
sendLocalLock();
}
break;
case SS7MsgISUP::CGB: // Circuit Group Blocking
case SS7MsgISUP::CGU: // Circuit Group Unblocking
// Q.763 3.43 range can be 1..256. Max bits set to 1 should be 32
// Bit: 0-no indication 1-block/unblock
{
bool hwFail = false;
if (!getGrpTypeInd(this,msg,hwFail))
break;
bool block = (msg->type() == SS7MsgISUP::CGB);
String* srcMap = 0;
unsigned int nCics = getRangeAndStatus(msg->params(),1,256,256,&srcMap,32);
if (!nCics) {
Debug(this,DebugNote,"%s with invalid range %s or map=%s",msg->name(),
msg->params().getValue(YSTRING("RangeAndStatus")),
msg->params().getValue(YSTRING("RangeAndStatus.map")));
break;
}
else if (nCics == 1 && ((block && m_ignoreCGBSingle) || (!block && m_ignoreCGUSingle))) {
Debug(this,DebugAll,"Ignoring %s with range 1",msg->name());
break;
}
String map('0',srcMap->length());
char* d = (char*)map.c_str();
for (unsigned int i = 0; i < srcMap->length(); i++)
if (srcMap->at(i) != '0' && blockCircuit(msg->cic()+i,block,true,hwFail,true,true))
d[i] = '1';
SS7MsgISUP* m = new SS7MsgISUP(block?SS7MsgISUP::CGA:SS7MsgISUP::CUA,msg->cic());
m->params().copyParam(msg->params(),"GroupSupervisionTypeIndicator");
m->params().addParam("RangeAndStatus",String(nCics));
m->params().addParam("RangeAndStatus.map",map);
transmitMessage(m,label,true);
// Replace circuits for outgoing calls in initial state
// Terminate all others when blocking for hw failure
if (block) {
if (hwFail)
cicHwBlocked(msg->cic(),map);
else
replaceCircuit(msg->cic(),map);
}
}
break;
case SS7MsgISUP::UEC: // Unequipped CIC (national use)
Debug(this,DebugWarn,"%s for cic=%u. Circuit is unequipped on remote side",
msg->name(),msg->cic());
blockCircuit(msg->cic(),true,true,false,true,true);
break;
case SS7MsgISUP::UPT: // User Part Test
transmitMessage(new SS7MsgISUP(SS7MsgISUP::UPA,msg->cic()),label,true);
break;
case SS7MsgISUP::UPA: // User Part Available
if (m_uptCicCode && m_uptCicCode == msg->cic()) {
DDebug(this,DebugInfo,"Received valid %s",msg->name());
m_uptCicCode = 0;
}
#ifdef DEBUG
else
Debug(this,DebugMild,"Received unexpected %s",msg->name());
#endif
break;
case SS7MsgISUP::GRA: // Circuit Group Reset Acknowledgement
// TODO: stop receiving segments
reason = "wrong-state-message";
break;
case SS7MsgISUP::CVT: // Circuit Validation Test (ANSI)
if (circuits() && circuits()->find(msg->cic())) {
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::CVR,msg->cic());
m->params().addParam("CircuitValidationRespIndicator","success");
transmitMessage(m,label,true);
}
else
reason = "unknown-channel";
break;
case SS7MsgISUP::CQM: // Circuit Group Query (national use)
if (circuits()) {
// Q.763 3.43 min=1 max=31
unsigned int n = getRangeAndStatus(msg->params(),1,31);
if (!n) {
reason = "invalid-ie";
break;
}
DataBlock si(0,n);
for (unsigned int i = 0; i < n; i++) {
unsigned char* state = si.data(i);
if (!state)
break;
SignallingCircuit* circuit = circuits()->find(msg->cic()+i);
if (circuit && (circuit->status() != SignallingCircuit::Missing)) {
switch (circuit->locked(SignallingCircuit::LockLocalMaint | SignallingCircuit::LockRemoteMaint)) {
case SignallingCircuit::LockLocalMaint:
*state = 0x01; // locally maint blocked
break;
case SignallingCircuit::LockRemoteMaint:
*state = 0x02; // remote maint blocked
break;
case SignallingCircuit::LockLocalMaint | SignallingCircuit::LockRemoteMaint:
*state = 0x03; // locally and remote maint blocked
break;
}
switch (circuit->locked(SignallingCircuit::LockLocalHWFail | SignallingCircuit::LockRemoteHWFail)) {
case SignallingCircuit::LockLocalHWFail:
*state |= 0x1c; // locally hw blocked
continue;
case SignallingCircuit::LockRemoteHWFail:
*state |= 0x2c; // locally hw blocked
continue;
case SignallingCircuit::LockLocalHWFail | SignallingCircuit::LockRemoteHWFail:
*state |= 0x3c; // locally and remotely hw blocked
continue;
}
if (circuit->connected())
*state |= 0x04; // incoming busy
else if (!circuit->available())
*state |= 0x08; // outgoing busy
else
*state |= 0x0c; // idle
}
else
*state = 0x03; // Unequipped
}
String tmp;
tmp.hexify(si.data(),si.length(),' ');
DDebug(this,DebugInfo,"Sending CQR (%u+%u): %s",msg->cic(),n,tmp.c_str());
SS7MsgISUP* m = new SS7MsgISUP(SS7MsgISUP::CQR,msg->cic());
m->params().addParam("RangeAndStatus",String(n));
m->params().addParam("CircuitStateIndicator",tmp);
transmitMessage(m,label,true);
}
else
reason = "unknown-channel";
break;
case SS7MsgISUP::CQR: // Circuit Group Query Response (national use)
case SS7MsgISUP::CVR: // Circuit Validation Response (ANSI)
case SS7MsgISUP::LPA: // Loopback Acknowledge (national use)
// Known but not implemented responses, just ignore them
impl = false;
break;
default:
impl = false;
// Q.764 2.9.5.1: call in Setup state:
// incoming: drop it and reset cic
// outgoing: repeat IAM and reset cic
lock();
SS7ISUPCall* call = findCall(msg->cic());
if (call)
call->ref();
unlock();
if (m_dropOnUnknown && call && call->earlyState() && msg->type() != SS7MsgISUP::CRG) {
Debug(this,DebugNote,
"Received unexpected message for call %u (%p) in initial state",
msg->cic(),call);
if (call->outgoing())
replaceCircuit(msg->cic(),String("1"),false);
else {
call->setTerminate(false,"normal",0,m_location);
SignallingCircuit* c = call->m_circuit;
if (c && c->ref())
startCircuitReset(c,String::empty());
}
}
else {
bool cnf = false;
bool release = false;
getMsgCompat(msg,release,cnf);
if (cnf || release) {
reason = "unknown-message";
unsigned char type = msg->type();
diagnostic.hexify(&type,1);
if (release) {
if (call)
call->setTerminate(true,reason,diagnostic,m_location);
else
transmitRLC(this,msg->cic(),label,true,reason,diagnostic,m_location);
// Avoid sending CNF
reason = 0;
}
}
}
TelEngine::destruct(call);
}
if (stopSGM) {
RefPointer<SS7ISUPCall> call;
findCall(msg->cic(),call);
if (call)
call->stopWaitSegment(false);
call = 0;
}
if (reason || !impl) {
Debug(this,impl?DebugNote:DebugStub,"'%s' with cic=%u: %s",
msg->name(),msg->cic(),(reason ? reason : "Not implemented, ignoring"));
if (reason)
transmitCNF(this,msg->cic(),label,true,reason,diagnostic);
}
}
// Replace a call's circuit if checkCall is true
// Release currently reseting circuit if the code match
// Clear lock flags
// See Q.764 2.9.3.1
bool SS7ISUP::resetCircuit(unsigned int cic, bool remote, bool checkCall)
{
SignallingCircuit* circuit = circuits() ? circuits()->find(cic) : 0;
if (!circuit)
return false;
DDebug(this,DebugAll,"Reseting circuit %u",cic);
if (checkCall) {
RefPointer<SS7ISUPCall> call;
findCall(cic,call);
if (call) {
if (call->outgoing() && call->state() == SS7ISUPCall::Setup) {
SignallingCircuit* newCircuit = 0;
reserveCircuit(newCircuit,call->cicRange(),SignallingCircuit::LockLockedBusy);
call->replaceCircuit(newCircuit);
}
else
call->setTerminate(false,"normal");
}
}
// Remove remote lock flags (Q.764 2.9.3.1)
if (remote && circuit->locked(SignallingCircuit::LockRemote)) {
Debug(this,DebugNote,"Unblocking remote circuit %u on reset request",cic);
circuit->hwLock(false,true,0!=circuit->locked(SignallingCircuit::LockRemoteHWFail),false);
circuit->maintLock(false,true,0!=circuit->locked(SignallingCircuit::LockRemoteMaint),false);
m_verifyEvent = true;
}
// Remove pending RSC/REL. Reset 'Resetting' flag'
SignallingMessageTimer* m = findPendingMessage(SS7MsgISUP::RSC,cic,true);
if (!m)
m = findPendingMessage(SS7MsgISUP::REL,cic,true);
if (m) {
Debug(this,DebugAll,"Pending %s`cic=%u removed",m->message()->name(),cic);
TelEngine::destruct(m);
}
circuit->resetLock(SignallingCircuit::Resetting);
if (m_rscCic && m_rscCic->code() == cic)
releaseCircuit(m_rscCic);
else
circuit->status(SignallingCircuit::Idle);
return true;
}
// Block/unblock a circuit
// See Q.764 2.8.2
bool SS7ISUP::blockCircuit(unsigned int cic, bool block, bool remote, bool hwFail,
bool changed, bool changedState, bool resetLocking)
{
XDebug(this,DebugAll,"blockCircuit(%u,%u,%u,%u,%u,%u,%u)",
cic,block,remote,hwFail,changed,changedState,resetLocking);
SignallingCircuit* circuit = circuits() ? circuits()->find(cic) : 0;
if (!circuit)
return false;
bool something = false;
if (hwFail)
something = circuit->hwLock(block,remote,changed,changedState);
else
something = circuit->maintLock(block,remote,changed,changedState);
if (resetLocking && !remote)
circuit->resetLock(hwFail ? SignallingCircuit::LockingHWFail : SignallingCircuit::LockingMaint);
if (something) {
Debug(this,DebugNote,"%s %s side of circuit %u. Current flags 0x%x",
(block ? "Blocked" : "Unblocked"),
(remote ? "remote" : "local"),
cic,circuit->locked(-1));
m_verifyEvent = true;
}
return true;
}
SS7ISUPCall* SS7ISUP::findCall(unsigned int cic)
{
for (ObjList* o = m_calls.skipNull(); o; o = o->skipNext()) {
SS7ISUPCall* call = static_cast<SS7ISUPCall*>(o->get());
if (call->id() == cic)
return call;
}
return 0;
}
// Utility used in sendLocalLock()
// Check if a circuit has lock change flag set and can be locked (not busy)
static inline bool canLock(SignallingCircuit* cic, bool hw)
{
if (hw)
return cic->locked(SignallingCircuit::LockLocalHWFailChg) &&
!cic->locked(SignallingCircuit::LockingHWFail | SignallingCircuit::Resetting);
return cic->locked(SignallingCircuit::LockLocalMaintChg) &&
!cic->locked(SignallingCircuit::LockingMaint | SignallingCircuit::Resetting);
}
// Utility: check if a circuit needs lock and not currently locking
static inline void checkNeedLock(SignallingCircuit* cic, bool& needLock)
{
if (needLock)
return;
needLock = cic->locked(SignallingCircuit::LockLocalChg) &&
!cic->locked(SignallingCircuit::LockingHWFail | SignallingCircuit::LockingMaint);
}
// Send blocking/unblocking messages
// Return false if no request was sent
bool SS7ISUP::sendLocalLock(const Time& when)
{
Lock lock(this);
if (!circuits())
return false;
bool needLock = false;
ObjList msgs;
while (true) {
bool hwReq = false;
bool lockReq = false;
unsigned int code = 0;
int locking = 0;
// Peek a starting circuit whose local state changed
ObjList* o = circuits()->circuits().skipNull();
SignallingCircuitSpan* span = 0;
for (; o; o = o->skipNext()) {
SignallingCircuit* cic = static_cast<SignallingCircuit*>(o->get());
if (canLock(cic,true)) {
hwReq = true;
lockReq = (0 != cic->locked(SignallingCircuit::LockLocalHWFail));
locking = SignallingCircuit::LockingHWFail;
}
else if (canLock(cic,false)) {
hwReq = false;
lockReq = (0 != cic->locked(SignallingCircuit::LockLocalMaint));
locking = SignallingCircuit::LockingMaint;
}
else {
checkNeedLock(cic,needLock);
continue;
}
code = cic->code();
span = cic->span();
cic->setLock(locking);
o = o->skipNext();
break;
}
if (!code)
break;
// If remote doesn't support group block/unblock just send BLK/UBL
if (!m_lockGroup)
o = 0;
// Check if we can pick a range of circuits within the same span
// with the same operation to do
// Q.763 3.43: range can be 2..256. Bit: 0-no indication 1-block/unblock.
// Max bits set to 1 must be 32
char d[256];
d[0] = '1';
unsigned int cics = 1;
unsigned int lockRange = 1;
ObjList* cicPos = o;
int newRange = 0;
int flag = hwReq ? SignallingCircuit::LockLocalHWFail : SignallingCircuit::LockLocalMaint;
for (; o && cics < 32 && lockRange < 256; o = o->skipNext()) {
SignallingCircuit* cic = static_cast<SignallingCircuit*>(o->get());
// Presume all circuits belonging to the same span to follow each other in the list
if (span != cic->span())
break;
// Make sure the circuit codes are sequential
if ((code + lockRange) != cic->code()) {
if (!newRange)
newRange = checkValidRange(code,cic->code());
checkNeedLock(cic,needLock);
continue;
}
// Add circuit to map. Skip busy circuits
// Circuit must have the same lock type and flags as the base circuit's
if (canLock(cic,hwReq) && (lockReq == (0 != cic->locked(flag)))) {
cic->setLock(locking);
d[lockRange] = '1';
cics++;
}
else {
checkNeedLock(cic,needLock);
d[lockRange] = '0';
}
lockRange++;
}
if (cics == 1) {
if (lockRange > 1) {
// Shorten the range: be nice to remote party, no need to check the whole map
if (hwReq)
lockRange = 2;
else
lockRange = 1;
}
else if (m_lockGroup && hwReq) {
if (!newRange) {
// Bad luck: check for a code before the circuit
for (o = circuits()->circuits().skipNull(); o && o != cicPos; o = o->skipNext()) {
SignallingCircuit* cic = static_cast<SignallingCircuit*>(o->get());
if (span != cic->span())
continue;
newRange = checkValidRange(code,cic->code());
if (newRange)
break;
}
}
if (newRange)
adjustRangeAndStatus(d,code,lockRange,newRange);
else
Debug(this,DebugNote,
"Failed to pick a second circuit to group HW %sblock cic=%u [%p]",
lockReq ? "" : "un",code,this);
}
}
else {
// Shorten range
unsigned int last = lockRange;
while (d[--last] == '0')
lockRange--;
}
// Build and send the message
// Don't send individual circuit blocking for HW failure (they are supposed
// to be sent for maintenance reason)
String map(d,lockRange);
SS7MsgISUP* msg = 0;
SignallingMessageTimer* t = 0;
if (m_lockGroup && (map.length() > 1 || hwReq)) {
msg = new SS7MsgISUP((lockReq ? SS7MsgISUP::CGB : SS7MsgISUP::CGU),code);
msg->params().addParam("GroupSupervisionTypeIndicator",
(hwReq ? "hw-failure" : "maintenance"));
msg->params().addParam("RangeAndStatus",String(map.length()));
msg->params().addParam("RangeAndStatus.map",map);
if (lockReq)
t = new SignallingMessageTimer(m_t18Interval,m_t19Interval);
else
t = new SignallingMessageTimer(m_t20Interval,m_t21Interval);
}
else {
msg = new SS7MsgISUP(lockReq ? SS7MsgISUP::BLK : SS7MsgISUP::UBL,code);
// Remember HW/maintenance flag
if (hwReq)
msg->params().addParam("isup_pending_block_hwfail",String::boolText(true));
if (lockReq)
t = new SignallingMessageTimer(m_t12Interval,m_t13Interval);
else
t = new SignallingMessageTimer(m_t14Interval,m_t15Interval);
}
t->message(msg);
m_pending.add(t);
msg->ref();
msgs.append(msg)->setDelete(false);
}
// Restart timer if we still have cics needing lock
DDebug(this,DebugAll,"%s circuit locking timer",needLock ? "Starting" : "Stopping");
if (needLock)
m_lockTimer.start(when.msec());
else
m_lockTimer.stop();
lock.drop();
return transmitMessages(msgs);
}
// Fill label from local/remote point codes
bool SS7ISUP::setLabel(SS7Label& label, unsigned int cic)
{
Lock lock(this);
if (!(m_remotePoint && m_defPoint))
return false;
label.assign(m_type,*m_remotePoint,*m_defPoint,
(m_defaultSls == SlsCircuit) ? cic : m_sls);
return true;
}
// Retrieve a pending message
SignallingMessageTimer* SS7ISUP::findPendingMessage(SS7MsgISUP::Type type, unsigned int cic,
bool remove)
{
Lock lock(this);
for (ObjList* o = m_pending.skipNull(); o; o = o->skipNext()) {
SignallingMessageTimer* m = static_cast<SignallingMessageTimer*>(o->get());
SS7MsgISUP* msg = static_cast<SS7MsgISUP*>(m->message());
if (msg && msg->type() == type && msg->cic() == cic) {
if (remove)
o->remove(false);
return m;
}
}
return 0;
}
// Retrieve a pending message with given parameter
SignallingMessageTimer* SS7ISUP::findPendingMessage(SS7MsgISUP::Type type, unsigned int cic,
const String& param, const String& value, bool remove)
{
Lock lock(this);
for (ObjList* o = m_pending.skipNull(); o; o = o->skipNext()) {
SignallingMessageTimer* m = static_cast<SignallingMessageTimer*>(o->get());
SS7MsgISUP* msg = static_cast<SS7MsgISUP*>(m->message());
if (msg && msg->type() == type && msg->cic() == cic && msg->params()[param] == value) {
if (remove)
o->remove(false);
return m;
}
}
return 0;
}
// Transmit a list of messages. Return true if at least 1 message was sent
bool SS7ISUP::transmitMessages(ObjList& list)
{
ObjList* o = list.skipNull();
if (!o)
return false;
for (; o; o = o->skipNext()) {
SS7MsgISUP* msg = static_cast<SS7MsgISUP*>(o->get());
SS7Label label;
setLabel(label,msg->cic());
if (m_duplicateCGB && (msg->type() == SS7MsgISUP::CGB)) {
// ANSI needs the CGB duplicated
msg->ref();
transmitMessage(msg,label,false);
}
transmitMessage(msg,label,false);
}
return true;
}
// Utility: check if a circuit exists and can be start an (un)block operation
static const char* checkBlockCic(SignallingCircuit* cic, bool block, bool maint,
bool force)
{
if (!cic)
return "not found";
int flg = cic->locked(maint ? SignallingCircuit::LockLocalMaint :
SignallingCircuit::LockLocalHWFail);
if ((block == (0 != flg)) && !force)
return "already in the same state";
flg = maint ? SignallingCircuit::LockingMaint : SignallingCircuit::LockingHWFail;
if (cic->locked(flg | SignallingCircuit::Resetting) && !force)
return "busy locking or resetting";
return 0;
}
// Handle circuit(s) (un)block command
bool SS7ISUP::handleCicBlockCommand(const NamedList& p, bool block)
{
if (!circuits())
return false;
SS7MsgISUP* msg = 0;
SS7MsgISUP::Type remove = SS7MsgISUP::Unknown;
bool force = p.getBoolValue(YSTRING("force"));
String* param = p.getParam(YSTRING("circuit"));
bool remote = p.getBoolValue(YSTRING("remote"));
Lock mylock(this);
if (param) {
if (remote) {
unsigned int code = param->toInteger();
return handleCicBlockRemoteCommand(p,&code,1,block);
}
SignallingCircuit* cic = circuits()->find(param->toInteger());
msg = buildCicBlock(cic,block,force);
if (!msg)
return false;
if (force)
remove = block ? SS7MsgISUP::UBL : SS7MsgISUP::BLK;
}
else {
// NOTE: we assume the circuits belongs to the same span for local (un)block
param = p.getParam(YSTRING("circuits"));
if (TelEngine::null(param)) {
Debug(this,DebugNote,"Circuit '%s' missing circuit(s)",
p.getValue(YSTRING("operation")));
return false;
}
// Parse the range
unsigned int count = 0;
unsigned int* cics = SignallingUtils::parseUIntArray(*param,1,0xffffffff,count,true);
if (!cics) {
// Allow '*' (all circuits) for remote
if (!(remote && *param == YSTRING("*"))) {
SignallingCircuitRange* range = circuits()->findRange(*param);
if (range)
cics = range->copyRange(count);
}
else {
String tmp;
circuits()->getCicList(tmp);
SignallingCircuitRange* range = new SignallingCircuitRange(tmp);
cics = range->copyRange(count);
TelEngine::destruct(range);
}
if (!cics) {
Debug(this,DebugNote,"Circuit group '%s': invalid circuits=%s",
p.getValue(YSTRING("operation")),param->c_str());
return false;
}
}
if (remote) {
bool ok = handleCicBlockRemoteCommand(p,cics,count,block);
delete[] cics;
return ok;
}
if (count > 32) {
Debug(this,DebugNote,"Circuit group '%s': too many circuits %u (max=32)",
p.getValue(YSTRING("operation")),count);
delete[] cics;
return false;
}
// Check if all circuits can be (un)blocked
ObjList list;
bool maint = !p.getBoolValue(YSTRING("hwfail"));
for (unsigned int i = 0; i < count; i++) {
SignallingCircuit* c = circuits()->find(cics[i]);
const char* reason = checkBlockCic(c,block,maint,force);
if (reason) {
Debug(this,DebugNote,"Circuit group '%s' range=%s failed for cic=%u: %s",
p.getValue(YSTRING("operation")),param->c_str(),cics[i],reason);
delete[] cics;
return false;
}
list.append(c)->setDelete(false);
}
// Retrieve the code: the lowest circuit code
unsigned int code = cics[0];
for (unsigned int i = 1; i < count; i++)
if (cics[i] < code)
code = cics[i];
// Build the range. Fail if falling outside maximum range
char d[256];
::memset(d,'0',256);
d[0] = '1';
unsigned int lockRange = 1;
unsigned int nCics = 0;
for (; nCics < count; nCics++) {
if (code == cics[nCics])
continue;
unsigned int pos = cics[nCics] - code;
if (pos > 255)
break;
d[pos++] = '1';
if (pos > lockRange)
lockRange = pos;
}
delete[] cics;
if (nCics != count) {
Debug(this,DebugNote,"Circuit group '%s': invalid circuit map=%s",
p.getValue(YSTRING("operation")),param->c_str());
return false;
}
if (nCics == 1) {
// Try to pick another circuit for map
SignallingCircuit* cic = static_cast<SignallingCircuit*>(list.skipNull()->get());
int newRange = 0;
for (ObjList* o = circuits()->circuits().skipNull(); o ; o = o->skipNext()) {
SignallingCircuit* c = static_cast<SignallingCircuit*>(o->get());
if (c->span() != cic->span() || c == cic)
continue;
newRange = checkValidRange(cic->code(),c->code());
if (newRange)
break;
}
if (!newRange) {
Debug(this,DebugNote,
"Circuit group '%s': failed to pick another circuit to send group command",
p.getValue(YSTRING("operation")));
return false;
}
adjustRangeAndStatus(d,code,lockRange,newRange);
}
// Ok: block circuits and send the request
int flg = maint ? SignallingCircuit::LockingMaint : SignallingCircuit::LockingHWFail;
for (ObjList* o = list.skipNull(); o ; o = o->skipNext()) {
SignallingCircuit* c = static_cast<SignallingCircuit*>(o->get());
blockCircuit(c->code(),block,false,!maint,true,true);
c->setLock(flg);
}
String map(d,lockRange);
msg = new SS7MsgISUP(block ? SS7MsgISUP::CGB : SS7MsgISUP::CGU,code);
msg->params().addParam("GroupSupervisionTypeIndicator",
(maint ? "maintenance" : "hw-failure"));
msg->params().addParam("RangeAndStatus",String(map.length()));
msg->params().addParam("RangeAndStatus.map",map);
SignallingMessageTimer* t = 0;
if (block)
t = new SignallingMessageTimer(m_t18Interval,m_t19Interval);
else
t = new SignallingMessageTimer(m_t20Interval,m_t21Interval);
t->message(msg);
m_pending.add(t);
msg->ref();
if (force)
remove = block ? SS7MsgISUP::CGU : SS7MsgISUP::CGB;
}
if (SS7MsgISUP::Unknown != remove) {
bool removed = false;
SignallingMessageTimer* pending = 0;
if (remove != SS7MsgISUP::CGB && remove != SS7MsgISUP::CGU) {
while (0 != (pending = findPendingMessage(remove,msg->cic(),true))) {
TelEngine::destruct(pending);
removed = true;
}
}
else {
NamedString* ns = msg->params().getParam(YSTRING("GroupSupervisionTypeIndicator"));
while (ns &&
0 != (pending = findPendingMessage(remove,msg->cic(),ns->name(),*ns,true))) {
TelEngine::destruct(pending);
removed = true;
}
}
if (removed)
Debug(this,DebugNote,"Removed pending operation '%s' cic=%u",
SS7MsgISUP::lookup(remove),msg->cic());
}
SS7Label label;
setLabel(label,msg->cic());
mylock.drop();
if (m_duplicateCGB && (msg->type() == SS7MsgISUP::CGB)) {
// ANSI needs the CGB duplicated
msg->ref();
transmitMessage(msg,label,false);
}
transmitMessage(msg,label,false);
return true;
}
// Handle remote circuit(s) (un)block command
bool SS7ISUP::handleCicBlockRemoteCommand(const NamedList& p, unsigned int* cics,
unsigned int count, bool block)
{
if (!(cics && count))
return false;
bool hwFail = p.getBoolValue(YSTRING("hwfail"));
if (debugAt(DebugNote)) {
String s;
for (unsigned int i = 0; i < count; i++)
s.append(String(cics[i]),",");
Debug(this,DebugNote,"Circuit remote '%s' command: hwfail=%s circuits=%s [%p]",
p.getValue(YSTRING("operation")),String::boolText(hwFail),s.c_str(),this);
}
bool found = false;
for (unsigned int i = 0; i < count; i++) {
if (blockCircuit(cics[i],block,true,hwFail,true,true))
found = true;
else
Debug(this,DebugNote,"Circuit remote '%s' command: cic %u not found [%p]",
p.getValue(YSTRING("operation")),cics[i],this);
}
if (found)
m_verifyEvent = true;
return found;
}
// Handle circuit(s) event generation command
bool SS7ISUP::handleCicEventCommand(const NamedList& p)
{
if (!circuits())
return false;
int evType = p.getIntValue(YSTRING("type"));
if (evType <= 0) {
Debug(this,DebugNote,"Control '%s': invalid type '%s'",
p.getValue(YSTRING("operation")),p.getValue(YSTRING("type")));
return false;
}
ObjList cics;
String* param = p.getParam(YSTRING("circuit"));
if (param) {
SignallingCircuit* cic = circuits()->find(param->toInteger());
if (!cic) {
Debug(this,DebugNote,"Control '%s' circuit %s not found",
p.getValue(YSTRING("operation")),param->c_str());
return false;
}
cics.append(cic)->setDelete(false);
}
else {
param = p.getParam(YSTRING("circuits"));
if (TelEngine::null(param)) {
Debug(this,DebugNote,"Control '%s' missing circuit(s)",
p.getValue(YSTRING("operation")));
return false;
}
// Parse the range
unsigned int count = 0;
unsigned int* cList = SignallingUtils::parseUIntArray(*param,1,0xffffffff,count,true);
if (!cList) {
Debug(this,DebugNote,"Control '%s' invalid circuits=%s",
p.getValue(YSTRING("operation")),param->c_str());
return false;
}
for (unsigned int i = 0; i < count; i++) {
SignallingCircuit* cic = circuits()->find(cList[i]);
if (cic) {
cics.append(cic)->setDelete(false);
continue;
}
Debug(this,DebugNote,"Control '%s' circuit %u not found",
p.getValue(YSTRING("operation")),cList[i]);
cics.clear();
break;
}
delete[] cList;
}
ObjList* o = cics.skipNull();
if (!o)
return false;
for (; o; o = o->skipNext()) {
SignallingCircuit* cic = static_cast<SignallingCircuit*>(o->get());
SignallingCircuitEvent* cicEvent = new SignallingCircuitEvent(cic,
(SignallingCircuitEvent::Type)evType);
cicEvent->copyParams(p);
SignallingEvent* ev = processCircuitEvent(cicEvent,0);
TelEngine::destruct(cicEvent);
if (ev)
delete ev;
}
return true;
}
// Try to start single circuit (un)blocking. Set a pending operation on success
// @param force True to ignore resetting/(un)blocking flags of the circuit
// Return built message to be sent on success
SS7MsgISUP* SS7ISUP::buildCicBlock(SignallingCircuit* cic, bool block, bool force)
{
const char* reason = checkBlockCic(cic,block,true,force);
if (reason) {
Debug(this,DebugNote,"Failed to start circuit %sblocking for %u: %s",
block ? "" : "un",cic ? cic->code() : 0,reason);
return 0;
}
blockCircuit(cic->code(),block,false,false,true,true);
cic->setLock(SignallingCircuit::LockingMaint);
SS7MsgISUP* m = new SS7MsgISUP(block ? SS7MsgISUP::BLK : SS7MsgISUP::UBL,cic->code());
SignallingMessageTimer* t = 0;
if (block)
t = new SignallingMessageTimer(m_t12Interval,m_t13Interval);
else
t = new SignallingMessageTimer(m_t14Interval,m_t15Interval);
t->message(m);
m_pending.add(t);
m->ref();
return m;
}
// Replace circuit for outgoing calls in Setup state
void SS7ISUP::replaceCircuit(unsigned int cic, const String& map, bool rel)
{
ObjList calls;
lock();
for (unsigned int i = 0; i < map.length(); i++) {
if (map[i] != '1')
continue;
// Replace circuit for call (Q.764 2.8.2.1)
SS7ISUPCall* call = findCall(cic + i);
if (call && call->outgoing() && call->state() == SS7ISUPCall::Setup &&
call->ref())
calls.append(call);
}
unlock();
for (ObjList* o = calls.skipNull(); o; o = o->skipNext()) {
SS7ISUPCall* call = static_cast<SS7ISUPCall*>(o->get());
Debug(this,DebugInfo,"Replacing remotely blocked cic=%u for existing call",call->id());
SignallingCircuit* newCircuit = 0;
if (call->canReplaceCircuit())
reserveCircuit(newCircuit,call->cicRange(),SignallingCircuit::LockLockedBusy);
if (!newCircuit) {
call->setTerminate(rel,"congestion",0,m_location);
if (!rel) {
SignallingCircuit* c = call->m_circuit;
if (c && c->ref())
startCircuitReset(c,String::empty());
}
continue;
}
lock();
SignallingCircuit* c = circuits()->find(call->id());
SS7MsgISUP* m = 0;
if (c && !c->locked(SignallingCircuit::Resetting)) {
c->setLock(SignallingCircuit::Resetting);
m = new SS7MsgISUP(rel ? SS7MsgISUP::REL : SS7MsgISUP::RSC,call->id());
if (rel) {
m->params().addParam("CauseIndicators","normal");
m->params().addParam("CauseIndicators.location",m_location,false);
}
m->ref();
}
unlock();
call->replaceCircuit(newCircuit,m);
if (m) {
SignallingMessageTimer* t = 0;
if (rel)
t = new SignallingMessageTimer(m_t1Interval,m_t5Interval);
else
t = new SignallingMessageTimer(m_t16Interval,m_t17Interval);
t->message(m);
m_pending.add(t);
}
}
}
// Handle circuit hw-fail block
// Replace cics for outgoing calls. Terminate incoming
void SS7ISUP::cicHwBlocked(unsigned int cic, const String& map)
{
Debug(this,DebugNote,"Circuit(s) in HW failure cic=%u map=%s",cic,map.c_str());
replaceCircuit(cic,map,true);
ObjList terminate;
lock();
for (unsigned int i = 0; i < map.length(); i++) {
if (map[i] != '1')
continue;
SS7ISUPCall* call = findCall(cic + i);
// We've made retransmit attempt for outgoing
bool processed = !call || (call->outgoing() && call->state() == SS7ISUPCall::Setup);
if (!processed && call->ref())
terminate.append(call);
}
unlock();
setCallsTerminate(terminate,true,"normal",0,m_location);
}
/**
* SS7BICC
*/
SS7BICC::SS7BICC(const NamedList& params, unsigned char sio)
: SignallingComponent(params.safe("SS7BICC"),&params,"ss7-bicc"),
SS7ISUP(params,sio)
{
m_cicLen = 4;
Debug(this,DebugInfo,"BICC Call Controller [%p]",this);
}
SS7BICC::~SS7BICC()
{
cleanup();
Debug(this,DebugInfo,"BICC Call Controller destroyed [%p]",this);
}
HandledMSU SS7BICC::receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls)
{
if (msu.getSIF() != sif() || !hasPointCode(label.dpc()) || !handlesRemotePC(label.opc()))
return HandledMSU::Rejected;
// we should have at least 4 bytes CIC and 1 byte message type
const unsigned char* s = msu.getData(label.length()+1,5);
if (!s)
return false;
unsigned int len = msu.length()-label.length()-1;
unsigned int cic = s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24);
SS7MsgISUP::Type type = (SS7MsgISUP::Type)s[4];
const char* name = SS7MsgISUP::lookup(type);
if (name) {
bool ok = processMSU(type,cic,s+5,len-5,label,network,sls);
String tmp;
tmp.hexify((void*)s,len,' ');
Debug(this,ok ? DebugInfo : DebugMild,"Unhandled BICC type %s, cic=%u, length %u: %s",
name,cic,len,tmp.c_str());
return ok;
}
String tmp;
tmp.hexify((void*)s,len,' ');
Debug(this,DebugMild,"Received unknown BICC type 0x%02x, cic=%u, length %u: %s",
type,cic,len,tmp.c_str());
return false;
}
/* vi: set ts=8 sw=4 sts=4 noet: */
Reference in New Issue View Git Blame Copy Permalink