sig_ss7.c File Reference

SS7 signaling module. More...

#include "asterisk.h"
#include <signal.h>
#include "asterisk/pbx.h"
#include "asterisk/causes.h"
#include "asterisk/musiconhold.h"
#include "asterisk/cli.h"
#include "asterisk/transcap.h"
#include "sig_ss7.h"

Include dependency graph for sig_ss7.c:

Go to the source code of this file.

Defines
#define	SIG_SS7_SC_HEADER   "%-4s %4s %-4s %-3s %-3s %-10s %-4s %s\n"
#define	SIG_SS7_SC_LINE   "%4d %4d %-4s %-3s %-3s %-10s %-4s %s"
#define	SS7_MAX_POLL   60000 /* Maximum poll time in ms. */
Functions
static unsigned char	cid_pres2ss7pres (int cid_pres)
static unsigned char	cid_pres2ss7screen (int cid_pres)
static struct ast_callid *	func_ss7_linkset_callid (struct sig_ss7_linkset *linkset, int chanpos)
int	sig_ss7_add_sigchan (struct sig_ss7_linkset *linkset, int which, int ss7type, int transport, int inalarm, int networkindicator, int pointcode, int adjpointcode)
	Setup and add a SS7 link channel.
int	sig_ss7_answer (struct sig_ss7_chan *p, struct ast_channel *ast)
	SS7 answer channel.
int	sig_ss7_available (struct sig_ss7_chan *p)
	Determine if the specified channel is available for an outgoing call.
int	sig_ss7_call (struct sig_ss7_chan *p, struct ast_channel *ast, const char *rdest)
	Dial out using the specified SS7 channel.
static const char *	sig_ss7_call_level2str (enum sig_ss7_call_level level)
void	sig_ss7_chan_delete (struct sig_ss7_chan *doomed)
	Delete the sig_ss7 private channel structure.
struct sig_ss7_chan *	sig_ss7_chan_new (void *pvt_data, struct sig_ss7_linkset *ss7)
	Create a new sig_ss7 private channel structure.
void	sig_ss7_cli_show_channels (int fd, struct sig_ss7_linkset *linkset)
void	sig_ss7_cli_show_channels_header (int fd)
static void	sig_ss7_deadlock_avoidance_private (struct sig_ss7_chan *p)
void	sig_ss7_fixup (struct ast_channel *oldchan, struct ast_channel *newchan, struct sig_ss7_chan *pchan)
	Fix up a channel: If a channel is consumed, this is called. Basically update any ->owner links.
static void	sig_ss7_handle_link_exception (struct sig_ss7_linkset *linkset, int which)
int	sig_ss7_hangup (struct sig_ss7_chan *p, struct ast_channel *ast)
	SS7 hangup channel.
int	sig_ss7_indicate (struct sig_ss7_chan *p, struct ast_channel *chan, int condition, const void *data, size_t datalen)
	SS7 answer channel.
void	sig_ss7_init_linkset (struct sig_ss7_linkset *ss7)
	Initialize the SS7 linkset control.
static int	sig_ss7_is_chan_available (struct sig_ss7_chan *pvt)
void	sig_ss7_link_alarm (struct sig_ss7_linkset *linkset, int which)
	Notify the SS7 layer that the link is in alarm.
void	sig_ss7_link_noalarm (struct sig_ss7_linkset *linkset, int which)
	Notify the SS7 layer that the link is no longer in alarm.
static void	sig_ss7_lock_owner (struct sig_ss7_linkset *ss7, int chanpos)
static void	sig_ss7_lock_private (struct sig_ss7_chan *p)
static void	sig_ss7_loopback (struct sig_ss7_chan *p, int enable)
static struct ast_channel *	sig_ss7_new_ast_channel (struct sig_ss7_chan *p, int state, int ulaw, int transfercapability, char *exten, const struct ast_channel *requestor)
static void	sig_ss7_open_media (struct sig_ss7_chan *p)
static int	sig_ss7_play_tone (struct sig_ss7_chan *p, enum sig_ss7_tone tone)
static void	sig_ss7_queue_control (struct sig_ss7_linkset *ss7, int chanpos, int subclass)
static void	sig_ss7_queue_frame (struct sig_ss7_linkset *ss7, int chanpos, struct ast_frame *frame)
struct ast_channel *	sig_ss7_request (struct sig_ss7_chan *p, enum sig_ss7_law law, const struct ast_channel *requestor, int transfercapability)
	SS7 channel request.
void	sig_ss7_set_alarm (struct sig_ss7_chan *p, int in_alarm)
static void	sig_ss7_set_caller_id (struct sig_ss7_chan *p)
static void	sig_ss7_set_dialing (struct sig_ss7_chan *p, int is_dialing)
static void	sig_ss7_set_digital (struct sig_ss7_chan *p, int is_digital)
static void	sig_ss7_set_dnid (struct sig_ss7_chan *p, const char *dnid)
static int	sig_ss7_set_echocanceller (struct sig_ss7_chan *p, int enable)
static void	sig_ss7_set_inservice (struct sig_ss7_chan *p, int is_inservice)
static void	sig_ss7_set_locallyblocked (struct sig_ss7_chan *p, int is_blocked)
static void	sig_ss7_set_outgoing (struct sig_ss7_chan *p, int is_outgoing)
static void	sig_ss7_set_remotelyblocked (struct sig_ss7_chan *p, int is_blocked)
static void	sig_ss7_unlock_private (struct sig_ss7_chan *p)
static void	ss7_apply_plan_to_number (char *buf, size_t size, const struct sig_ss7_linkset *ss7, const char *number, const unsigned nai)
static void	ss7_block_cics (struct sig_ss7_linkset *linkset, int startcic, int endcic, unsigned int dpc, unsigned char state[], int block)
static int	ss7_find_cic (struct sig_ss7_linkset *linkset, int cic, unsigned int dpc)
static int	ss7_find_cic_gripe (struct sig_ss7_linkset *linkset, int cic, unsigned int dpc, const char *msg_name)
static void	ss7_grab (struct sig_ss7_chan *pvt, struct sig_ss7_linkset *ss7)
static void	ss7_handle_cqm (struct sig_ss7_linkset *linkset, int startcic, int endcic, unsigned int dpc)
static void	ss7_hangup_cics (struct sig_ss7_linkset *linkset, int startcic, int endcic, unsigned int dpc)
static void	ss7_inservice (struct sig_ss7_linkset *linkset, int startcic, int endcic, unsigned int dpc)
void *	ss7_linkset (void *data)
static int	ss7_pres_scr2cid_pres (char presentation_ind, char screening_ind)
static void	ss7_queue_pvt_cause_data (struct ast_channel *owner, const char *cause, int ast_cause)
static void	ss7_rel (struct sig_ss7_linkset *ss7)
static void	ss7_reset_linkset (struct sig_ss7_linkset *linkset)
static void	ss7_start_call (struct sig_ss7_chan *p, struct sig_ss7_linkset *linkset)

---

Detailed Description

SS7 signaling module.

Author:

Matthew Fredrickson <creslin@digium.com>

Richard Mudgett <rmudgett@digium.com>

See Also:

• CREDITS

Definition in file sig_ss7.c.

---

Define Documentation

#define SIG_SS7_SC_HEADER   "%-4s %4s %-4s %-3s %-3s %-10s %-4s %s\n"

Definition at line 1924 of file sig_ss7.c.

Referenced by sig_ss7_cli_show_channels_header().

#define SIG_SS7_SC_LINE   "%4d %4d %-4s %-3s %-3s %-10s %-4s %s"

Definition at line 1925 of file sig_ss7.c.

Referenced by sig_ss7_cli_show_channels().

#define SS7_MAX_POLL   60000 /* Maximum poll time in ms. */

Referenced by ss7_linkset().

---

Function Documentation

static unsigned char cid_pres2ss7pres

(

int

cid_pres

)

[static]

Definition at line 1507 of file sig_ss7.c.

Referenced by sig_ss7_call().

{
    return (cid_pres >> 5) & 0x03;
}

static unsigned char cid_pres2ss7screen

(

int

cid_pres

)

[static]

Definition at line 1512 of file sig_ss7.c.

Referenced by sig_ss7_call().

{
   return cid_pres & 0x03;
}

static struct ast_callid* func_ss7_linkset_callid	(	struct sig_ss7_linkset *	linkset,
		int	chanpos
	)		[static, read]

Definition at line 766 of file sig_ss7.c.

References ast_callid_threadassoc_add(), ast_channel_callid(), ast_channel_unlock, sig_ss7_chan::owner, sig_ss7_linkset::pvts, and sig_ss7_lock_owner().

Referenced by ss7_linkset().

{
   struct ast_callid *callid = NULL;
   sig_ss7_lock_owner(linkset, chanpos);
   if (linkset->pvts[chanpos]->owner) {
      callid = ast_channel_callid(linkset->pvts[chanpos]->owner);
      ast_channel_unlock(linkset->pvts[chanpos]->owner);
      if (callid) {
         ast_callid_threadassoc_add(callid);
      }
   }

   return callid;
}

int sig_ss7_add_sigchan	(	struct sig_ss7_linkset *	linkset,
		int	which,
		int	ss7type,
		int	transport,
		int	inalarm,
		int	networkindicator,
		int	pointcode,
		int	adjpointcode
	)

Setup and add a SS7 link channel.

Since:

1.8

Parameters:

linkset	Controlling linkset for the channel.
which	Link index of the signaling channel.
ss7type	Switch type of the linkset
transport	Signaling transport of channel.
inalarm	Non-zero if the channel is in alarm.
networkindicator	User configuration parameter.
pointcode	User configuration parameter.
adjpointcode	User configuration parameter.

Return values:

0	on success.
-1	on error.

Definition at line 1448 of file sig_ss7.c.

References ast_log(), sig_ss7_linkset::fds, sig_ss7_linkset::linkstate, LINKSTATE_DOWN, LINKSTATE_INALARM, LOG_ERROR, LOG_WARNING, sig_ss7_linkset::ss7, and sig_ss7_linkset::type.

Referenced by linkset_addsigchan().

{
   if (!linkset->ss7) {
      linkset->type = ss7type;
      linkset->ss7 = ss7_new(ss7type);
      if (!linkset->ss7) {
         ast_log(LOG_ERROR, "Can't create new SS7!\n");
         return -1;
      }
   }

   ss7_set_network_ind(linkset->ss7, networkindicator);
   ss7_set_pc(linkset->ss7, pointcode);

   if (ss7_add_link(linkset->ss7, transport, linkset->fds[which])) {
      ast_log(LOG_WARNING, "Could not add SS7 link!\n");
   }

   if (inalarm) {
      linkset->linkstate[which] = LINKSTATE_DOWN | LINKSTATE_INALARM;
      ss7_link_alarm(linkset->ss7, linkset->fds[which]);
   } else {
      linkset->linkstate[which] = LINKSTATE_DOWN;
      ss7_link_noalarm(linkset->ss7, linkset->fds[which]);
   }

   ss7_set_adjpc(linkset->ss7, linkset->fds[which], adjpointcode);

   return 0;
}

int sig_ss7_answer	(	struct sig_ss7_chan *	p,
		struct ast_channel *	ast
	)

SS7 answer channel.

Since:

1.8

Parameters:

p	Signaling private structure pointer.
ast	Asterisk channel structure pointer.

Return values:

0	on success.
-1	on error.

Definition at line 1727 of file sig_ss7.c.

References sig_ss7_chan::call_level, SIG_SS7_CALL_LEVEL_CONNECT, sig_ss7_open_media(), sig_ss7_chan::ss7, sig_ss7_linkset::ss7, ss7_grab(), ss7_rel(), and sig_ss7_chan::ss7call.

Referenced by dahdi_answer().

{
   int res;

   ss7_grab(p, p->ss7);
   if (p->call_level < SIG_SS7_CALL_LEVEL_CONNECT) {
      p->call_level = SIG_SS7_CALL_LEVEL_CONNECT;
   }
   sig_ss7_open_media(p);
   res = isup_anm(p->ss7->ss7, p->ss7call);
   ss7_rel(p->ss7);
   return res;
}

int sig_ss7_available

(

struct sig_ss7_chan *

p

)

Determine if the specified channel is available for an outgoing call.

Since:

1.8

Parameters:

p	Signaling private structure pointer.

Return values:

TRUE	if the channel is available.

Definition at line 1487 of file sig_ss7.c.

References ast_mutex_lock, ast_mutex_unlock, available(), sig_ss7_chan::call_level, sig_ss7_linkset::lock, SIG_SS7_CALL_LEVEL_ALLOCATED, sig_ss7_is_chan_available(), and sig_ss7_chan::ss7.

Referenced by available().

{
   int available;

   if (!p->ss7) {
      /* Something is wrong here.  A SS7 channel without the ss7 pointer? */
      return 0;
   }

   /* Only have to deal with the linkset lock. */
   ast_mutex_lock(&p->ss7->lock);
   available = sig_ss7_is_chan_available(p);
   if (available) {
      p->call_level = SIG_SS7_CALL_LEVEL_ALLOCATED;
   }
   ast_mutex_unlock(&p->ss7->lock);

   return available;
}

int sig_ss7_call	(	struct sig_ss7_chan *	p,
		struct ast_channel *	ast,
		const char *	rdest
	)

Dial out using the specified SS7 channel.

Since:

1.8

Parameters:

p	Signaling private structure pointer.
ast	Asterisk channel structure pointer.
rdest	Dialstring.

Return values:

0	on success.
-1	on error.

Definition at line 1528 of file sig_ss7.c.

References ast_channel_connected(), ast_copy_string(), ast_log(), ast_setstate(), AST_STATE_DIALING, sig_ss7_chan::call_level, sig_ss7_linkset::called_nai, sig_ss7_linkset::calling_nai, sig_ss7_chan::cic, cid_pres2ss7pres(), cid_pres2ss7screen(), sig_ss7_chan::dpc, sig_ss7_chan::gen_add_nai, sig_ss7_chan::gen_add_num_plan, sig_ss7_chan::gen_add_pres_ind, sig_ss7_chan::gen_add_type, sig_ss7_chan::hidecallerid, ast_party_connected_line::id, sig_ss7_linkset::internationalprefix, LOG_ERROR, LOG_WARNING, sig_ss7_linkset::nationalprefix, ast_party_id::number, pbx_builtin_getvar_helper(), SIG_SS7_CALL_LEVEL_ALLOCATED, SIG_SS7_CALL_LEVEL_SETUP, sig_ss7_set_dialing(), sig_ss7_chan::ss7, sig_ss7_linkset::ss7, ss7_grab(), SS7_NAI_DYNAMIC, ss7_rel(), sig_ss7_chan::ss7call, ast_party_number::str, sig_ss7_chan::stripmsd, sig_ss7_chan::use_callingpres, and ast_party_number::valid.

Referenced by dahdi_call().

{
   char ss7_called_nai;
   int called_nai_strip;
   char ss7_calling_nai;
   int calling_nai_strip;
   const char *charge_str = NULL;
   const char *gen_address = NULL;
   const char *gen_digits = NULL;
   const char *gen_dig_type = NULL;
   const char *gen_dig_scheme = NULL;
   const char *gen_name = NULL;
   const char *jip_digits = NULL;
   const char *lspi_ident = NULL;
   const char *rlt_flag = NULL;
   const char *call_ref_id = NULL;
   const char *call_ref_pc = NULL;
   const char *send_far = NULL;
   char *c;
   char *l;
   char dest[256];

   ast_copy_string(dest, rdest, sizeof(dest));

   c = strchr(dest, '/');
   if (c) {
      c++;
   } else {
      c = "";
   }
   if (strlen(c) < p->stripmsd) {
      ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
      return -1;
   }

   if (!p->hidecallerid) {
      l = ast_channel_connected(ast)->id.number.valid ? ast_channel_connected(ast)->id.number.str : NULL;
   } else {
      l = NULL;
   }

   ss7_grab(p, p->ss7);

   if (p->call_level != SIG_SS7_CALL_LEVEL_ALLOCATED) {
      /* Call collision before sending IAM.  Abort call. */
      ss7_rel(p->ss7);
      return -1;
   }

   p->ss7call = isup_new_call(p->ss7->ss7);
   if (!p->ss7call) {
      ss7_rel(p->ss7);
      ast_log(LOG_ERROR, "Unable to allocate new SS7 call!\n");
      return -1;
   }

   called_nai_strip = 0;
   ss7_called_nai = p->ss7->called_nai;
   if (ss7_called_nai == SS7_NAI_DYNAMIC) { /* compute dynamically */
      if (strncmp(c + p->stripmsd, p->ss7->internationalprefix, strlen(p->ss7->internationalprefix)) == 0) {
         called_nai_strip = strlen(p->ss7->internationalprefix);
         ss7_called_nai = SS7_NAI_INTERNATIONAL;
      } else if (strncmp(c + p->stripmsd, p->ss7->nationalprefix, strlen(p->ss7->nationalprefix)) == 0) {
         called_nai_strip = strlen(p->ss7->nationalprefix);
         ss7_called_nai = SS7_NAI_NATIONAL;
      } else {
         ss7_called_nai = SS7_NAI_SUBSCRIBER;
      }
   }
   isup_set_called(p->ss7call, c + p->stripmsd + called_nai_strip, ss7_called_nai, p->ss7->ss7);

   calling_nai_strip = 0;
   ss7_calling_nai = p->ss7->calling_nai;
   if ((l != NULL) && (ss7_calling_nai == SS7_NAI_DYNAMIC)) { /* compute dynamically */
      if (strncmp(l, p->ss7->internationalprefix, strlen(p->ss7->internationalprefix)) == 0) {
         calling_nai_strip = strlen(p->ss7->internationalprefix);
         ss7_calling_nai = SS7_NAI_INTERNATIONAL;
      } else if (strncmp(l, p->ss7->nationalprefix, strlen(p->ss7->nationalprefix)) == 0) {
         calling_nai_strip = strlen(p->ss7->nationalprefix);
         ss7_calling_nai = SS7_NAI_NATIONAL;
      } else {
         ss7_calling_nai = SS7_NAI_SUBSCRIBER;
      }
   }
   isup_set_calling(p->ss7call, l ? (l + calling_nai_strip) : NULL, ss7_calling_nai,
      p->use_callingpres ? cid_pres2ss7pres(ast_channel_connected(ast)->id.number.presentation) : (l ? SS7_PRESENTATION_ALLOWED : SS7_PRESENTATION_RESTRICTED),
      p->use_callingpres ? cid_pres2ss7screen(ast_channel_connected(ast)->id.number.presentation) : SS7_SCREENING_USER_PROVIDED);

   isup_set_oli(p->ss7call, ast_channel_connected(ast)->ani2);
   isup_init_call(p->ss7->ss7, p->ss7call, p->cic, p->dpc);

   /* Set the charge number if it is set */
   charge_str = pbx_builtin_getvar_helper(ast, "SS7_CHARGE_NUMBER");
   if (charge_str)
      isup_set_charge(p->ss7call, charge_str, SS7_ANI_CALLING_PARTY_SUB_NUMBER, 0x10);

   gen_address = pbx_builtin_getvar_helper(ast, "SS7_GENERIC_ADDRESS");
   if (gen_address)
      isup_set_gen_address(p->ss7call, gen_address, p->gen_add_nai,p->gen_add_pres_ind, p->gen_add_num_plan,p->gen_add_type); /* need to add some types here for NAI,PRES,TYPE */

   gen_digits = pbx_builtin_getvar_helper(ast, "SS7_GENERIC_DIGITS");
   gen_dig_type = pbx_builtin_getvar_helper(ast, "SS7_GENERIC_DIGTYPE");
   gen_dig_scheme = pbx_builtin_getvar_helper(ast, "SS7_GENERIC_DIGSCHEME");
   if (gen_digits)
      isup_set_gen_digits(p->ss7call, gen_digits, atoi(gen_dig_type), atoi(gen_dig_scheme));

   gen_name = pbx_builtin_getvar_helper(ast, "SS7_GENERIC_NAME");
   if (gen_name)
      isup_set_generic_name(p->ss7call, gen_name, GEN_NAME_TYPE_CALLING_NAME, GEN_NAME_AVAIL_AVAILABLE, GEN_NAME_PRES_ALLOWED);

   jip_digits = pbx_builtin_getvar_helper(ast, "SS7_JIP");
   if (jip_digits)
      isup_set_jip_digits(p->ss7call, jip_digits);

   lspi_ident = pbx_builtin_getvar_helper(ast, "SS7_LSPI_IDENT");
   if (lspi_ident)
      isup_set_lspi(p->ss7call, lspi_ident, 0x18, 0x7, 0x00);

   rlt_flag = pbx_builtin_getvar_helper(ast, "SS7_RLT_ON");
   if ((rlt_flag) && ((strncmp("NO", rlt_flag, strlen(rlt_flag))) != 0 )) {
      isup_set_lspi(p->ss7call, rlt_flag, 0x18, 0x7, 0x00); /* Setting for Nortel DMS-250/500 */
   }

   call_ref_id = pbx_builtin_getvar_helper(ast, "SS7_CALLREF_IDENT");
   call_ref_pc = pbx_builtin_getvar_helper(ast, "SS7_CALLREF_PC");
   if (call_ref_id && call_ref_pc) {
      isup_set_callref(p->ss7call, atoi(call_ref_id),
             call_ref_pc ? atoi(call_ref_pc) : 0);
   }

   send_far = pbx_builtin_getvar_helper(ast, "SS7_SEND_FAR");
   if ((send_far) && ((strncmp("NO", send_far, strlen(send_far))) != 0 ))
      (isup_far(p->ss7->ss7, p->ss7call));

   p->call_level = SIG_SS7_CALL_LEVEL_SETUP;
   isup_iam(p->ss7->ss7, p->ss7call);
   sig_ss7_set_dialing(p, 1);
   ast_setstate(ast, AST_STATE_DIALING);
   ss7_rel(p->ss7);
   return 0;
}

static const char* sig_ss7_call_level2str

(

enum sig_ss7_call_level

level

)

[static]

Definition at line 53 of file sig_ss7.c.

References SIG_SS7_CALL_LEVEL_ALERTING, SIG_SS7_CALL_LEVEL_ALLOCATED, SIG_SS7_CALL_LEVEL_CONNECT, SIG_SS7_CALL_LEVEL_CONTINUITY, SIG_SS7_CALL_LEVEL_GLARE, SIG_SS7_CALL_LEVEL_IDLE, SIG_SS7_CALL_LEVEL_PROCEEDING, and SIG_SS7_CALL_LEVEL_SETUP.

Referenced by sig_ss7_cli_show_channels().

{
   switch (level) {
   case SIG_SS7_CALL_LEVEL_IDLE:
      return "Idle";
   case SIG_SS7_CALL_LEVEL_ALLOCATED:
      return "Allocated";
   case SIG_SS7_CALL_LEVEL_CONTINUITY:
      return "Continuity";
   case SIG_SS7_CALL_LEVEL_SETUP:
      return "Setup";
   case SIG_SS7_CALL_LEVEL_PROCEEDING:
      return "Proceeding";
   case SIG_SS7_CALL_LEVEL_ALERTING:
      return "Alerting";
   case SIG_SS7_CALL_LEVEL_CONNECT:
      return "Connect";
   case SIG_SS7_CALL_LEVEL_GLARE:
      return "Glare";
   }
   return "Unknown";
}

void sig_ss7_chan_delete

(

struct sig_ss7_chan *

doomed

)

Delete the sig_ss7 private channel structure.

Since:

1.8

Parameters:

doomed

sig_ss7 private channel structure to delete.

Returns:

Nothing

Definition at line 1919 of file sig_ss7.c.

References ast_free.

Referenced by destroy_dahdi_pvt().

{
   ast_free(doomed);
}

struct sig_ss7_chan* sig_ss7_chan_new	(	void *	pvt_data,
		struct sig_ss7_linkset *	ss7
	)		[read]

Create a new sig_ss7 private channel structure.

Since:

1.8

Parameters:

pvt_data	Upper layer private data structure.
ss7	Controlling linkset for the channel.

Return values:

sig_ss7_chan	on success.
NULL	on error.

Definition at line 1979 of file sig_ss7.c.

References ast_calloc, sig_ss7_chan::chan_pvt, and sig_ss7_chan::ss7.

Referenced by mkintf().

{
   struct sig_ss7_chan *pvt;

   pvt = ast_calloc(1, sizeof(*pvt));
   if (!pvt) {
      return pvt;
   }

   pvt->chan_pvt = pvt_data;
   pvt->ss7 = ss7;

   return pvt;
}

void sig_ss7_cli_show_channels	(	int	fd,
		struct sig_ss7_linkset *	linkset
	)

Definition at line 1932 of file sig_ss7.c.

References ast_channel_name(), ast_channel_unlock, ast_cli(), ast_mutex_lock, ast_mutex_unlock, sig_ss7_chan::call_level, sig_ss7_chan::channel, sig_ss7_chan::locallyblocked, sig_ss7_linkset::lock, sig_ss7_linkset::numchans, sig_ss7_chan::owner, sig_ss7_linkset::pvts, sig_ss7_chan::remotelyblocked, sig_ss7_call_level2str(), sig_ss7_is_chan_available(), sig_ss7_lock_owner(), sig_ss7_lock_private(), SIG_SS7_SC_LINE, sig_ss7_unlock_private(), sig_ss7_linkset::span, and sig_ss7_chan::ss7call.

Referenced by handle_ss7_show_channels().

{
   char line[256];
   int idx;
   struct sig_ss7_chan *pvt;

   ast_mutex_lock(&linkset->lock);
   for (idx = 0; idx < linkset->numchans; ++idx) {
      if (!linkset->pvts[idx]) {
         continue;
      }
      pvt = linkset->pvts[idx];
      sig_ss7_lock_private(pvt);
      sig_ss7_lock_owner(linkset, idx);

      snprintf(line, sizeof(line), SIG_SS7_SC_LINE,
         linkset->span,
         pvt->channel,
         sig_ss7_is_chan_available(pvt) ? "Yes" : "No",
         pvt->locallyblocked ? "Yes" : "No",
         pvt->remotelyblocked ? "Yes" : "No",
         sig_ss7_call_level2str(pvt->call_level),
         pvt->ss7call ? "Yes" : "No",
         pvt->owner ? ast_channel_name(pvt->owner) : "");

      if (pvt->owner) {
         ast_channel_unlock(pvt->owner);
      }
      sig_ss7_unlock_private(pvt);

      ast_mutex_unlock(&linkset->lock);
      ast_cli(fd, "%s\n", line);
      ast_mutex_lock(&linkset->lock);
   }
   ast_mutex_unlock(&linkset->lock);
}

void sig_ss7_cli_show_channels_header

(

int

fd

)

Definition at line 1926 of file sig_ss7.c.

References ast_cli(), and SIG_SS7_SC_HEADER.

Referenced by handle_ss7_show_channels().

{
   ast_cli(fd, SIG_SS7_SC_HEADER, "link", "",     "Chan", "Lcl", "Rem", "Call",  "SS7",  "Channel");
   ast_cli(fd, SIG_SS7_SC_HEADER, "set",  "Chan", "Idle", "Blk", "Blk", "Level", "Call", "Name");
}

static void sig_ss7_deadlock_avoidance_private

(

struct sig_ss7_chan *

p

)

[static]

Definition at line 90 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::deadlock_avoidance_private, sig_ss7_callbacks, sig_ss7_lock_private(), and sig_ss7_unlock_private().

Referenced by ss7_grab().

{
   if (sig_ss7_callbacks.deadlock_avoidance_private) {
      sig_ss7_callbacks.deadlock_avoidance_private(p->chan_pvt);
   } else {
      /* Fallback to the old way if callback not present. */
      sig_ss7_unlock_private(p);
      sched_yield();
      sig_ss7_lock_private(p);
   }
}

void sig_ss7_fixup	(	struct ast_channel *	oldchan,
		struct ast_channel *	newchan,
		struct sig_ss7_chan *	pchan
	)

Fix up a channel: If a channel is consumed, this is called. Basically update any ->owner links.

Since:

1.8

Parameters:

oldchan	Old channel pointer to replace.
newchan	New channel pointer to set.
pchan	Signaling private structure pointer.

Returns:

Nothing

Definition at line 1751 of file sig_ss7.c.

References sig_ss7_chan::owner.

Referenced by dahdi_fixup().

{
   if (pchan->owner == oldchan) {
      pchan->owner = newchan;
   }
}

static void sig_ss7_handle_link_exception	(	struct sig_ss7_linkset *	linkset,
		int	which
	)		[static]

Definition at line 287 of file sig_ss7.c.

References sig_ss7_callback::handle_link_exception, and sig_ss7_callbacks.

Referenced by ss7_linkset().

{
   if (sig_ss7_callbacks.handle_link_exception) {
      sig_ss7_callbacks.handle_link_exception(linkset, which);
   }
}

int sig_ss7_hangup	(	struct sig_ss7_chan *	p,
		struct ast_channel *	ast
	)

SS7 hangup channel.

Since:

1.8

Parameters:

p	Signaling private structure pointer.
ast	Asterisk channel structure pointer.

Return values:

0	on success.
-1	on error.

Definition at line 1680 of file sig_ss7.c.

References sig_ss7_chan::alreadyhungup, ast_channel_hangupcause(), ast_channel_tech_pvt(), ast_log(), sig_ss7_chan::call_level, sig_ss7_chan::exten, LOG_WARNING, sig_ss7_chan::owner, pbx_builtin_getvar_helper(), sig_ss7_chan::progress, sig_ss7_chan::rlt, SIG_SS7_CALL_LEVEL_IDLE, sig_ss7_set_dialing(), sig_ss7_set_outgoing(), sig_ss7_chan::ss7, sig_ss7_linkset::ss7, ss7_grab(), ss7_rel(), and sig_ss7_chan::ss7call.

Referenced by dahdi_hangup().

{
   int res = 0;

   if (!ast_channel_tech_pvt(ast)) {
      ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
      return 0;
   }

   p->owner = NULL;
   sig_ss7_set_dialing(p, 0);
   sig_ss7_set_outgoing(p, 0);
   p->progress = 0;
   p->rlt = 0;
   p->exten[0] = '\0';
   /* Perform low level hangup if no owner left */
   ss7_grab(p, p->ss7);
   p->call_level = SIG_SS7_CALL_LEVEL_IDLE;
   if (p->ss7call) {
      if (!p->alreadyhungup) {
         const char *cause = pbx_builtin_getvar_helper(ast,"SS7_CAUSE");
         int icause = ast_channel_hangupcause(ast) ? ast_channel_hangupcause(ast) : -1;

         if (cause) {
            if (atoi(cause)) {
               icause = atoi(cause);
            }
         }
         isup_rel(p->ss7->ss7, p->ss7call, icause);
         p->alreadyhungup = 1;
      }
   }
   ss7_rel(p->ss7);

   return res;
}

int sig_ss7_indicate	(	struct sig_ss7_chan *	p,
		struct ast_channel *	chan,
		int	condition,
		const void *	data,
		size_t	datalen
	)

SS7 answer channel.

Since:

1.8

Parameters:

p	Signaling private structure pointer.
chan	Asterisk channel structure pointer.
condition	AST control frame subtype.
data	AST control frame payload contents.
datalen	Length of payload contents.

Return values:

0	on success.
-1	on error or indication condition not handled.

Definition at line 1771 of file sig_ss7.c.

References AST_CAUSE_CONGESTION, AST_CAUSE_INVALID_NUMBER_FORMAT, AST_CAUSE_USER_BUSY, ast_channel_hangupcause_set(), ast_channel_name(), AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HOLD, AST_CONTROL_INCOMPLETE, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, AST_CONTROL_SRCUPDATE, AST_CONTROL_UNHOLD, ast_debug, ast_moh_start(), ast_moh_stop(), ast_setstate(), AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, sig_ss7_chan::call_level, sig_ss7_chan::mohinterpret, sig_ss7_chan::outgoing, sig_ss7_chan::progress, sig_ss7_chan::rlt, SIG_SS7_CALL_LEVEL_ALERTING, SIG_SS7_CALL_LEVEL_CONNECT, SIG_SS7_CALL_LEVEL_PROCEEDING, sig_ss7_play_tone(), sig_ss7_set_echocanceller(), SIG_SS7_TONE_BUSY, SIG_SS7_TONE_CONGESTION, SIG_SS7_TONE_RINGTONE, sig_ss7_chan::ss7, sig_ss7_linkset::ss7, ss7_grab(), ss7_rel(), and sig_ss7_chan::ss7call.

Referenced by dahdi_indicate().

{
   int res = -1;

   switch (condition) {
   case AST_CONTROL_BUSY:
      if (p->call_level < SIG_SS7_CALL_LEVEL_CONNECT) {
         ast_channel_hangupcause_set(chan, AST_CAUSE_USER_BUSY);
         ast_softhangup_nolock(chan, AST_SOFTHANGUP_DEV);
         res = 0;
         break;
      }
      res = sig_ss7_play_tone(p, SIG_SS7_TONE_BUSY);
      break;
   case AST_CONTROL_RINGING:
      ss7_grab(p, p->ss7);
      if (p->call_level < SIG_SS7_CALL_LEVEL_ALERTING && !p->outgoing) {
         p->call_level = SIG_SS7_CALL_LEVEL_ALERTING;
         if ((isup_far(p->ss7->ss7, p->ss7call)) != -1) {
            p->rlt = 1;
         }

         /* No need to send CPG if call will be RELEASE */
         if (p->rlt != 1) {
            isup_cpg(p->ss7->ss7, p->ss7call, CPG_EVENT_ALERTING);
         }
      }
      ss7_rel(p->ss7);

      res = sig_ss7_play_tone(p, SIG_SS7_TONE_RINGTONE);

      if (ast_channel_state(chan) != AST_STATE_UP && ast_channel_state(chan) != AST_STATE_RING) {
         ast_setstate(chan, AST_STATE_RINGING);
      }
      break;
   case AST_CONTROL_PROCEEDING:
      ast_debug(1,"Received AST_CONTROL_PROCEEDING on %s\n",ast_channel_name(chan));
      ss7_grab(p, p->ss7);
      /* This IF sends the FAR for an answered ALEG call */
      if (ast_channel_state(chan) == AST_STATE_UP && (p->rlt != 1)){
         if ((isup_far(p->ss7->ss7, p->ss7call)) != -1) {
            p->rlt = 1;
         }
      }

      if (p->call_level < SIG_SS7_CALL_LEVEL_PROCEEDING && !p->outgoing) {
         p->call_level = SIG_SS7_CALL_LEVEL_PROCEEDING;
         isup_acm(p->ss7->ss7, p->ss7call);
      }
      ss7_rel(p->ss7);
      /* don't continue in ast_indicate */
      res = 0;
      break;
   case AST_CONTROL_PROGRESS:
      ast_debug(1,"Received AST_CONTROL_PROGRESS on %s\n",ast_channel_name(chan));
      ss7_grab(p, p->ss7);
      if (!p->progress && p->call_level < SIG_SS7_CALL_LEVEL_ALERTING && !p->outgoing) {
         p->progress = 1;/* No need to send inband-information progress again. */
         isup_cpg(p->ss7->ss7, p->ss7call, CPG_EVENT_INBANDINFO);
         ss7_rel(p->ss7);

         /* enable echo canceler here on SS7 calls */
         sig_ss7_set_echocanceller(p, 1);
      } else {
         ss7_rel(p->ss7);
      }
      /* don't continue in ast_indicate */
      res = 0;
      break;
   case AST_CONTROL_INCOMPLETE:
      if (p->call_level < SIG_SS7_CALL_LEVEL_CONNECT) {
         ast_channel_hangupcause_set(chan, AST_CAUSE_INVALID_NUMBER_FORMAT);
         ast_softhangup_nolock(chan, AST_SOFTHANGUP_DEV);
         res = 0;
         break;
      }
      /* Wait for DTMF digits to complete the dialed number. */
      res = 0;
      break;
   case AST_CONTROL_CONGESTION:
      if (p->call_level < SIG_SS7_CALL_LEVEL_CONNECT) {
         ast_channel_hangupcause_set(chan, AST_CAUSE_CONGESTION);
         ast_softhangup_nolock(chan, AST_SOFTHANGUP_DEV);
         res = 0;
         break;
      }
      res = sig_ss7_play_tone(p, SIG_SS7_TONE_CONGESTION);
      break;
   case AST_CONTROL_HOLD:
      ast_moh_start(chan, data, p->mohinterpret);
      break;
   case AST_CONTROL_UNHOLD:
      ast_moh_stop(chan);
      break;
   case AST_CONTROL_SRCUPDATE:
      res = 0;
      break;
   case -1:
      res = sig_ss7_play_tone(p, -1);
      break;
   }
   return res;
}

void sig_ss7_init_linkset

(

struct sig_ss7_linkset *

ss7

)

Initialize the SS7 linkset control.

Since:

1.8

Parameters:

ss7	SS7 linkset control structure.

Returns:

Nothing

Definition at line 2002 of file sig_ss7.c.

References ARRAY_LEN, ast_mutex_init, AST_PTHREADT_NULL, sig_ss7_linkset::fds, sig_ss7_linkset::lock, and sig_ss7_linkset::master.

Referenced by dahdi_restart(), and load_module().

{
   int idx;

   memset(ss7, 0, sizeof(*ss7));

   ast_mutex_init(&ss7->lock);

   ss7->master = AST_PTHREADT_NULL;
   for (idx = 0; idx < ARRAY_LEN(ss7->fds); ++idx) {
      ss7->fds[idx] = -1;
   }
}

static int sig_ss7_is_chan_available

(

struct sig_ss7_chan *

pvt

)

[static]

Definition at line 302 of file sig_ss7.c.

References sig_ss7_chan::call_level, sig_ss7_chan::inalarm, sig_ss7_chan::locallyblocked, sig_ss7_chan::owner, sig_ss7_chan::remotelyblocked, SIG_SS7_CALL_LEVEL_IDLE, and sig_ss7_chan::ss7call.

Referenced by sig_ss7_available(), sig_ss7_cli_show_channels(), and ss7_linkset().

{
   if (!pvt->inalarm && !pvt->owner && !pvt->ss7call
      && pvt->call_level == SIG_SS7_CALL_LEVEL_IDLE
      && !pvt->locallyblocked && !pvt->remotelyblocked) {
      return 1;
   }
   return 0;
}

void sig_ss7_link_alarm	(	struct sig_ss7_linkset *	linkset,
		int	which
	)

Notify the SS7 layer that the link is in alarm.

Since:

1.8

Parameters:

linkset	Controlling linkset for the channel.
which	Link index of the signaling channel.

Returns:

Nothing

Definition at line 1409 of file sig_ss7.c.

References sig_ss7_linkset::fds, sig_ss7_linkset::linkstate, LINKSTATE_DOWN, LINKSTATE_INALARM, LINKSTATE_UP, and sig_ss7_linkset::ss7.

Referenced by my_handle_link_exception().

{
   linkset->linkstate[which] |= (LINKSTATE_DOWN | LINKSTATE_INALARM);
   linkset->linkstate[which] &= ~LINKSTATE_UP;
   ss7_link_alarm(linkset->ss7, linkset->fds[which]);
}

void sig_ss7_link_noalarm	(	struct sig_ss7_linkset *	linkset,
		int	which
	)

Notify the SS7 layer that the link is no longer in alarm.

Since:

1.8

Parameters:

linkset	Controlling linkset for the channel.
which	Link index of the signaling channel.

Returns:

Nothing

Definition at line 1425 of file sig_ss7.c.

References sig_ss7_linkset::fds, sig_ss7_linkset::linkstate, LINKSTATE_DOWN, LINKSTATE_INALARM, LINKSTATE_STARTING, and sig_ss7_linkset::ss7.

Referenced by my_handle_link_exception().

{
   linkset->linkstate[which] &= ~(LINKSTATE_INALARM | LINKSTATE_DOWN);
   linkset->linkstate[which] |= LINKSTATE_STARTING;
   ss7_link_noalarm(linkset->ss7, linkset->fds[which]);
}

static void sig_ss7_lock_owner	(	struct sig_ss7_linkset *	ss7,
		int	chanpos
	)		[static]

Definition at line 325 of file sig_ss7.c.

References ast_channel_trylock, DEADLOCK_AVOIDANCE, sig_ss7_linkset::lock, sig_ss7_chan::owner, sig_ss7_linkset::pvts, sig_ss7_lock_private(), and sig_ss7_unlock_private().

Referenced by func_ss7_linkset_callid(), sig_ss7_cli_show_channels(), sig_ss7_queue_frame(), ss7_hangup_cics(), and ss7_linkset().

{
   for (;;) {
      if (!ss7->pvts[chanpos]->owner) {
         /* There is no owner lock to get. */
         break;
      }
      if (!ast_channel_trylock(ss7->pvts[chanpos]->owner)) {
         /* We got the lock */
         break;
      }

      /* Avoid deadlock */
      sig_ss7_unlock_private(ss7->pvts[chanpos]);
      DEADLOCK_AVOIDANCE(&ss7->lock);
      sig_ss7_lock_private(ss7->pvts[chanpos]);
   }
}

static void sig_ss7_lock_private

(

struct sig_ss7_chan *

p

)

[static]

Definition at line 83 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::lock_private, and sig_ss7_callbacks.

Referenced by sig_ss7_cli_show_channels(), sig_ss7_deadlock_avoidance_private(), sig_ss7_lock_owner(), ss7_hangup_cics(), ss7_linkset(), and ss7_start_call().

{
   if (sig_ss7_callbacks.lock_private) {
      sig_ss7_callbacks.lock_private(p->chan_pvt);
   }
}

static void sig_ss7_loopback	(	struct sig_ss7_chan *	p,
		int	enable
	)		[static]

Definition at line 250 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_chan::loopedback, sig_ss7_callback::set_loopback, and sig_ss7_callbacks.

Referenced by ss7_linkset().

{
   if (p->loopedback != enable) {
      p->loopedback = enable;
      if (sig_ss7_callbacks.set_loopback) {
         sig_ss7_callbacks.set_loopback(p->chan_pvt, enable);
      }
   }
}

static struct ast_channel* sig_ss7_new_ast_channel	(	struct sig_ss7_chan *	p,
		int	state,
		int	ulaw,
		int	transfercapability,
		char *	exten,
		const struct ast_channel *	requestor
	)		[static, read]

Definition at line 260 of file sig_ss7.c.

References sig_ss7_chan::alreadyhungup, ast_channel_transfercapability_set(), AST_TRANS_CAP_DIGITAL, ast_transfercapability2str(), sig_ss7_chan::chan_pvt, sig_ss7_callback::new_ast_channel, sig_ss7_chan::owner, pbx_builtin_setvar_helper(), sig_ss7_callbacks, and sig_ss7_set_digital().

Referenced by sig_ss7_request(), and ss7_start_call().

{
   struct ast_channel *ast;

   if (sig_ss7_callbacks.new_ast_channel) {
      ast = sig_ss7_callbacks.new_ast_channel(p->chan_pvt, state, ulaw, exten, requestor);
   } else {
      return NULL;
   }
   if (!ast) {
      return NULL;
   }

   if (!p->owner) {
      p->owner = ast;
   }
   p->alreadyhungup = 0;
   ast_channel_transfercapability_set(ast, transfercapability);
   pbx_builtin_setvar_helper(ast, "TRANSFERCAPABILITY",
      ast_transfercapability2str(transfercapability));
   if (transfercapability & AST_TRANS_CAP_DIGITAL) {
      sig_ss7_set_digital(p, 1);
   }

   return ast;
}

static void sig_ss7_open_media

(

struct sig_ss7_chan *

p

)

[static]

Definition at line 164 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::open_media, and sig_ss7_callbacks.

Referenced by sig_ss7_answer(), and ss7_linkset().

{
   if (sig_ss7_callbacks.open_media) {
      sig_ss7_callbacks.open_media(p->chan_pvt);
   }
}

static int sig_ss7_play_tone	(	struct sig_ss7_chan *	p,
		enum sig_ss7_tone	tone
	)		[static]

Definition at line 230 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::play_tone, and sig_ss7_callbacks.

Referenced by sig_ss7_indicate().

{
   int res;

   if (sig_ss7_callbacks.play_tone) {
      res = sig_ss7_callbacks.play_tone(p->chan_pvt, tone);
   } else {
      res = -1;
   }
   return res;
}

static void sig_ss7_queue_control	(	struct sig_ss7_linkset *	ss7,
		int	chanpos,
		int	subclass
	)		[static]

Definition at line 381 of file sig_ss7.c.

References AST_FRAME_CONTROL, sig_ss7_chan::chan_pvt, ast_frame_subclass::integer, sig_ss7_linkset::pvts, sig_ss7_callback::queue_control, sig_ss7_callbacks, sig_ss7_queue_frame(), and ast_frame::subclass.

Referenced by ss7_linkset().

{
   struct ast_frame f = {AST_FRAME_CONTROL, };
   struct sig_ss7_chan *p = ss7->pvts[chanpos];

   if (sig_ss7_callbacks.queue_control) {
      sig_ss7_callbacks.queue_control(p->chan_pvt, subclass);
   }

   f.subclass.integer = subclass;
   sig_ss7_queue_frame(ss7, chanpos, &f);
}

static void sig_ss7_queue_frame	(	struct sig_ss7_linkset *	ss7,
		int	chanpos,
		struct ast_frame *	frame
	)		[static]

Definition at line 358 of file sig_ss7.c.

References ast_channel_unlock, ast_queue_frame(), sig_ss7_chan::owner, sig_ss7_linkset::pvts, and sig_ss7_lock_owner().

Referenced by sig_ss7_queue_control().

{
   sig_ss7_lock_owner(ss7, chanpos);
   if (ss7->pvts[chanpos]->owner) {
      ast_queue_frame(ss7->pvts[chanpos]->owner, frame);
      ast_channel_unlock(ss7->pvts[chanpos]->owner);
   }
}

struct ast_channel* sig_ss7_request	(	struct sig_ss7_chan *	p,
		enum sig_ss7_law	law,
		const struct ast_channel *	requestor,
		int	transfercapability
	)		[read]

SS7 channel request.

Since:

1.8

Parameters:

p	Signaling private structure pointer.
law	Companding law preferred
requestor	Asterisk channel requesting a channel to dial (Can be NULL)
transfercapability

Return values:

ast_channel	on success.
NULL	on error.

Definition at line 1887 of file sig_ss7.c.

References ast_mutex_lock, ast_mutex_unlock, AST_STATE_RESERVED, sig_ss7_chan::call_level, sig_ss7_chan::exten, sig_ss7_linkset::lock, SIG_SS7_ALAW, SIG_SS7_CALL_LEVEL_IDLE, sig_ss7_new_ast_channel(), sig_ss7_set_outgoing(), SIG_SS7_ULAW, sig_ss7_chan::ss7, and sig_ss7_linkset::type.

Referenced by dahdi_request().

{
   struct ast_channel *ast;

   /* Companding law is determined by SS7 signaling type. */
   if (p->ss7->type == SS7_ITU) {
      law = SIG_SS7_ALAW;
   } else {
      law = SIG_SS7_ULAW;
   }

   sig_ss7_set_outgoing(p, 1);
   ast = sig_ss7_new_ast_channel(p, AST_STATE_RESERVED, law, transfercapability, p->exten, requestor);
   if (!ast) {
      sig_ss7_set_outgoing(p, 0);

      /* Release the allocated channel.  Only have to deal with the linkset lock. */
      ast_mutex_lock(&p->ss7->lock);
      p->call_level = SIG_SS7_CALL_LEVEL_IDLE;
      ast_mutex_unlock(&p->ss7->lock);
   }
   return ast;
}

void sig_ss7_set_alarm	(	struct sig_ss7_chan *	p,
		int	in_alarm
	)

Definition at line 102 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_chan::inalarm, sig_ss7_callback::set_alarm, and sig_ss7_callbacks.

Referenced by dahdi_handle_event(), handle_init_event(), mkintf(), and ss7_linkset().

{
   p->inalarm = in_alarm;
   if (sig_ss7_callbacks.set_alarm) {
      sig_ss7_callbacks.set_alarm(p->chan_pvt, in_alarm);
   }
}

static void sig_ss7_set_caller_id

(

struct sig_ss7_chan *

p

)

[static]

Definition at line 180 of file sig_ss7.c.

References ast_party_caller::ani, ast_party_caller::ani2, ast_party_caller_init(), ast_strlen_zero(), sig_ss7_chan::callingpres, sig_ss7_chan::chan_pvt, sig_ss7_chan::cid_ani, sig_ss7_chan::cid_ani2, sig_ss7_chan::cid_name, sig_ss7_chan::cid_num, sig_ss7_chan::cid_subaddr, sig_ss7_chan::cid_ton, ast_party_caller::id, ast_party_id::name, ast_party_id::number, ast_party_number::plan, ast_party_name::presentation, ast_party_number::presentation, sig_ss7_callback::set_callerid, sig_ss7_callbacks, ast_party_name::str, ast_party_number::str, ast_party_subaddress::str, ast_party_id::subaddress, ast_party_name::valid, ast_party_number::valid, and ast_party_subaddress::valid.

Referenced by ss7_linkset().

{
   struct ast_party_caller caller;

   if (sig_ss7_callbacks.set_callerid) {
      ast_party_caller_init(&caller);

      caller.id.name.str = p->cid_name;
      caller.id.name.presentation = p->callingpres;
      caller.id.name.valid = 1;

      caller.id.number.str = p->cid_num;
      caller.id.number.plan = p->cid_ton;
      caller.id.number.presentation = p->callingpres;
      caller.id.number.valid = 1;

      if (!ast_strlen_zero(p->cid_subaddr)) {
         caller.id.subaddress.valid = 1;
         //caller.id.subaddress.type = 0;/* nsap */
         //caller.id.subaddress.odd_even_indicator = 0;
         caller.id.subaddress.str = p->cid_subaddr;
      }

      caller.ani.number.str = p->cid_ani;
      //caller.ani.number.plan = p->xxx;
      //caller.ani.number.presentation = p->xxx;
      caller.ani.number.valid = 1;

      caller.ani2 = p->cid_ani2;
      sig_ss7_callbacks.set_callerid(p->chan_pvt, &caller);
   }
}

static void sig_ss7_set_dialing	(	struct sig_ss7_chan *	p,
		int	is_dialing
	)		[static]

Definition at line 110 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::set_dialing, and sig_ss7_callbacks.

Referenced by sig_ss7_call(), sig_ss7_hangup(), and ss7_linkset().

{
   if (sig_ss7_callbacks.set_dialing) {
      sig_ss7_callbacks.set_dialing(p->chan_pvt, is_dialing);
   }
}

static void sig_ss7_set_digital	(	struct sig_ss7_chan *	p,
		int	is_digital
	)		[static]

Definition at line 117 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::set_digital, and sig_ss7_callbacks.

Referenced by sig_ss7_new_ast_channel().

{
   if (sig_ss7_callbacks.set_digital) {
      sig_ss7_callbacks.set_digital(p->chan_pvt, is_digital);
   }
}

static void sig_ss7_set_dnid	(	struct sig_ss7_chan *	p,
		const char *	dnid
	)		[static]

Definition at line 223 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::set_dnid, and sig_ss7_callbacks.

Referenced by ss7_linkset().

{
   if (sig_ss7_callbacks.set_dnid) {
      sig_ss7_callbacks.set_dnid(p->chan_pvt, dnid);
   }
}

static int sig_ss7_set_echocanceller	(	struct sig_ss7_chan *	p,
		int	enable
	)		[static]

Definition at line 242 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::set_echocanceller, and sig_ss7_callbacks.

Referenced by sig_ss7_indicate(), ss7_linkset(), and ss7_start_call().

{
   if (sig_ss7_callbacks.set_echocanceller) {
      return sig_ss7_callbacks.set_echocanceller(p->chan_pvt, enable);
   }
   return -1;
}

static void sig_ss7_set_inservice	(	struct sig_ss7_chan *	p,
		int	is_inservice
	)		[static]

Definition at line 132 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callback::set_inservice, and sig_ss7_callbacks.

Referenced by ss7_inservice(), and ss7_linkset().

{
   if (sig_ss7_callbacks.set_inservice) {
      sig_ss7_callbacks.set_inservice(p->chan_pvt, is_inservice);
   }
}

static void sig_ss7_set_locallyblocked	(	struct sig_ss7_chan *	p,
		int	is_blocked
	)		[static]

Definition at line 139 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_chan::locallyblocked, sig_ss7_callback::set_locallyblocked, and sig_ss7_callbacks.

Referenced by ss7_linkset().

{
   p->locallyblocked = is_blocked;
   if (sig_ss7_callbacks.set_locallyblocked) {
      sig_ss7_callbacks.set_locallyblocked(p->chan_pvt, is_blocked);
   }
}

static void sig_ss7_set_outgoing	(	struct sig_ss7_chan *	p,
		int	is_outgoing
	)		[static]

Definition at line 124 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_chan::outgoing, sig_ss7_callback::set_outgoing, and sig_ss7_callbacks.

Referenced by sig_ss7_hangup(), and sig_ss7_request().

{
   p->outgoing = is_outgoing;
   if (sig_ss7_callbacks.set_outgoing) {
      sig_ss7_callbacks.set_outgoing(p->chan_pvt, is_outgoing);
   }
}

static void sig_ss7_set_remotelyblocked	(	struct sig_ss7_chan *	p,
		int	is_blocked
	)		[static]

Definition at line 147 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_chan::remotelyblocked, sig_ss7_callback::set_remotelyblocked, and sig_ss7_callbacks.

Referenced by ss7_block_cics(), and ss7_linkset().

{
   p->remotelyblocked = is_blocked;
   if (sig_ss7_callbacks.set_remotelyblocked) {
      sig_ss7_callbacks.set_remotelyblocked(p->chan_pvt, is_blocked);
   }
}

static void sig_ss7_unlock_private

(

struct sig_ss7_chan *

p

)

[static]

Definition at line 76 of file sig_ss7.c.

References sig_ss7_chan::chan_pvt, sig_ss7_callbacks, and sig_ss7_callback::unlock_private.

Referenced by sig_ss7_cli_show_channels(), sig_ss7_deadlock_avoidance_private(), sig_ss7_lock_owner(), ss7_hangup_cics(), ss7_linkset(), and ss7_start_call().

{
   if (sig_ss7_callbacks.unlock_private) {
      sig_ss7_callbacks.unlock_private(p->chan_pvt);
   }
}

static void ss7_apply_plan_to_number	(	char *	buf,
		size_t	size,
		const struct sig_ss7_linkset *	ss7,
		const char *	number,
		const unsigned	nai
	)		[static]

Definition at line 719 of file sig_ss7.c.

References ast_strlen_zero(), sig_ss7_linkset::internationalprefix, sig_ss7_linkset::nationalprefix, sig_ss7_linkset::subscriberprefix, and sig_ss7_linkset::unknownprefix.

Referenced by ss7_linkset().

{
   if (ast_strlen_zero(number)) { /* make sure a number exists so prefix isn't placed on an empty string */
      if (size) {
         *buf = '\0';
      }
      return;
   }
   switch (nai) {
   case SS7_NAI_INTERNATIONAL:
      snprintf(buf, size, "%s%s", ss7->internationalprefix, number);
      break;
   case SS7_NAI_NATIONAL:
      snprintf(buf, size, "%s%s", ss7->nationalprefix, number);
      break;
   case SS7_NAI_SUBSCRIBER:
      snprintf(buf, size, "%s%s", ss7->subscriberprefix, number);
      break;
   case SS7_NAI_UNKNOWN:
      snprintf(buf, size, "%s%s", ss7->unknownprefix, number);
      break;
   default:
      snprintf(buf, size, "%s", number);
      break;
   }
}

static void ss7_block_cics	(	struct sig_ss7_linkset *	linkset,
		int	startcic,
		int	endcic,
		unsigned int	dpc,
		unsigned char	state[],
		int	block
	)		[inline, static]

Definition at line 521 of file sig_ss7.c.

References sig_ss7_chan::cic, sig_ss7_chan::dpc, sig_ss7_linkset::numchans, sig_ss7_linkset::pvts, and sig_ss7_set_remotelyblocked().

Referenced by ss7_linkset().

{
   int i;

   /* XXX the use of state here seems questionable about matching up with the linkset channels */
   for (i = 0; i < linkset->numchans; i++) {
      if (linkset->pvts[i] && (linkset->pvts[i]->dpc == dpc && ((linkset->pvts[i]->cic >= startcic) && (linkset->pvts[i]->cic <= endcic)))) {
         if (state) {
            if (state[i])
               sig_ss7_set_remotelyblocked(linkset->pvts[i], block);
         } else
            sig_ss7_set_remotelyblocked(linkset->pvts[i], block);
      }
   }
}

static int ss7_find_cic	(	struct sig_ss7_linkset *	linkset,
		int	cic,
		unsigned int	dpc
	)		[static]

Definition at line 434 of file sig_ss7.c.

References sig_ss7_chan::cic, sig_ss7_chan::dpc, sig_ss7_linkset::numchans, and sig_ss7_linkset::pvts.

Referenced by ss7_find_cic_gripe().

{
   int i;
   int winner = -1;
   for (i = 0; i < linkset->numchans; i++) {
      if (linkset->pvts[i] && (linkset->pvts[i]->dpc == dpc && linkset->pvts[i]->cic == cic)) {
         winner = i;
         break;
      }
   }
   return winner;
}

static int ss7_find_cic_gripe	(	struct sig_ss7_linkset *	linkset,
		int	cic,
		unsigned int	dpc,
		const char *	msg_name
	)		[static]

Definition at line 459 of file sig_ss7.c.

References ast_log(), LOG_WARNING, sig_ss7_linkset::span, and ss7_find_cic().

Referenced by ss7_linkset().

{
   int chanpos;

   chanpos = ss7_find_cic(linkset, cic, dpc);
   if (chanpos < 0) {
      ast_log(LOG_WARNING, "Linkset %d: SS7 %s requested unconfigured CIC/DPC %d/%d.\n",
         linkset->span, msg_name, cic, dpc);
      return -1;
   }
   return chanpos;
}

static void ss7_grab	(	struct sig_ss7_chan *	pvt,
		struct sig_ss7_linkset *	ss7
	)		[static]

Definition at line 1387 of file sig_ss7.c.

References ast_mutex_trylock, AST_PTHREADT_NULL, sig_ss7_linkset::lock, sig_ss7_linkset::master, and sig_ss7_deadlock_avoidance_private().

Referenced by sig_ss7_answer(), sig_ss7_call(), sig_ss7_hangup(), and sig_ss7_indicate().

{
   /* Grab the lock first */
   while (ast_mutex_trylock(&ss7->lock)) {
      /* Avoid deadlock */
      sig_ss7_deadlock_avoidance_private(pvt);
   }
   /* Then break the poll */
   if (ss7->master != AST_PTHREADT_NULL) {
      pthread_kill(ss7->master, SIGURG);
   }
}

static void ss7_handle_cqm	(	struct sig_ss7_linkset *	linkset,
		int	startcic,
		int	endcic,
		unsigned int	dpc
	)		[static]

Definition at line 472 of file sig_ss7.c.

References ast_log(), sig_ss7_chan::cic, sig_ss7_chan::dpc, sig_ss7_chan::locallyblocked, LOG_WARNING, sig_ss7_linkset::numchans, sig_ss7_chan::outgoing, sig_ss7_linkset::pvts, sig_ss7_chan::remotelyblocked, sig_ss7_linkset::ss7, sig_ss7_chan::ss7call, and status.

Referenced by ss7_linkset().

{
   unsigned char status[32];
   struct sig_ss7_chan *p = NULL;
   int i, offset;

   for (i = 0; i < linkset->numchans; i++) {
      if (linkset->pvts[i] && (linkset->pvts[i]->dpc == dpc && ((linkset->pvts[i]->cic >= startcic) && (linkset->pvts[i]->cic <= endcic)))) {
         p = linkset->pvts[i];
         offset = p->cic - startcic;
         status[offset] = 0;
         if (p->locallyblocked)
            status[offset] |= (1 << 0) | (1 << 4);
         if (p->remotelyblocked)
            status[offset] |= (1 << 1) | (1 << 5);
         if (p->ss7call) {
            if (p->outgoing)
               status[offset] |= (1 << 3);
            else
               status[offset] |= (1 << 2);
         } else
            status[offset] |= 0x3 << 2;
      }
   }

   if (p)
      isup_cqr(linkset->ss7, startcic, endcic, dpc, status);
   else
      ast_log(LOG_WARNING, "Could not find any equipped circuits within CQM CICs\n");

}

static void ss7_hangup_cics	(	struct sig_ss7_linkset *	linkset,
		int	startcic,
		int	endcic,
		unsigned int	dpc
	)		[inline, static]

Definition at line 504 of file sig_ss7.c.

References ast_channel_unlock, AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), sig_ss7_chan::cic, sig_ss7_chan::dpc, sig_ss7_linkset::numchans, sig_ss7_chan::owner, sig_ss7_linkset::pvts, sig_ss7_lock_owner(), sig_ss7_lock_private(), and sig_ss7_unlock_private().

Referenced by ss7_linkset().

{
   int i;

   for (i = 0; i < linkset->numchans; i++) {
      if (linkset->pvts[i] && (linkset->pvts[i]->dpc == dpc && ((linkset->pvts[i]->cic >= startcic) && (linkset->pvts[i]->cic <= endcic)))) {
         sig_ss7_lock_private(linkset->pvts[i]);
         sig_ss7_lock_owner(linkset, i);
         if (linkset->pvts[i]->owner) {
            ast_softhangup_nolock(linkset->pvts[i]->owner, AST_SOFTHANGUP_DEV);
            ast_channel_unlock(linkset->pvts[i]->owner);
         }
         sig_ss7_unlock_private(linkset->pvts[i]);
      }
   }
}

static void ss7_inservice	(	struct sig_ss7_linkset *	linkset,
		int	startcic,
		int	endcic,
		unsigned int	dpc
	)		[static]

Definition at line 537 of file sig_ss7.c.

References sig_ss7_chan::cic, sig_ss7_chan::dpc, sig_ss7_linkset::numchans, sig_ss7_linkset::pvts, and sig_ss7_set_inservice().

Referenced by ss7_linkset().

{
   int i;

   for (i = 0; i < linkset->numchans; i++) {
      if (linkset->pvts[i] && (linkset->pvts[i]->dpc == dpc && ((linkset->pvts[i]->cic >= startcic) && (linkset->pvts[i]->cic <= endcic))))
         sig_ss7_set_inservice(linkset->pvts[i], 1);
   }
}

void* ss7_linkset

(

void *

data

)

Todo:

The handling of the SS7 FAA message is not good and I don't know enough to handle it correctly.

Definition at line 782 of file sig_ss7.c.

References sig_ss7_chan::alreadyhungup, ast_assert, ast_callid_threadassoc_remove(), ast_callid_unref, AST_CAUSE_INTERWORKING, AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, AST_CAUSE_UNALLOCATED, ast_channel_hangupcause_set(), ast_channel_unlock, AST_CONTROL_ANSWER, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, ast_copy_string(), ast_debug, ast_exists_extension(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_setstate(), AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), AST_STATE_RINGING, ast_strlen_zero(), ast_tvnow(), ast_verbose(), sig_ss7_chan::call_level, sig_ss7_linkset::called_nai, sig_ss7_linkset::calling_nai, sig_ss7_chan::calling_party_cat, sig_ss7_chan::callingpres, sig_ss7_chan::charge_number, sig_ss7_chan::cic, sig_ss7_chan::cid_ani, sig_ss7_chan::cid_ani2, sig_ss7_chan::cid_name, sig_ss7_chan::cid_num, sig_ss7_chan::cid_ton, sig_ss7_chan::context, sig_ss7_linkset::debug, sig_ss7_chan::dpc, errno, sig_ss7_chan::exten, sig_ss7_linkset::fds, func_ss7_linkset_callid(), sig_ss7_chan::gen_add_nai, sig_ss7_chan::gen_add_num_plan, sig_ss7_chan::gen_add_number, sig_ss7_chan::gen_add_pres_ind, sig_ss7_chan::gen_add_type, sig_ss7_chan::gen_dig_number, sig_ss7_chan::gen_dig_scheme, sig_ss7_chan::gen_dig_type, sig_ss7_chan::generic_name, sig_ss7_chan::immediate, sig_ss7_chan::jip_number, sig_ss7_linkset::lock, LOG_ERROR, LOG_NOTICE, LOG_WARNING, sig_ss7_chan::loopedback, sig_ss7_linkset::numchans, sig_ss7_linkset::numsigchans, sig_ss7_chan::orig_called_num, sig_ss7_chan::owner, sig_ss7_chan::progress, sig_ss7_linkset::pvts, sig_ss7_chan::redirecting_num, sig_ss7_chan::rlt, SIG_SS7_CALL_LEVEL_ALERTING, SIG_SS7_CALL_LEVEL_ALLOCATED, SIG_SS7_CALL_LEVEL_CONNECT, SIG_SS7_CALL_LEVEL_CONTINUITY, SIG_SS7_CALL_LEVEL_GLARE, SIG_SS7_CALL_LEVEL_IDLE, SIG_SS7_CALL_LEVEL_PROCEEDING, SIG_SS7_DEBUG_DEFAULT, sig_ss7_handle_link_exception(), sig_ss7_is_chan_available(), sig_ss7_lock_owner(), sig_ss7_lock_private(), sig_ss7_loopback(), sig_ss7_open_media(), sig_ss7_queue_control(), sig_ss7_set_alarm(), sig_ss7_set_caller_id(), sig_ss7_set_dialing(), sig_ss7_set_dnid(), sig_ss7_set_echocanceller(), sig_ss7_set_inservice(), sig_ss7_set_locallyblocked(), sig_ss7_set_remotelyblocked(), sig_ss7_unlock_private(), sig_ss7_linkset::span, sig_ss7_linkset::ss7, ss7_apply_plan_to_number(), ss7_block_cics(), ss7_find_cic_gripe(), ss7_handle_cqm(), ss7_hangup_cics(), ss7_inservice(), SS7_MAX_POLL, ss7_pres_scr2cid_pres(), ss7_queue_pvt_cause_data(), ss7_reset_linkset(), ss7_start_call(), sig_ss7_chan::ss7call, sig_ss7_linkset::state, tv, and sig_ss7_chan::use_callerid.

Referenced by setup_dahdi_int().

{
   int res, i;
   struct timeval *next = NULL, tv;
   struct sig_ss7_linkset *linkset = (struct sig_ss7_linkset *) data;
   struct ss7 *ss7 = linkset->ss7;
   ss7_event *e = NULL;
   struct sig_ss7_chan *p;
   struct pollfd pollers[SIG_SS7_NUM_DCHANS];
   int nextms;

#define SS7_MAX_POLL 60000 /* Maximum poll time in ms. */

   pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

   ss7_set_debug(ss7, SIG_SS7_DEBUG_DEFAULT);
   ast_mutex_lock(&linkset->lock);
   ss7_start(ss7);
   ast_mutex_unlock(&linkset->lock);

   for (;;) {
      ast_mutex_lock(&linkset->lock);
      if ((next = ss7_schedule_next(ss7))) {
         tv = ast_tvnow();
         tv.tv_sec = next->tv_sec - tv.tv_sec;
         tv.tv_usec = next->tv_usec - tv.tv_usec;
         if (tv.tv_usec < 0) {
            tv.tv_usec += 1000000;
            tv.tv_sec -= 1;
         }
         if (tv.tv_sec < 0) {
            tv.tv_sec = 0;
            tv.tv_usec = 0;
         }
         nextms = tv.tv_sec * 1000;
         nextms += tv.tv_usec / 1000;
         if (SS7_MAX_POLL < nextms) {
            nextms = SS7_MAX_POLL;
         }
      } else {
         nextms = SS7_MAX_POLL;
      }

      for (i = 0; i < linkset->numsigchans; i++) {
         pollers[i].fd = linkset->fds[i];
         pollers[i].events = ss7_pollflags(ss7, linkset->fds[i]);
         pollers[i].revents = 0;
      }
      ast_mutex_unlock(&linkset->lock);

      pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
      pthread_testcancel();
      res = poll(pollers, linkset->numsigchans, nextms);
      pthread_testcancel();
      pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

      if ((res < 0) && (errno != EINTR)) {
         ast_log(LOG_ERROR, "poll(%s)\n", strerror(errno));
      } else if (!res) {
         ast_mutex_lock(&linkset->lock);
         ss7_schedule_run(ss7);
         ast_mutex_unlock(&linkset->lock);
         continue;
      }

      ast_mutex_lock(&linkset->lock);
      for (i = 0; i < linkset->numsigchans; i++) {
         if (pollers[i].revents & POLLPRI) {
            sig_ss7_handle_link_exception(linkset, i);
         }
         if (pollers[i].revents & POLLIN) {
            res = ss7_read(ss7, pollers[i].fd);
         }
         if (pollers[i].revents & POLLOUT) {
            res = ss7_write(ss7, pollers[i].fd);
            if (res < 0) {
               ast_debug(1, "Error in write %s\n", strerror(errno));
            }
         }
      }

      while ((e = ss7_check_event(ss7))) {
         struct ast_callid *callid = NULL;
         int chanpos = -1;
         char cause_str[30];

         if (linkset->debug) {
            ast_verbose("Linkset %d: Processing event: %s\n",
               linkset->span, ss7_event2str(e->e));
         }

         switch (e->e) {
         case SS7_EVENT_UP:
            if (linkset->state != LINKSET_STATE_UP) {
               ast_verbose("--- SS7 Up ---\n");
               ss7_reset_linkset(linkset);
            }
            linkset->state = LINKSET_STATE_UP;
            break;
         case SS7_EVENT_DOWN:
            ast_verbose("--- SS7 Down ---\n");
            linkset->state = LINKSET_STATE_DOWN;
            for (i = 0; i < linkset->numchans; i++) {
               p = linkset->pvts[i];
               if (p) {
                  sig_ss7_set_alarm(p, 1);
               }
            }
            break;
         case MTP2_LINK_UP:
            ast_verbose("MTP2 link up (SLC %d)\n", e->gen.data);
            break;
         case MTP2_LINK_DOWN:
            ast_log(LOG_WARNING, "MTP2 link down (SLC %d)\n", e->gen.data);
            break;
         case ISUP_EVENT_CPG:
            chanpos = ss7_find_cic_gripe(linkset, e->cpg.cic, e->cpg.opc, "CPG");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            sig_ss7_lock_private(p);
            callid = func_ss7_linkset_callid(linkset, chanpos);

            switch (e->cpg.event) {
            case CPG_EVENT_ALERTING:
               if (p->call_level < SIG_SS7_CALL_LEVEL_ALERTING) {
                  p->call_level = SIG_SS7_CALL_LEVEL_ALERTING;
               }
               sig_ss7_lock_owner(linkset, chanpos);
               if (p->owner) {
                  ast_setstate(p->owner, AST_STATE_RINGING);
                  ast_channel_unlock(p->owner);
               }
               sig_ss7_queue_control(linkset, chanpos, AST_CONTROL_RINGING);
               break;
            case CPG_EVENT_PROGRESS:
            case CPG_EVENT_INBANDINFO:
               {
                  ast_debug(1, "Queuing frame PROGRESS on CIC %d\n", p->cic);
                  sig_ss7_queue_control(linkset, chanpos, AST_CONTROL_PROGRESS);
                  p->progress = 1;
                  sig_ss7_set_dialing(p, 0);
                  sig_ss7_open_media(p);
               }
               break;
            default:
               ast_debug(1, "Do not handle CPG with event type 0x%x\n", e->cpg.event);
               break;
            }

            sig_ss7_unlock_private(p);
            break;
         case ISUP_EVENT_RSC:
            ast_verbose("Resetting CIC %d\n", e->rsc.cic);
            chanpos = ss7_find_cic_gripe(linkset, e->rsc.cic, e->rsc.opc, "RSC");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            sig_ss7_lock_private(p);
            callid = func_ss7_linkset_callid(linkset, chanpos);
            sig_ss7_set_inservice(p, 1);
            sig_ss7_set_remotelyblocked(p, 0);
            isup_set_call_dpc(e->rsc.call, p->dpc);
            sig_ss7_lock_owner(linkset, chanpos);
            p->ss7call = NULL;
            if (p->owner) {
               ss7_queue_pvt_cause_data(p->owner, "SS7 ISUP_EVENT_RSC", AST_CAUSE_INTERWORKING);
               ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
               ast_channel_unlock(p->owner);
            }
            sig_ss7_unlock_private(p);
            isup_rlc(ss7, e->rsc.call);
            break;
         case ISUP_EVENT_GRS:
            ast_debug(1, "Got Reset for CICs %d to %d: Acknowledging\n", e->grs.startcic, e->grs.endcic);
            chanpos = ss7_find_cic_gripe(linkset, e->grs.startcic, e->grs.opc, "GRS");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            isup_gra(ss7, e->grs.startcic, e->grs.endcic, e->grs.opc);
            ss7_block_cics(linkset, e->grs.startcic, e->grs.endcic, e->grs.opc, NULL, 0);
            ss7_hangup_cics(linkset, e->grs.startcic, e->grs.endcic, e->grs.opc);
            break;
         case ISUP_EVENT_CQM:
            ast_debug(1, "Got Circuit group query message from CICs %d to %d\n", e->cqm.startcic, e->cqm.endcic);
            ss7_handle_cqm(linkset, e->cqm.startcic, e->cqm.endcic, e->cqm.opc);
            break;
         case ISUP_EVENT_GRA:
            ast_verbose("Got reset acknowledgement from CIC %d to %d.\n", e->gra.startcic, e->gra.endcic);
            ss7_inservice(linkset, e->gra.startcic, e->gra.endcic, e->gra.opc);
            ss7_block_cics(linkset, e->gra.startcic, e->gra.endcic, e->gra.opc, e->gra.status, 1);
            break;
         case ISUP_EVENT_IAM:
            ast_debug(1, "Got IAM for CIC %d and called number %s, calling number %s\n", e->iam.cic, e->iam.called_party_num, e->iam.calling_party_num);
            chanpos = ss7_find_cic_gripe(linkset, e->iam.cic, e->iam.opc, "IAM");
            if (chanpos < 0) {
               isup_rel(ss7, e->iam.call, -1);
               break;
            }
            p = linkset->pvts[chanpos];
            sig_ss7_lock_private(p);
            sig_ss7_lock_owner(linkset, chanpos);
            if (p->call_level != SIG_SS7_CALL_LEVEL_IDLE) {
               /*
                * Detected glare/dual-seizure
                *
                * Always abort both calls since we can't implement the dual
                * seizure procedures due to our channel assignment architecture
                * and the fact that we cannot tell libss7 to discard its call
                * structure to ignore the incoming IAM.
                */
               ast_debug(1,
                  "Linkset %d: SS7 IAM glare on CIC/DPC %d/%d.  Dropping both calls.\n",
                  linkset->span, e->iam.cic, e->iam.opc);
               if (p->call_level == SIG_SS7_CALL_LEVEL_ALLOCATED) {
                  /*
                   * We have not sent our IAM yet and we never will at this point.
                   */
                  p->alreadyhungup = 1;
                  isup_rel(ss7, e->iam.call, AST_CAUSE_NORMAL_CIRCUIT_CONGESTION);
               }
               p->call_level = SIG_SS7_CALL_LEVEL_GLARE;
               if (p->owner) {
                  ss7_queue_pvt_cause_data(p->owner, "SS7 ISUP_EVENT_IAM (glare)", AST_CAUSE_NORMAL_CIRCUIT_CONGESTION);
                  ast_channel_hangupcause_set(p->owner, AST_CAUSE_NORMAL_CIRCUIT_CONGESTION);
                  ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
                  ast_channel_unlock(p->owner);
               }
               sig_ss7_unlock_private(p);
               break;
            }
            /*
             * The channel should not have an owner at this point since we
             * are in the process of creating an owner for it.
             */
            ast_assert(!p->owner);

            if (!sig_ss7_is_chan_available(p)) {
               /* Circuit is likely blocked or in alarm. */
               isup_rel(ss7, e->iam.call, AST_CAUSE_NORMAL_CIRCUIT_CONGESTION);
               sig_ss7_unlock_private(p);
               break;
            }

            /* Mark channel as in use so no outgoing call will steal it. */
            p->call_level = SIG_SS7_CALL_LEVEL_ALLOCATED;
            p->ss7call = e->iam.call;

            isup_set_call_dpc(p->ss7call, p->dpc);

            if ((p->use_callerid) && (!ast_strlen_zero(e->iam.calling_party_num))) {
               ss7_apply_plan_to_number(p->cid_num, sizeof(p->cid_num), linkset, e->iam.calling_party_num, e->iam.calling_nai);
               p->callingpres = ss7_pres_scr2cid_pres(e->iam.presentation_ind, e->iam.screening_ind);
            } else
               p->cid_num[0] = 0;

            /* Set DNID */
            if (!ast_strlen_zero(e->iam.called_party_num)) {
               ss7_apply_plan_to_number(p->exten, sizeof(p->exten), linkset,
                  e->iam.called_party_num, e->iam.called_nai);
            } else {
               p->exten[0] = '\0';
            }
            sig_ss7_set_dnid(p, p->exten);

            if (p->immediate) {
               p->exten[0] = 's';
               p->exten[1] = '\0';
            } else if (!ast_strlen_zero(e->iam.called_party_num)) {
               char *st;
               ss7_apply_plan_to_number(p->exten, sizeof(p->exten), linkset, e->iam.called_party_num, e->iam.called_nai);
               st = strchr(p->exten, '#');
               if (st) {
                  *st = '\0';
               }
            } else {
               p->exten[0] = '\0';
            }

            p->cid_ani[0] = '\0';
            if ((p->use_callerid) && (!ast_strlen_zero(e->iam.generic_name)))
               ast_copy_string(p->cid_name, e->iam.generic_name, sizeof(p->cid_name));
            else
               p->cid_name[0] = '\0';

            p->cid_ani2 = e->iam.oli_ani2;
            p->cid_ton = 0;
            ast_copy_string(p->charge_number, e->iam.charge_number, sizeof(p->charge_number));
            ast_copy_string(p->gen_add_number, e->iam.gen_add_number, sizeof(p->gen_add_number));
            p->gen_add_type = e->iam.gen_add_type;
            p->gen_add_nai = e->iam.gen_add_nai;
            p->gen_add_pres_ind = e->iam.gen_add_pres_ind;
            p->gen_add_num_plan = e->iam.gen_add_num_plan;
            ast_copy_string(p->gen_dig_number, e->iam.gen_dig_number, sizeof(p->gen_dig_number));
            p->gen_dig_type = e->iam.gen_dig_type;
            p->gen_dig_scheme = e->iam.gen_dig_scheme;
            ast_copy_string(p->jip_number, e->iam.jip_number, sizeof(p->jip_number));
            ast_copy_string(p->orig_called_num, e->iam.orig_called_num, sizeof(p->orig_called_num));
            ast_copy_string(p->redirecting_num, e->iam.redirecting_num, sizeof(p->redirecting_num));
            ast_copy_string(p->generic_name, e->iam.generic_name, sizeof(p->generic_name));
            p->calling_party_cat = e->iam.calling_party_cat;

            sig_ss7_set_caller_id(p);

            if (ast_exists_extension(NULL, p->context, p->exten, 1, p->cid_num)) {
               if (e->iam.cot_check_required) {
                  p->call_level = SIG_SS7_CALL_LEVEL_CONTINUITY;
                  sig_ss7_loopback(p, 1);
               } else {
                  ss7_start_call(p, linkset);
               }
            } else {
               ast_debug(1, "Call on CIC for unconfigured extension %s\n", p->exten);
               p->alreadyhungup = 1;
               isup_rel(ss7, e->iam.call, AST_CAUSE_UNALLOCATED);
            }
            sig_ss7_unlock_private(p);
            break;
         case ISUP_EVENT_COT:
            chanpos = ss7_find_cic_gripe(linkset, e->cot.cic, e->cot.opc, "COT");
            if (chanpos < 0) {
               isup_rel(ss7, e->cot.call, -1);
               break;
            }
            p = linkset->pvts[chanpos];

            sig_ss7_lock_private(p);
            if (p->loopedback) {
               sig_ss7_loopback(p, 0);
               ss7_start_call(p, linkset);
            }
            sig_ss7_unlock_private(p);
            break;
         case ISUP_EVENT_CCR:
            ast_debug(1, "Got CCR request on CIC %d\n", e->ccr.cic);
            chanpos = ss7_find_cic_gripe(linkset, e->ccr.cic, e->ccr.opc, "CCR");
            if (chanpos < 0) {
               break;
            }

            p = linkset->pvts[chanpos];

            sig_ss7_lock_private(p);
            sig_ss7_loopback(p, 1);
            sig_ss7_unlock_private(p);

            isup_lpa(linkset->ss7, e->ccr.cic, p->dpc);
            break;
         case ISUP_EVENT_CVT:
            ast_debug(1, "Got CVT request on CIC %d\n", e->cvt.cic);
            chanpos = ss7_find_cic_gripe(linkset, e->cvt.cic, e->cvt.opc, "CVT");
            if (chanpos < 0) {
               break;
            }

            p = linkset->pvts[chanpos];

            sig_ss7_lock_private(p);
            sig_ss7_loopback(p, 1);
            sig_ss7_unlock_private(p);

            isup_cvr(linkset->ss7, e->cvt.cic, p->dpc);
            break;
         case ISUP_EVENT_REL:
            chanpos = ss7_find_cic_gripe(linkset, e->rel.cic, e->rel.opc, "REL");
            if (chanpos < 0) {
               /* Continue hanging up the call anyway. */
               isup_rlc(ss7, e->rel.call);
               break;
            }
            p = linkset->pvts[chanpos];
            sig_ss7_lock_private(p);
            callid = func_ss7_linkset_callid(linkset, chanpos);
            sig_ss7_lock_owner(linkset, chanpos);
            if (p->owner) {
               snprintf(cause_str, sizeof(cause_str), "SS7 ISUP_EVENT_REL (%d)", e->rel.cause);
               ss7_queue_pvt_cause_data(p->owner, cause_str, e->rel.cause);

               ast_channel_hangupcause_set(p->owner, e->rel.cause);
               ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
               ast_channel_unlock(p->owner);
            }

            /* End the loopback if we have one */
            sig_ss7_loopback(p, 0);

            isup_rlc(ss7, e->rel.call);
            p->ss7call = NULL;

            sig_ss7_unlock_private(p);
            break;
         case ISUP_EVENT_ACM:
            chanpos = ss7_find_cic_gripe(linkset, e->acm.cic, e->acm.opc, "ACM");
            if (chanpos < 0) {
               isup_rel(ss7, e->acm.call, -1);
               break;
            }
            {
               p = linkset->pvts[chanpos];

               ast_debug(1, "Queueing frame from SS7_EVENT_ACM on CIC %d\n", p->cic);

               if (e->acm.call_ref_ident > 0) {
                  p->rlt = 1; /* Setting it but not using it here*/
               }

               sig_ss7_lock_private(p);
               callid = func_ss7_linkset_callid(linkset, chanpos);
               sig_ss7_queue_control(linkset, chanpos, AST_CONTROL_PROCEEDING);
               if (p->call_level < SIG_SS7_CALL_LEVEL_PROCEEDING) {
                  p->call_level = SIG_SS7_CALL_LEVEL_PROCEEDING;
               }
               sig_ss7_set_dialing(p, 0);
               /* Send alerting if subscriber is free */
               if (e->acm.called_party_status_ind == 1) {
                  if (p->call_level < SIG_SS7_CALL_LEVEL_ALERTING) {
                     p->call_level = SIG_SS7_CALL_LEVEL_ALERTING;
                  }
                  sig_ss7_lock_owner(linkset, chanpos);
                  if (p->owner) {
                     ast_setstate(p->owner, AST_STATE_RINGING);
                     ast_channel_unlock(p->owner);
                  }
                  sig_ss7_queue_control(linkset, chanpos, AST_CONTROL_RINGING);
               }
               sig_ss7_unlock_private(p);
            }
            break;
         case ISUP_EVENT_CGB:
            chanpos = ss7_find_cic_gripe(linkset, e->cgb.startcic, e->cgb.opc, "CGB");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            ss7_block_cics(linkset, e->cgb.startcic, e->cgb.endcic, e->cgb.opc, e->cgb.status, 1);
            isup_cgba(linkset->ss7, e->cgb.startcic, e->cgb.endcic, e->cgb.opc, e->cgb.status, e->cgb.type);
            break;
         case ISUP_EVENT_CGU:
            chanpos = ss7_find_cic_gripe(linkset, e->cgu.startcic, e->cgu.opc, "CGU");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            ss7_block_cics(linkset, e->cgu.startcic, e->cgu.endcic, e->cgu.opc, e->cgu.status, 0);
            isup_cgua(linkset->ss7, e->cgu.startcic, e->cgu.endcic, e->cgu.opc, e->cgu.status, e->cgu.type);
            break;
         case ISUP_EVENT_UCIC:
            chanpos = ss7_find_cic_gripe(linkset, e->ucic.cic, e->ucic.opc, "UCIC");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            ast_debug(1, "Unequiped Circuit Id Code on CIC %d\n", e->ucic.cic);
            sig_ss7_lock_private(p);
            sig_ss7_set_remotelyblocked(p, 1);
            sig_ss7_set_inservice(p, 0);
            sig_ss7_unlock_private(p);/* doesn't require a SS7 acknowledgement */
            break;
         case ISUP_EVENT_BLO:
            chanpos = ss7_find_cic_gripe(linkset, e->blo.cic, e->blo.opc, "BLO");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            ast_debug(1, "Blocking CIC %d\n", e->blo.cic);
            sig_ss7_lock_private(p);
            sig_ss7_set_remotelyblocked(p, 1);
            sig_ss7_unlock_private(p);
            isup_bla(linkset->ss7, e->blo.cic, p->dpc);
            break;
         case ISUP_EVENT_BLA:
            chanpos = ss7_find_cic_gripe(linkset, e->bla.cic, e->bla.opc, "BLA");
            if (chanpos < 0) {
               break;
            }
            ast_debug(1, "Blocking CIC %d\n", e->bla.cic);
            p = linkset->pvts[chanpos];
            sig_ss7_lock_private(p);
            sig_ss7_set_locallyblocked(p, 1);
            sig_ss7_unlock_private(p);
            break;
         case ISUP_EVENT_UBL:
            chanpos = ss7_find_cic_gripe(linkset, e->ubl.cic, e->ubl.opc, "UBL");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            ast_debug(1, "Unblocking CIC %d\n", e->ubl.cic);
            sig_ss7_lock_private(p);
            sig_ss7_set_remotelyblocked(p, 0);
            sig_ss7_unlock_private(p);
            isup_uba(linkset->ss7, e->ubl.cic, p->dpc);
            break;
         case ISUP_EVENT_UBA:
            chanpos = ss7_find_cic_gripe(linkset, e->uba.cic, e->uba.opc, "UBA");
            if (chanpos < 0) {
               break;
            }
            p = linkset->pvts[chanpos];
            ast_debug(1, "Unblocking CIC %d\n", e->uba.cic);
            sig_ss7_lock_private(p);
            sig_ss7_set_locallyblocked(p, 0);
            sig_ss7_unlock_private(p);
            break;
         case ISUP_EVENT_CON:
         case ISUP_EVENT_ANM:
            if (e->e == ISUP_EVENT_CON) {
               chanpos = ss7_find_cic_gripe(linkset, e->con.cic, e->con.opc, "CON");
               if (chanpos < 0) {
                  isup_rel(ss7, e->con.call, -1);
                  break;
               }
            } else {
               chanpos = ss7_find_cic_gripe(linkset, e->anm.cic, e->anm.opc, "ANM");
               if (chanpos < 0) {
                  isup_rel(ss7, e->anm.call, -1);
                  break;
               }
            }

            {
               p = linkset->pvts[chanpos];
               sig_ss7_lock_private(p);
               callid = func_ss7_linkset_callid(linkset, chanpos);
               if (p->call_level < SIG_SS7_CALL_LEVEL_CONNECT) {
                  p->call_level = SIG_SS7_CALL_LEVEL_CONNECT;
               }
               sig_ss7_queue_control(linkset, chanpos, AST_CONTROL_ANSWER);
               sig_ss7_set_dialing(p, 0);
               sig_ss7_open_media(p);
               sig_ss7_set_echocanceller(p, 1);
               sig_ss7_unlock_private(p);
            }
            break;
         case ISUP_EVENT_RLC:
            /* XXX Call ptr should be passed up from libss7! */
            chanpos = ss7_find_cic_gripe(linkset, e->rlc.cic, e->rlc.opc, "RLC");
            if (chanpos < 0) {
               break;
            }
            {
               p = linkset->pvts[chanpos];
               sig_ss7_lock_private(p);
               callid = func_ss7_linkset_callid(linkset, chanpos);
               if (p->alreadyhungup) {
                  if (!p->owner) {
                     p->call_level = SIG_SS7_CALL_LEVEL_IDLE;
                  }
                  p->ss7call = NULL;
               }
               sig_ss7_unlock_private(p);
            }
            break;
         case ISUP_EVENT_FAA:
            /*!
             * \todo The handling of the SS7 FAA message is not good and I
             * don't know enough to handle it correctly.
             */
            chanpos = ss7_find_cic_gripe(linkset, e->faa.cic, e->faa.opc, "FAA");
            if (chanpos < 0) {
               isup_rel(linkset->ss7, e->faa.call, -1);
               break;
            }
            {
               /* XXX FAR and FAA used for something dealing with transfers? */
               p = linkset->pvts[chanpos];
               ast_debug(1, "FAA received on CIC %d\n", e->faa.cic);
               sig_ss7_lock_private(p);
               callid = func_ss7_linkset_callid(linkset, chanpos);
               if (p->alreadyhungup){
                  if (!p->owner) {
                     p->call_level = SIG_SS7_CALL_LEVEL_IDLE;
                  }
                  /* XXX We seem to be leaking the isup call structure here. */
                  p->ss7call = NULL;
                  ast_log(LOG_NOTICE, "Received FAA and we haven't sent FAR.  Ignoring.\n");
               }
               sig_ss7_unlock_private(p);
            }
            break;
         default:
            ast_debug(1, "Unknown event %s\n", ss7_event2str(e->e));
            break;
         }

         /* Call ID stuff needs to be cleaned up here */
         if (callid) {
            callid = ast_callid_unref(callid);
            ast_callid_threadassoc_remove();
         }
      }
      ast_mutex_unlock(&linkset->lock);
   }

   return 0;
}

static int ss7_pres_scr2cid_pres	(	char	presentation_ind,
		char	screening_ind
	)		[static]

Definition at line 746 of file sig_ss7.c.

Referenced by ss7_linkset().

{
   return ((presentation_ind & 0x3) << 5) | (screening_ind & 0x3);
}

static void ss7_queue_pvt_cause_data	(	struct ast_channel *	owner,
		const char *	cause,
		int	ast_cause
	)		[static]

Definition at line 408 of file sig_ss7.c.

References ast_alloca, ast_control_pvt_cause_code::ast_cause, ast_channel_hangupcause_hash_set(), AST_CHANNEL_NAME, ast_channel_name(), AST_CONTROL_PVT_CAUSE_CODE, ast_copy_string(), ast_queue_control_data(), ast_control_pvt_cause_code::chan_name, and ast_control_pvt_cause_code::code.

Referenced by ss7_linkset().

{
   struct ast_control_pvt_cause_code *cause_code;
   int datalen = sizeof(*cause_code) + strlen(cause);

   cause_code = ast_alloca(datalen);
   memset(cause_code, 0, datalen);
   cause_code->ast_cause = ast_cause;
   ast_copy_string(cause_code->chan_name, ast_channel_name(owner), AST_CHANNEL_NAME);
   ast_copy_string(cause_code->code, cause, datalen + 1 - sizeof(*cause_code));
   ast_queue_control_data(owner, AST_CONTROL_PVT_CAUSE_CODE, cause_code, datalen);
   ast_channel_hangupcause_hash_set(owner, cause_code, datalen);
}

static void ss7_rel

(

struct sig_ss7_linkset *

ss7

)

[inline, static]

Definition at line 1382 of file sig_ss7.c.

References ast_mutex_unlock, and sig_ss7_linkset::lock.

Referenced by sig_ss7_answer(), sig_ss7_call(), sig_ss7_hangup(), and sig_ss7_indicate().

{
   ast_mutex_unlock(&ss7->lock);
}

static void ss7_reset_linkset

(

struct sig_ss7_linkset *

linkset

)

[static]

Definition at line 547 of file sig_ss7.c.

References ast_verbose(), sig_ss7_chan::cic, sig_ss7_chan::dpc, sig_ss7_linkset::numchans, sig_ss7_linkset::pvts, and sig_ss7_linkset::ss7.

Referenced by ss7_linkset().

{
   int i, startcic = -1, endcic, dpc;

   if (linkset->numchans <= 0)
      return;

   startcic = linkset->pvts[0]->cic;
   /* DB: CIC's DPC fix */
   dpc = linkset->pvts[0]->dpc;

   for (i = 0; i < linkset->numchans; i++) {
      if (linkset->pvts[i+1] && linkset->pvts[i+1]->dpc == dpc && ((linkset->pvts[i+1]->cic - linkset->pvts[i]->cic) == 1) && (linkset->pvts[i]->cic - startcic < 31)) {
         continue;
      } else {
         endcic = linkset->pvts[i]->cic;
         ast_verbose("Resetting CICs %d to %d\n", startcic, endcic);
         isup_grs(linkset->ss7, startcic, endcic, dpc);

         /* DB: CIC's DPC fix */
         if (linkset->pvts[i+1]) {
            startcic = linkset->pvts[i+1]->cic;
            dpc = linkset->pvts[i+1]->dpc;
         }
      }
   }
}

static void ss7_start_call	(	struct sig_ss7_chan *	p,
		struct sig_ss7_linkset *	linkset
	)		[static]

Definition at line 576 of file sig_ss7.c.

References sig_ss7_chan::alreadyhungup, ast_callid_threadstorage_auto(), ast_callid_threadstorage_auto_clean(), AST_CAUSE_SWITCH_CONGESTION, ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_hangup(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_pbx_start(), AST_STATE_RING, ast_strlen_zero(), ast_verb, sig_ss7_chan::call_level, sig_ss7_chan::call_ref_ident, sig_ss7_chan::call_ref_pc, sig_ss7_chan::calling_party_cat, sig_ss7_chan::charge_number, sig_ss7_chan::cic, sig_ss7_chan::exten, sig_ss7_linkset::flags, sig_ss7_chan::gen_add_number, sig_ss7_chan::gen_dig_number, sig_ss7_chan::gen_dig_scheme, sig_ss7_chan::gen_dig_type, sig_ss7_chan::generic_name, sig_ss7_chan::jip_number, LINKSET_FLAG_EXPLICITACM, sig_ss7_linkset::lock, LOG_WARNING, sig_ss7_chan::lspi_ident, sig_ss7_chan::orig_called_num, pbx_builtin_setvar_helper(), sig_ss7_chan::redirecting_num, SIG_SS7_ALAW, SIG_SS7_CALL_LEVEL_IDLE, SIG_SS7_CALL_LEVEL_PROCEEDING, SIG_SS7_CALL_LEVEL_SETUP, sig_ss7_lock_private(), sig_ss7_new_ast_channel(), sig_ss7_set_echocanceller(), SIG_SS7_ULAW, sig_ss7_unlock_private(), sig_ss7_linkset::ss7, sig_ss7_chan::ss7call, and sig_ss7_linkset::type.

Referenced by ss7_linkset().

{
   struct ss7 *ss7 = linkset->ss7;
   int law;
   struct ast_channel *c;
   char tmp[256];
   struct ast_callid *callid = NULL;
   int callid_created = ast_callid_threadstorage_auto(&callid);

   if (!(linkset->flags & LINKSET_FLAG_EXPLICITACM)) {
      p->call_level = SIG_SS7_CALL_LEVEL_PROCEEDING;
      isup_acm(ss7, p->ss7call);
   } else {
      p->call_level = SIG_SS7_CALL_LEVEL_SETUP;
   }

   /* Companding law is determined by SS7 signaling type. */
   if (linkset->type == SS7_ITU) {
      law = SIG_SS7_ALAW;
   } else {
      law = SIG_SS7_ULAW;
   }

   /*
    * Release the SS7 lock while we create the channel so other
    * threads can send messages.  We must also release the private
    * lock to prevent deadlock while creating the channel.
    */
   ast_mutex_unlock(&linkset->lock);
   sig_ss7_unlock_private(p);
   c = sig_ss7_new_ast_channel(p, AST_STATE_RING, law, 0, p->exten, NULL);
   if (!c) {
      ast_log(LOG_WARNING, "Unable to start PBX on CIC %d\n", p->cic);
      ast_mutex_lock(&linkset->lock);
      sig_ss7_lock_private(p);
      isup_rel(linkset->ss7, p->ss7call, AST_CAUSE_SWITCH_CONGESTION);
      p->call_level = SIG_SS7_CALL_LEVEL_IDLE;
      p->alreadyhungup = 1;
      ast_callid_threadstorage_auto_clean(callid, callid_created);
      return;
   }

   /* Hold the channel and private lock while we setup the channel. */
   ast_channel_lock(c);
   sig_ss7_lock_private(p);

   sig_ss7_set_echocanceller(p, 1);

   /*
    * It is reasonably safe to set the following
    * channel variables while the channel private
    * structure is locked.  The PBX has not been
    * started yet and it is unlikely that any other task
    * will do anything with the channel we have just
    * created.
    *
    * We only reference these variables in the context of the ss7_linkset function
    * when receiving either and IAM or a COT message.
    */
   if (!ast_strlen_zero(p->charge_number)) {
      pbx_builtin_setvar_helper(c, "SS7_CHARGE_NUMBER", p->charge_number);
      /* Clear this after we set it */
      p->charge_number[0] = 0;
   }
   if (!ast_strlen_zero(p->gen_add_number)) {
      pbx_builtin_setvar_helper(c, "SS7_GENERIC_ADDRESS", p->gen_add_number);
      /* Clear this after we set it */
      p->gen_add_number[0] = 0;
   }
   if (!ast_strlen_zero(p->jip_number)) {
      pbx_builtin_setvar_helper(c, "SS7_JIP", p->jip_number);
      /* Clear this after we set it */
      p->jip_number[0] = 0;
   }
   if (!ast_strlen_zero(p->gen_dig_number)) {
      pbx_builtin_setvar_helper(c, "SS7_GENERIC_DIGITS", p->gen_dig_number);
      /* Clear this after we set it */
      p->gen_dig_number[0] = 0;
   }
   if (!ast_strlen_zero(p->orig_called_num)) {
      pbx_builtin_setvar_helper(c, "SS7_ORIG_CALLED_NUM", p->orig_called_num);
      /* Clear this after we set it */
      p->orig_called_num[0] = 0;
   }

   snprintf(tmp, sizeof(tmp), "%d", p->gen_dig_type);
   pbx_builtin_setvar_helper(c, "SS7_GENERIC_DIGTYPE", tmp);
   /* Clear this after we set it */
   p->gen_dig_type = 0;

   snprintf(tmp, sizeof(tmp), "%d", p->gen_dig_scheme);
   pbx_builtin_setvar_helper(c, "SS7_GENERIC_DIGSCHEME", tmp);
   /* Clear this after we set it */
   p->gen_dig_scheme = 0;

   if (!ast_strlen_zero(p->lspi_ident)) {
      pbx_builtin_setvar_helper(c, "SS7_LSPI_IDENT", p->lspi_ident);
      /* Clear this after we set it */
      p->lspi_ident[0] = 0;
   }

   snprintf(tmp, sizeof(tmp), "%d", p->call_ref_ident);
   pbx_builtin_setvar_helper(c, "SS7_CALLREF_IDENT", tmp);
   /* Clear this after we set it */
   p->call_ref_ident = 0;

   snprintf(tmp, sizeof(tmp), "%d", p->call_ref_pc);
   pbx_builtin_setvar_helper(c, "SS7_CALLREF_PC", tmp);
   /* Clear this after we set it */
   p->call_ref_pc = 0;

   snprintf(tmp, sizeof(tmp), "%d", p->calling_party_cat);
   pbx_builtin_setvar_helper(c, "SS7_CALLING_PARTY_CATEGORY", tmp);
   /* Clear this after we set it */
   p->calling_party_cat = 0;

   if (!ast_strlen_zero(p->redirecting_num)) {
      pbx_builtin_setvar_helper(c, "SS7_REDIRECTING_NUMBER", p->redirecting_num);
      /* Clear this after we set it */
      p->redirecting_num[0] = 0;
   }
   if (!ast_strlen_zero(p->generic_name)) {
      pbx_builtin_setvar_helper(c, "SS7_GENERIC_NAME", p->generic_name);
      /* Clear this after we set it */
      p->generic_name[0] = 0;
   }

   sig_ss7_unlock_private(p);
   ast_channel_unlock(c);

   if (ast_pbx_start(c)) {
      ast_log(LOG_WARNING, "Unable to start PBX on %s (CIC %d)\n", ast_channel_name(c), p->cic);
      ast_hangup(c);
   } else {
      ast_verb(3, "Accepting call to '%s' on CIC %d\n", p->exten, p->cic);
   }

   /* Must return with linkset and private lock. */
   ast_mutex_lock(&linkset->lock);
   sig_ss7_lock_private(p);
   ast_callid_threadstorage_auto_clean(callid, callid_created);
}