diff options
Diffstat (limited to 'channels/sig_pri.c')
-rw-r--r-- | channels/sig_pri.c | 2455 |
1 files changed, 2455 insertions, 0 deletions
diff --git a/channels/sig_pri.c b/channels/sig_pri.c new file mode 100644 index 000000000..1a648a124 --- /dev/null +++ b/channels/sig_pri.c @@ -0,0 +1,2455 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 1999 - 2009, Digium, Inc. + * + * Mark Spencer <markster@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \brief PRI signaling module + * + * \author Matthew Fredrickson <creslin@digium.com> + */ + + +#include "asterisk.h" + +#ifdef HAVE_PRI + +#include <errno.h> +#include <ctype.h> +#include <signal.h> + +#include "asterisk/utils.h" +#include "asterisk/options.h" +#include "asterisk/pbx.h" +#include "asterisk/file.h" +#include "asterisk/callerid.h" +#include "asterisk/say.h" +#include "asterisk/manager.h" +#include "asterisk/astdb.h" +#include "asterisk/causes.h" +#include "asterisk/musiconhold.h" +#include "asterisk/cli.h" +#include "asterisk/transcap.h" +#include "asterisk/features.h" + +#include "sig_pri.h" + +static int pri_matchdigittimeout = 3000; + +static int pri_gendigittimeout = 8000; + +#define DCHAN_NOTINALARM (1 << 0) +#define DCHAN_UP (1 << 1) + +#define PRI_CHANNEL(p) ((p) & 0xff) +#define PRI_SPAN(p) (((p) >> 8) & 0xff) +#define PRI_EXPLICIT(p) (((p) >> 16) & 0x01) + + +#define DCHAN_AVAILABLE (DCHAN_NOTINALARM | DCHAN_UP) + +#define PRI_DEADLOCK_AVOIDANCE(lock) \ + do { \ + sig_pri_unlock_private(p); \ + usleep(1); \ + sig_pri_lock_private(p); \ + } while (0) + +static int pri_active_dchan_index(struct sig_pri_pri *pri); + +static inline void pri_rel(struct sig_pri_pri *pri) +{ + ast_mutex_unlock(&pri->lock); +} + +static unsigned int PVT_TO_CHANNEL(struct sig_pri_chan *p) +{ + int explicit; + + if (p->pri->dchan_logical_span[pri_active_dchan_index(p->pri)] == p->logicalspan) + explicit = 1; + else + explicit = 0; + + return (((p)->prioffset) | ((p)->logicalspan << 8) | (explicit ? 0x10000 : 0)); +} + +static void sig_pri_handle_dchan_exception(struct sig_pri_pri *pri, int index) +{ + if (pri->calls->handle_dchan_exception) + pri->calls->handle_dchan_exception(pri, index); +} + +static void sig_pri_unlock_private(struct sig_pri_chan *p) +{ + if (p->calls->unlock_private) + p->calls->unlock_private(p->chan_pvt); +} + +static void sig_pri_lock_private(struct sig_pri_chan *p) +{ + if (p->calls->lock_private) + p->calls->lock_private(p->chan_pvt); +} + +static inline int pri_grab(struct sig_pri_chan *p, struct sig_pri_pri *pri) +{ + int res; + /* Grab the lock first */ + do { + res = ast_mutex_trylock(&pri->lock); + if (res) { + PRI_DEADLOCK_AVOIDANCE(p); + } + } while (res); + /* Then break the poll */ + pthread_kill(pri->master, SIGURG); + return 0; +} + +static int sig_pri_set_echocanceller(struct sig_pri_chan *p, int enable) +{ + if (p->calls->set_echocanceller) + return p->calls->set_echocanceller(p->chan_pvt, enable); + else + return -1; +} + +static void sig_pri_fixup_chans(struct sig_pri_chan *old, struct sig_pri_chan *new) +{ + if (old->calls->fixup_chans) + old->calls->fixup_chans(old->chan_pvt, new->chan_pvt); +} + +static int sig_pri_play_tone(struct sig_pri_chan *p, enum sig_pri_tone tone) +{ + if (p->calls->play_tone) + return p->calls->play_tone(p->chan_pvt, tone); + else + return -1; +} + +static struct ast_channel *sig_pri_new_ast_channel(struct sig_pri_chan *p, int state, int startpbx, int ulaw, int transfercapability, char *exten) +{ + struct ast_channel *c; + + if (p->calls->new_ast_channel) + c = p->calls->new_ast_channel(p->chan_pvt, state, startpbx, ulaw, transfercapability, exten); + else + return NULL; + + if (!p->owner) + p->owner = c; + p->isidlecall = 0; + p->alreadyhungup = 0; + + return c; +} + +struct ast_channel *sig_pri_request(struct sig_pri_chan *p, enum sig_pri_law law) +{ + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + + return sig_pri_new_ast_channel(p, AST_STATE_RESERVED, 0, law, 0, p->exten); +} + +int pri_is_up(struct sig_pri_pri *pri) +{ + int x; + for (x = 0; x < NUM_DCHANS; x++) { + if (pri->dchanavail[x] == DCHAN_AVAILABLE) + return 1; + } + return 0; +} + +static char *pri_order(int level) +{ + switch (level) { + case 0: + return "Primary"; + case 1: + return "Secondary"; + case 2: + return "Tertiary"; + case 3: + return "Quaternary"; + default: + return "<Unknown>"; + } +} + +/* Returns index of the active dchan */ +static int pri_active_dchan_index(struct sig_pri_pri *pri) +{ + int x = -1; + + for (x = 0; x < NUM_DCHANS; x++) { + if ((pri->dchans[x] == pri->pri)) + break; + } + + return x; +} + +static int pri_find_dchan(struct sig_pri_pri *pri) +{ + int oldslot = -1; + struct pri *old; + int newslot = -1; + int x; + old = pri->pri; + for (x = 0; x < NUM_DCHANS; x++) { + if ((pri->dchanavail[x] == DCHAN_AVAILABLE) && (newslot < 0)) + newslot = x; + if (pri->dchans[x] == old) { + oldslot = x; + } + } + if (newslot < 0) { + newslot = 0; + /* This is annoying to see on non persistent layer 2 connections. Let's not complain in that case */ + if (pri->sig != SIG_BRI_PTMP) { + ast_log(LOG_WARNING, "No D-channels available! Using Primary channel as D-channel anyway!\n"); + } + } + if (old && (oldslot != newslot)) + ast_log(LOG_NOTICE, "Switching from d-channel fd %d to fd %d!\n", + pri->fds[oldslot], pri->fds[newslot]); + pri->pri = pri->dchans[newslot]; + return 0; +} +static void pri_update_cid(struct sig_pri_chan *p, struct sig_pri_pri *pri) +{ + /* We must unlock the PRI to avoid the possibility of a deadlock */ + if (pri) + ast_mutex_unlock(&pri->lock); + for (;;) { + if (p->owner) { + if (ast_channel_trylock(p->owner)) { + PRI_DEADLOCK_AVOIDANCE(p); + } else { + ast_set_callerid(p->owner, S_OR(p->lastcid_num, NULL), + S_OR(p->lastcid_name, NULL), + S_OR(p->lastcid_num, NULL) + ); + ast_channel_unlock(p->owner); + break; + } + } else + break; + } + if (pri) + ast_mutex_lock(&pri->lock); +} + +static void pri_queue_frame(struct sig_pri_chan *p, struct ast_frame *f, struct sig_pri_pri *pri) +{ + /* We must unlock the PRI to avoid the possibility of a deadlock */ + if (pri) + ast_mutex_unlock(&pri->lock); + for (;;) { + if (p->owner) { + if (ast_channel_trylock(p->owner)) { + PRI_DEADLOCK_AVOIDANCE(p); + } else { + ast_queue_frame(p->owner, f); + ast_channel_unlock(p->owner); + break; + } + } else + break; + } + if (pri) + ast_mutex_lock(&pri->lock); +} + +static void pri_queue_control(struct sig_pri_chan *p, int subclass, struct sig_pri_pri *pri) +{ + struct ast_frame f = {AST_FRAME_CONTROL, }; + + f.subclass = subclass; + pri_queue_frame(p, &f, pri); +} + +static int pri_find_principle(struct sig_pri_pri *pri, int channel) +{ + int x; + int span = PRI_SPAN(channel); + int principle = -1; + int explicit = PRI_EXPLICIT(channel); + channel = PRI_CHANNEL(channel); + + if (!explicit) { + int index = pri_active_dchan_index(pri); + if (index == -1) + return -1; + span = pri->dchan_logical_span[index]; + } + + for (x = 0; x < pri->numchans; x++) { + if (pri->pvts[x] && (pri->pvts[x]->prioffset == channel) && (pri->pvts[x]->logicalspan == span)) { + principle = x; + break; + } + } + + return principle; +} + +static int pri_fixup_principle(struct sig_pri_pri *pri, int principle, q931_call *c) +{ + int x; + if (!c) { + if (principle < 0) + return -1; + return principle; + } + if ((principle > -1) && + (principle < pri->numchans) && + (pri->pvts[principle]) && + (pri->pvts[principle]->call == c)) + return principle; + /* First, check for other bearers */ + for (x = 0; x < pri->numchans; x++) { + if (!pri->pvts[x]) + continue; + if (pri->pvts[x]->call == c) { + /* Found our call */ + if (principle != x) { + struct sig_pri_chan *new = pri->pvts[principle], *old = pri->pvts[x]; + + ast_verb(3, "Moving call from channel %d to channel %d\n", + old->channel, new->channel); + if (new->owner) { + ast_log(LOG_WARNING, "Can't fix up channel from %d to %d because %d is already in use\n", + old->channel, new->channel, new->channel); + return -1; + } + + sig_pri_fixup_chans(old, new); + /* Fix it all up now */ + new->owner = old->owner; + old->owner = NULL; + + new->call = old->call; + old->call = NULL; + + } + return principle; + } + } + ast_log(LOG_WARNING, "Call specified, but not found?\n"); + return -1; +} + +static char * redirectingreason2str(int redirectingreason) +{ + switch (redirectingreason) { + case 0: + return "UNKNOWN"; + case 1: + return "BUSY"; + case 2: + return "NO_REPLY"; + case 0xF: + return "UNCONDITIONAL"; + default: + return "NOREDIRECT"; + } +} + +static char *dialplan2str(int dialplan) +{ + if (dialplan == -1) { + return("Dynamically set dialplan in ISDN"); + } + return (pri_plan2str(dialplan)); +} + +static void apply_plan_to_number(char *buf, size_t size, const struct sig_pri_pri *pri, const char *number, const int plan) +{ + switch (plan) { + case PRI_INTERNATIONAL_ISDN: /* Q.931 dialplan == 0x11 international dialplan => prepend international prefix digits */ + snprintf(buf, size, "%s%s", pri->internationalprefix, number); + break; + case PRI_NATIONAL_ISDN: /* Q.931 dialplan == 0x21 national dialplan => prepend national prefix digits */ + snprintf(buf, size, "%s%s", pri->nationalprefix, number); + break; + case PRI_LOCAL_ISDN: /* Q.931 dialplan == 0x41 local dialplan => prepend local prefix digits */ + snprintf(buf, size, "%s%s", pri->localprefix, number); + break; + case PRI_PRIVATE: /* Q.931 dialplan == 0x49 private dialplan => prepend private prefix digits */ + snprintf(buf, size, "%s%s", pri->privateprefix, number); + break; + case PRI_UNKNOWN: /* Q.931 dialplan == 0x00 unknown dialplan => prepend unknown prefix digits */ + snprintf(buf, size, "%s%s", pri->unknownprefix, number); + break; + default: /* other Q.931 dialplan => don't twiddle with callingnum */ + snprintf(buf, size, "%s", number); + break; + } +} + +static int pri_check_restart(struct sig_pri_pri *pri) +{ +#ifdef HAVE_PRI_SERVICE_MESSAGES +tryanotherpos: +#endif + do { + pri->resetpos++; + } while ((pri->resetpos < pri->numchans) && + (!pri->pvts[pri->resetpos] || + pri->pvts[pri->resetpos]->call || + pri->pvts[pri->resetpos]->resetting)); + if (pri->resetpos < pri->numchans) { +#ifdef HAVE_PRI_SERVICE_MESSAGES + char db_chan_name[20], db_answer[5], state; + int why; + + /* check if the channel is out of service */ + ast_mutex_lock(&pri->pvts[pri->resetpos]->service_lock); + snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->pvts[pri->resetpos]->pri->span, pri->pvts[pri->resetpos]->channel); + ast_mutex_unlock(&pri->pvts[pri->resetpos]->service_lock); + + /* if so, try next channel */ + if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) { + sscanf(db_answer, "%c:%d", &state, &why); + if (why) { + ast_log(LOG_NOTICE, "span '%d' channel '%d' out-of-service (reason: %s), not sending RESTART\n", pri->span, + pri->pvts[pri->resetpos]->channel, (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end"); + goto tryanotherpos; + } + } +#endif + + /* Mark the channel as resetting and restart it */ + pri->pvts[pri->resetpos]->resetting = 1; + pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[pri->resetpos])); + } else { + pri->resetting = 0; + time(&pri->lastreset); + } + return 0; +} + +static int pri_find_empty_chan(struct sig_pri_pri *pri, int backwards) +{ + int x; + if (backwards) + x = pri->numchans; + else + x = 0; + for (;;) { + if (backwards && (x < 0)) + break; + if (!backwards && (x >= pri->numchans)) + break; + if (pri->pvts[x] && !pri->pvts[x]->inalarm && !pri->pvts[x]->owner) { + ast_debug(1, "Found empty available channel %d/%d\n", + pri->pvts[x]->logicalspan, pri->pvts[x]->prioffset); + return x; + } + if (backwards) + x--; + else + x++; + } + return -1; +} + +static void *do_idle_thread(void *vchan) +{ + struct ast_channel *chan = vchan; + struct sig_pri_chan *pvt = chan->tech_pvt; + struct ast_frame *f; + char ex[80]; + /* Wait up to 30 seconds for an answer */ + int newms, ms = 30000; + ast_verb(3, "Initiating idle call on channel %s\n", chan->name); + snprintf(ex, sizeof(ex), "%d/%s", pvt->channel, pvt->pri->idledial); + if (ast_call(chan, ex, 0)) { + ast_log(LOG_WARNING, "Idle dial failed on '%s' to '%s'\n", chan->name, ex); + ast_hangup(chan); + return NULL; + } + while ((newms = ast_waitfor(chan, ms)) > 0) { + f = ast_read(chan); + if (!f) { + /* Got hangup */ + break; + } + if (f->frametype == AST_FRAME_CONTROL) { + switch (f->subclass) { + case AST_CONTROL_ANSWER: + /* Launch the PBX */ + ast_copy_string(chan->exten, pvt->pri->idleext, sizeof(chan->exten)); + ast_copy_string(chan->context, pvt->pri->idlecontext, sizeof(chan->context)); + chan->priority = 1; + ast_verb(4, "Idle channel '%s' answered, sending to %s@%s\n", chan->name, chan->exten, chan->context); + ast_pbx_run(chan); + /* It's already hungup, return immediately */ + return NULL; + case AST_CONTROL_BUSY: + ast_verb(4, "Idle channel '%s' busy, waiting...\n", chan->name); + break; + case AST_CONTROL_CONGESTION: + ast_verb(4, "Idle channel '%s' congested, waiting...\n", chan->name); + break; + }; + } + ast_frfree(f); + ms = newms; + } + /* Hangup the channel since nothing happend */ + ast_hangup(chan); + return NULL; +} + +static void *pri_ss_thread(void *data) +{ + struct sig_pri_chan *p = data; + struct ast_channel *chan = p->owner; + char exten[AST_MAX_EXTENSION]; + int res; + int len; + int timeout; + + /* in the bizarre case where the channel has become a zombie before we + even get started here, abort safely + */ + if (!p) { + ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", chan->name); + ast_hangup(chan); + return NULL; + } + + ast_verb(3, "Starting simple switch on '%s'\n", chan->name); + + /* Now loop looking for an extension */ + ast_copy_string(exten, p->exten, sizeof(exten)); + len = strlen(exten); + res = 0; + while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) { + if (len && !ast_ignore_pattern(chan->context, exten)) + sig_pri_play_tone(p, -1); + else + sig_pri_play_tone(p, SIG_PRI_TONE_DIALTONE); + if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) + timeout = pri_matchdigittimeout; + else + timeout = pri_gendigittimeout; + res = ast_waitfordigit(chan, timeout); + if (res < 0) { + ast_log(LOG_DEBUG, "waitfordigit returned < 0...\n"); + ast_hangup(chan); + return NULL; + } else if (res) { + exten[len++] = res; + exten[len] = '\0'; + } else + goto exit; + } + /* if no extension was received ('unspecified') on overlap call, use the 's' extension */ + if (ast_strlen_zero(exten)) { + ast_verb(3, "Going to extension s|1 because of empty extension received on overlap call\n"); + exten[0] = 's'; + exten[1] = '\0'; + } + sig_pri_play_tone(p, -1); + if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) { + /* Start the real PBX */ + ast_copy_string(chan->exten, exten, sizeof(chan->exten)); + sig_pri_set_echocanceller(p, 1); + ast_setstate(chan, AST_STATE_RING); + res = ast_pbx_run(chan); + if (res) { + ast_log(LOG_WARNING, "PBX exited non-zero!\n"); + } + } else { + ast_log(LOG_DEBUG, "No such possible extension '%s' in context '%s'\n", exten, chan->context); + chan->hangupcause = AST_CAUSE_UNALLOCATED; + ast_hangup(chan); + p->exten[0] = '\0'; + /* Since we send release complete here, we won't get one */ + p->call = NULL; + } + return NULL; + +exit: + res = sig_pri_play_tone(p, SIG_PRI_TONE_CONGESTION); + if (res < 0) + ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel); + ast_hangup(chan); + return NULL; +} + +void pri_event_alarm(struct sig_pri_pri *pri, int index, int before_start_pri) +{ + pri->dchanavail[index] &= ~(DCHAN_NOTINALARM | DCHAN_UP); + if (!before_start_pri) + pri_find_dchan(pri); +} + +void pri_event_noalarm(struct sig_pri_pri *pri, int index, int before_start_pri) +{ + pri->dchanavail[index] |= DCHAN_NOTINALARM; + if (!before_start_pri) + pri_restart(pri->dchans[index]); +} + +static void *pri_dchannel(void *vpri) +{ + struct sig_pri_pri *pri = vpri; + pri_event *e; + struct pollfd fds[NUM_DCHANS]; + int res; + int chanpos = 0; + int x; + struct ast_channel *c; + struct timeval tv, lowest, *next; + int doidling=0; + char *cc; + time_t t; + int i, which=-1; + int numdchans; + pthread_t threadid; + pthread_attr_t attr; + char ani2str[6]; + char plancallingnum[256]; + char plancallingani[256]; + char calledtonstr[10]; + struct timeval lastidle = { 0, 0 }; + pthread_t p; + struct ast_channel *idle; + char idlen[80]; + int nextidle = -1; + int haveidles; + int activeidles; + + gettimeofday(&lastidle, NULL); + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); + + if (!ast_strlen_zero(pri->idledial) && !ast_strlen_zero(pri->idleext)) { + /* Need to do idle dialing, check to be sure though */ + cc = strchr(pri->idleext, '@'); + if (cc) { + *cc = '\0'; + cc++; + ast_copy_string(pri->idlecontext, cc, sizeof(pri->idlecontext)); +#if 0 + /* Extensions may not be loaded yet */ + if (!ast_exists_extension(NULL, pri->idlecontext, pri->idleext, 1, NULL)) + ast_log(LOG_WARNING, "Extension '%s @ %s' does not exist\n", pri->idleext, pri->idlecontext); + else +#endif + doidling = 1; + } else + ast_log(LOG_WARNING, "Idle dial string '%s' lacks '@context'\n", pri->idleext); + } + for (;;) { + for (i = 0; i < NUM_DCHANS; i++) { + if (!pri->dchans[i]) + break; + fds[i].fd = pri->fds[i]; + fds[i].events = POLLIN | POLLPRI; + fds[i].revents = 0; + } + numdchans = i; + time(&t); + ast_mutex_lock(&pri->lock); + if (pri->switchtype != PRI_SWITCH_GR303_TMC && (pri->sig != SIG_BRI_PTMP) && (pri->resetinterval > 0)) { + if (pri->resetting && pri_is_up(pri)) { + if (pri->resetpos < 0) + pri_check_restart(pri); + } else { + if (!pri->resetting && (t - pri->lastreset) >= pri->resetinterval) { + pri->resetting = 1; + pri->resetpos = -1; + } + } + } + /* Look for any idle channels if appropriate */ + if (doidling && pri_is_up(pri)) { + nextidle = -1; + haveidles = 0; + activeidles = 0; + for (x = pri->numchans; x >= 0; x--) { + if (pri->pvts[x] && !pri->pvts[x]->owner && + !pri->pvts[x]->call) { + if (haveidles < pri->minunused) { + haveidles++; + } else if (!pri->pvts[x]->resetting) { + nextidle = x; + break; + } + } else if (pri->pvts[x] && pri->pvts[x]->owner && pri->pvts[x]->isidlecall) + activeidles++; + } + if (nextidle > -1) { + if (ast_tvdiff_ms(ast_tvnow(), lastidle) > 1000) { + /* Don't create a new idle call more than once per second */ + snprintf(idlen, sizeof(idlen), "%d/%s", pri->pvts[nextidle]->channel, pri->idledial); + idle = sig_pri_request(pri->pvts[nextidle], AST_FORMAT_ULAW); + if (idle) { + pri->pvts[nextidle]->isidlecall = 1; + if (ast_pthread_create_background(&p, NULL, do_idle_thread, idle)) { + ast_log(LOG_WARNING, "Unable to start new thread for idle channel '%s'\n", idle->name); + ast_hangup(idle); + } + } else + ast_log(LOG_WARNING, "Unable to request channel 'DAHDI/%s' for idle call\n", idlen); + gettimeofday(&lastidle, NULL); + } + } else if ((haveidles < pri->minunused) && + (activeidles > pri->minidle)) { + /* Mark something for hangup if there is something + that can be hungup */ + for (x = pri->numchans; x >= 0; x--) { + /* find a candidate channel */ + if (pri->pvts[x] && pri->pvts[x]->owner && pri->pvts[x]->isidlecall) { + pri->pvts[x]->owner->_softhangup |= AST_SOFTHANGUP_DEV; + haveidles++; + /* Stop if we have enough idle channels or + can't spare any more active idle ones */ + if ((haveidles >= pri->minunused) || + (activeidles <= pri->minidle)) + break; + } + } + } + } + /* Start with reasonable max */ + lowest = ast_tv(60, 0); + for (i = 0; i < NUM_DCHANS; i++) { + /* Find lowest available d-channel */ + if (!pri->dchans[i]) + break; + if ((next = pri_schedule_next(pri->dchans[i]))) { + /* We need relative time here */ + tv = ast_tvsub(*next, ast_tvnow()); + if (tv.tv_sec < 0) { + tv = ast_tv(0,0); + } + if (doidling || pri->resetting) { + if (tv.tv_sec > 1) { + tv = ast_tv(1, 0); + } + } else { + if (tv.tv_sec > 60) { + tv = ast_tv(60, 0); + } + } + } else if (doidling || pri->resetting) { + /* Make sure we stop at least once per second if we're + monitoring idle channels */ + tv = ast_tv(1,0); + } else { + /* Don't poll for more than 60 seconds */ + tv = ast_tv(60, 0); + } + if (!i || ast_tvcmp(tv, lowest) < 0) { + lowest = tv; + } + } + ast_mutex_unlock(&pri->lock); + + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); + pthread_testcancel(); + e = NULL; + res = poll(fds, numdchans, lowest.tv_sec * 1000 + lowest.tv_usec / 1000); + pthread_testcancel(); + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); + + ast_mutex_lock(&pri->lock); + if (!res) { + for (which = 0; which < NUM_DCHANS; which++) { + if (!pri->dchans[which]) + break; + /* Just a timeout, run the scheduler */ + e = pri_schedule_run(pri->dchans[which]); + if (e) + break; + } + } else if (res > -1) { + for (which = 0; which < NUM_DCHANS; which++) { + if (!pri->dchans[which]) + break; + if (fds[which].revents & POLLPRI) { + sig_pri_handle_dchan_exception(pri, which); + } else if (fds[which].revents & POLLIN) { + e = pri_check_event(pri->dchans[which]); + } + if (e) + break; + } + } else if (errno != EINTR) + ast_log(LOG_WARNING, "pri_event returned error %d (%s)\n", errno, strerror(errno)); + + if (e) { + if (pri->debug) + pri_dump_event(pri->dchans[which], e); + + if (e->e != PRI_EVENT_DCHAN_DOWN) { + if (!(pri->dchanavail[which] & DCHAN_UP)) { + ast_verb(2, "%s D-Channel on span %d up\n", pri_order(which), pri->span); + } + pri->dchanavail[which] |= DCHAN_UP; + } else { + if (pri->dchanavail[which] & DCHAN_UP) { + ast_verb(2, "%s D-Channel on span %d down\n", pri_order(which), pri->span); + } + pri->dchanavail[which] &= ~DCHAN_UP; + } + + if ((e->e != PRI_EVENT_DCHAN_UP) && (e->e != PRI_EVENT_DCHAN_DOWN) && (pri->pri != pri->dchans[which])) + /* Must be an NFAS group that has the secondary dchan active */ + pri->pri = pri->dchans[which]; + + switch (e->e) { + case PRI_EVENT_DCHAN_UP: + if (!pri->pri) pri_find_dchan(pri); + + /* Note presense of D-channel */ + time(&pri->lastreset); + + /* Restart in 5 seconds */ + if (pri->resetinterval > -1) { + pri->lastreset -= pri->resetinterval; + pri->lastreset += 5; + } + pri->resetting = 0; + /* Take the channels from inalarm condition */ + for (i = 0; i < pri->numchans; i++) + if (pri->pvts[i]) { + pri->pvts[i]->inalarm = 0; + } + break; + case PRI_EVENT_DCHAN_DOWN: + pri_find_dchan(pri); + if (!pri_is_up(pri)) { + pri->resetting = 0; + /* Hangup active channels and put them in alarm mode */ + for (i = 0; i < pri->numchans; i++) { + struct sig_pri_chan *p = pri->pvts[i]; + if (p) { + if (!p->pri || !p->pri->pri || pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0) { + /* T309 is not enabled : hangup calls when alarm occurs */ + if (p->call) { + if (p->pri && p->pri->pri) { + pri_hangup(p->pri->pri, p->call, -1); + pri_destroycall(p->pri->pri, p->call); + p->call = NULL; + } else + ast_log(LOG_WARNING, "The PRI Call have not been destroyed\n"); + } + if (p->owner) + ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV); + } + /* For PTMP connections with non persistent layer 2 we want + * to *not* declare inalarm unless there actually is an alarm */ + if (p->pri->sig != SIG_BRI_PTMP) { + p->inalarm = 1; + } + } + } + } + break; + case PRI_EVENT_RESTART: + if (e->restart.channel > -1) { + chanpos = pri_find_principle(pri, e->restart.channel); + if (chanpos < 0) + ast_log(LOG_WARNING, "Restart requested on odd/unavailable channel number %d/%d on span %d\n", + PRI_SPAN(e->restart.channel), PRI_CHANNEL(e->restart.channel), pri->span); + else { +#ifdef HAVE_PRI_SERVICE_MESSAGES + char db_chan_name[20], db_answer[5], state; + int why, skipit = 0; + + ast_mutex_lock(&pri->pvts[chanpos]->service_lock); + snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->pvts[chanpos]->pri->span, pri->pvts[chanpos]->channel); + ast_mutex_unlock(&pri->pvts[chanpos]->service_lock); + + if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) { + sscanf(db_answer, "%c:%d", &state, &why); + if (why) { + ast_log(LOG_NOTICE, "span '%d' channel '%d' out-of-service (reason: %s), ignoring RESTART\n", pri->span, + e->restart.channel, (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end"); + skipit = 1; + } else { + ast_db_del(db_chan_name, SRVST_DBKEY); + } + } + if (!skipit) { +#endif + ast_verb(3, "B-channel %d/%d restarted on span %d\n", + PRI_SPAN(e->restart.channel), PRI_CHANNEL(e->restart.channel), pri->span); + sig_pri_lock_private(pri->pvts[chanpos]); + if (pri->pvts[chanpos]->call) { + pri_destroycall(pri->pri, pri->pvts[chanpos]->call); + pri->pvts[chanpos]->call = NULL; + } +#ifdef HAVE_PRI_SERVICE_MESSAGES + } +#endif + /* Force soft hangup if appropriate */ + if (pri->pvts[chanpos]->owner) + ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV); + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } else { + ast_verb(3, "Restart on requested on entire span %d\n", pri->span); + for (x = 0; x < pri->numchans; x++) + if (pri->pvts[x]) { + sig_pri_lock_private(pri->pvts[x]); + if (pri->pvts[x]->call) { + pri_destroycall(pri->pri, pri->pvts[x]->call); + pri->pvts[x]->call = NULL; + } + if (pri->pvts[x]->owner) + ast_softhangup_nolock(pri->pvts[x]->owner, AST_SOFTHANGUP_DEV); + sig_pri_unlock_private(pri->pvts[x]); + } + } + break; + case PRI_EVENT_KEYPAD_DIGIT: + chanpos = pri_find_principle(pri, e->digit.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "KEYPAD_DIGITs received on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->digit.channel), PRI_CHANNEL(e->digit.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->digit.call); + if (chanpos > -1) { + sig_pri_lock_private(pri->pvts[chanpos]); + /* queue DTMF frame if the PBX for this call was already started (we're forwarding KEYPAD_DIGITs further on */ + if ((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) && pri->pvts[chanpos]->call==e->digit.call && pri->pvts[chanpos]->owner) { + /* how to do that */ + int digitlen = strlen(e->digit.digits); + char digit; + int i; + for (i = 0; i < digitlen; i++) { + digit = e->digit.digits[i]; + { + struct ast_frame f = { AST_FRAME_DTMF, digit, }; + pri_queue_frame(pri->pvts[chanpos], &f, pri); + } + } + } + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } + break; + + case PRI_EVENT_INFO_RECEIVED: + chanpos = pri_find_principle(pri, e->ring.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "INFO received on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->ring.call); + if (chanpos > -1) { + sig_pri_lock_private(pri->pvts[chanpos]); + /* queue DTMF frame if the PBX for this call was already started (we're forwarding INFORMATION further on */ + if ((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) && pri->pvts[chanpos]->call==e->ring.call && pri->pvts[chanpos]->owner) { + /* how to do that */ + int digitlen = strlen(e->ring.callednum); + char digit; + int i; + for (i = 0; i < digitlen; i++) { + digit = e->ring.callednum[i]; + { + struct ast_frame f = { AST_FRAME_DTMF, digit, }; + pri_queue_frame(pri->pvts[chanpos], &f, pri); + } + } + } + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } + break; +#ifdef HAVE_PRI_SERVICE_MESSAGES + case PRI_EVENT_SERVICE: + chanpos = pri_find_principle(pri, e->service.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Received service change status %d on unconfigured channel %d/%d span %d\n", + e->service_ack.changestatus, PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span); + } else { + char db_chan_name[20], db_answer[5], state; + int ch, why = -1; + + ast_mutex_lock(&pri->pvts[chanpos]->service_lock); + ch = pri->pvts[chanpos]->channel; + ast_mutex_unlock(&pri->pvts[chanpos]->service_lock); + + snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->pvts[chanpos]->pri->span, ch); + if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) { + sscanf(db_answer, "%c:%d", &state, &why); + ast_db_del(db_chan_name, SRVST_DBKEY); + } + switch (e->service.changestatus) { + case 0: /* in-service */ + if (why > -1) { + if (why & SRVST_NEAREND) { + snprintf(db_answer, sizeof(db_answer), "%s:%d", SRVST_TYPE_OOS, SRVST_NEAREND); + ast_db_put(db_chan_name, SRVST_DBKEY, db_answer); + ast_debug(2, "channel '%d' service state { near: out-of-service, far: in-service }\n", ch); + } + } + break; + case 2: /* out-of-service */ + if (why == -1) { + why = SRVST_FAREND; + } else { + why |= SRVST_FAREND; + } + snprintf(db_answer, sizeof(db_answer), "%s:%d", SRVST_TYPE_OOS, why); + ast_db_put(db_chan_name, SRVST_DBKEY, db_answer); + break; + default: + ast_log(LOG_ERROR, "Huh? changestatus is: %d\n", e->service.changestatus); + } + ast_log(LOG_NOTICE, "Channel %d/%d span %d (logical: %d) received a change of service message, status '%d'\n", + PRI_SPAN(e->service.channel), PRI_CHANNEL(e->service.channel), pri->span, ch, e->service.changestatus); + } + break; + case PRI_EVENT_SERVICE_ACK: + chanpos = pri_find_principle(pri, e->service_ack.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Received service acknowledge change status '%d' on unconfigured channel %d/%d span %d\n", + e->service_ack.changestatus, PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span); + } else { + ast_debug(2, "Channel %d/%d span %d received a change os service acknowledgement message, status '%d'\n", + PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span, e->service_ack.changestatus); + } + break; +#endif + case PRI_EVENT_RING: + if (e->ring.channel == -1) + chanpos = pri_find_empty_chan(pri, 1); + else + chanpos = pri_find_principle(pri, e->ring.channel); + /* if no channel specified find one empty */ + if (chanpos < 0) { + ast_log(LOG_WARNING, "Ring requested on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span); + } else { + sig_pri_lock_private(pri->pvts[chanpos]); + if (pri->pvts[chanpos]->owner) { + if (pri->pvts[chanpos]->call == e->ring.call) { + ast_log(LOG_WARNING, "Duplicate setup requested on channel %d/%d already in use on span %d\n", + PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span); + break; + } else { + /* This is where we handle initial glare */ + ast_debug(1, "Ring requested on channel %d/%d already in use or previously requested on span %d. Attempting to renegotiating channel.\n", + PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span); + sig_pri_unlock_private(pri->pvts[chanpos]); + chanpos = -1; + } + } + if (chanpos > -1) + sig_pri_unlock_private(pri->pvts[chanpos]); + } + if ((chanpos < 0) && (e->ring.flexible)) + chanpos = pri_find_empty_chan(pri, 1); + if (chanpos > -1) { + sig_pri_lock_private(pri->pvts[chanpos]); + pri->pvts[chanpos]->call = e->ring.call; + apply_plan_to_number(plancallingnum, sizeof(plancallingnum), pri, e->ring.callingnum, e->ring.callingplan); + if (pri->pvts[chanpos]->use_callerid) { + ast_shrink_phone_number(plancallingnum); + ast_copy_string(pri->pvts[chanpos]->cid_num, plancallingnum, sizeof(pri->pvts[chanpos]->cid_num)); +#ifdef PRI_ANI + if (!ast_strlen_zero(e->ring.callingani)) { + apply_plan_to_number(plancallingani, sizeof(plancallingani), pri, e->ring.callingani, e->ring.callingplanani); + ast_shrink_phone_number(plancallingani); + ast_copy_string(pri->pvts[chanpos]->cid_ani, plancallingani, sizeof(pri->pvts[chanpos]->cid_ani)); + } else { + pri->pvts[chanpos]->cid_ani[0] = '\0'; + } +#endif + ast_copy_string(pri->pvts[chanpos]->cid_name, e->ring.callingname, sizeof(pri->pvts[chanpos]->cid_name)); + pri->pvts[chanpos]->cid_ton = e->ring.callingplan; /* this is the callingplan (TON/NPI), e->ring.callingplan>>4 would be the TON */ + } else { + pri->pvts[chanpos]->cid_num[0] = '\0'; + pri->pvts[chanpos]->cid_ani[0] = '\0'; + pri->pvts[chanpos]->cid_name[0] = '\0'; + pri->pvts[chanpos]->cid_ton = 0; + } + apply_plan_to_number(pri->pvts[chanpos]->rdnis, sizeof(pri->pvts[chanpos]->rdnis), pri, + e->ring.redirectingnum, e->ring.callingplanrdnis); + /* If immediate=yes go to s|1 */ + if (pri->pvts[chanpos]->immediate) { + ast_verb(3, "Going to extension s|1 because of immediate=yes\n"); + pri->pvts[chanpos]->exten[0] = 's'; + pri->pvts[chanpos]->exten[1] = '\0'; + } + /* Get called number */ + else if (!ast_strlen_zero(e->ring.callednum)) { + ast_copy_string(pri->pvts[chanpos]->exten, e->ring.callednum, sizeof(pri->pvts[chanpos]->exten)); + ast_copy_string(pri->pvts[chanpos]->dnid, e->ring.callednum, sizeof(pri->pvts[chanpos]->dnid)); + } else if (pri->overlapdial) + pri->pvts[chanpos]->exten[0] = '\0'; + else { + /* Some PRI circuits are set up to send _no_ digits. Handle them as 's'. */ + pri->pvts[chanpos]->exten[0] = 's'; + pri->pvts[chanpos]->exten[1] = '\0'; + } + /* Set DNID on all incoming calls -- even immediate */ + if (!ast_strlen_zero(e->ring.callednum)) + ast_copy_string(pri->pvts[chanpos]->dnid, e->ring.callednum, sizeof(pri->pvts[chanpos]->dnid)); + /* No number yet, but received "sending complete"? */ + if (e->ring.complete && (ast_strlen_zero(e->ring.callednum))) { + ast_verb(3, "Going to extension s|1 because of Complete received\n"); + pri->pvts[chanpos]->exten[0] = 's'; + pri->pvts[chanpos]->exten[1] = '\0'; + } + /* Make sure extension exists (or in overlap dial mode, can exist) */ + if (((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) && ast_canmatch_extension(NULL, pri->pvts[chanpos]->context, pri->pvts[chanpos]->exten, 1, pri->pvts[chanpos]->cid_num)) || + ast_exists_extension(NULL, pri->pvts[chanpos]->context, pri->pvts[chanpos]->exten, 1, pri->pvts[chanpos]->cid_num)) { + /* Setup law */ + if (e->ring.complete || !(pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)) { + /* Just announce proceeding */ + pri->pvts[chanpos]->proceeding = 1; + pri_proceeding(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 0); + } else { + if (pri->switchtype != PRI_SWITCH_GR303_TMC) + pri_need_more_info(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 1); + else + pri_answer(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 1); + } + /* Get the use_callingpres state */ + pri->pvts[chanpos]->callingpres = e->ring.callingpres; + + /* Start PBX */ + if (!e->ring.complete && (pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) && ast_matchmore_extension(NULL, pri->pvts[chanpos]->context, pri->pvts[chanpos]->exten, 1, pri->pvts[chanpos]->cid_num)) { + /* Release the PRI lock while we create the channel */ + ast_mutex_unlock(&pri->lock); + + c = sig_pri_new_ast_channel(pri->pvts[chanpos], AST_STATE_RESERVED, 0, (e->ring.layer1 = PRI_LAYER_1_ALAW) ? SIG_PRI_ALAW : SIG_PRI_ULAW, e->ring.ctype, pri->pvts[chanpos]->exten); + + sig_pri_unlock_private(pri->pvts[chanpos]); + + if (!ast_strlen_zero(e->ring.callingsubaddr)) { + pbx_builtin_setvar_helper(c, "CALLINGSUBADDR", e->ring.callingsubaddr); + } + if (e->ring.ani2 >= 0) { + snprintf(ani2str, 5, "%.2d", e->ring.ani2); + pbx_builtin_setvar_helper(c, "ANI2", ani2str); + pri->pvts[chanpos]->cid_ani2 = e->ring.ani2; + } + +#ifdef SUPPORT_USERUSER + if (!ast_strlen_zero(e->ring.useruserinfo)) { + pbx_builtin_setvar_helper(c, "USERUSERINFO", e->ring.useruserinfo); + } +#endif + + snprintf(calledtonstr, sizeof(calledtonstr)-1, "%d", e->ring.calledplan); + pbx_builtin_setvar_helper(c, "CALLEDTON", calledtonstr); + if (e->ring.redirectingreason >= 0) + pbx_builtin_setvar_helper(c, "PRIREDIRECTREASON", redirectingreason2str(e->ring.redirectingreason)); + + sig_pri_lock_private(pri->pvts[chanpos]); + ast_mutex_lock(&pri->lock); + + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + if (c && !ast_pthread_create(&threadid, &attr, pri_ss_thread, pri->pvts[chanpos])) { + ast_verb(3, "Accepting overlap call from '%s' to '%s' on channel %d/%d, span %d\n", + plancallingnum, S_OR(pri->pvts[chanpos]->exten, "<unspecified>"), + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span); + } else { + ast_log(LOG_WARNING, "Unable to start PBX on channel %d/%d, span %d\n", + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span); + if (c) + ast_hangup(c); + else { + pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_SWITCH_CONGESTION); + pri->pvts[chanpos]->call = NULL; + } + } + pthread_attr_destroy(&attr); + } else { + ast_mutex_unlock(&pri->lock); + /* Release PRI lock while we create the channel */ + c = sig_pri_new_ast_channel(pri->pvts[chanpos], AST_STATE_RING, 1, (e->ring.layer1 == PRI_LAYER_1_ALAW) ? SIG_PRI_ALAW : SIG_PRI_ULAW, e->ring.ctype, pri->pvts[chanpos]->exten); + + if (c) { + char calledtonstr[10]; + + sig_pri_unlock_private(pri->pvts[chanpos]); + + if (e->ring.ani2 >= 0) { + snprintf(ani2str, 5, "%d", e->ring.ani2); + pbx_builtin_setvar_helper(c, "ANI2", ani2str); + pri->pvts[chanpos]->cid_ani2 = e->ring.ani2; + } + +#ifdef SUPPORT_USERUSER + if (!ast_strlen_zero(e->ring.useruserinfo)) { + pbx_builtin_setvar_helper(c, "USERUSERINFO", e->ring.useruserinfo); + } +#endif + + if (e->ring.redirectingreason >= 0) + pbx_builtin_setvar_helper(c, "PRIREDIRECTREASON", redirectingreason2str(e->ring.redirectingreason)); + + snprintf(calledtonstr, sizeof(calledtonstr)-1, "%d", e->ring.calledplan); + pbx_builtin_setvar_helper(c, "CALLEDTON", calledtonstr); + + sig_pri_lock_private(pri->pvts[chanpos]); + ast_mutex_lock(&pri->lock); + + ast_verb(3, "Accepting call from '%s' to '%s' on channel %d/%d, span %d\n", + plancallingnum, pri->pvts[chanpos]->exten, + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span); + sig_pri_set_echocanceller(pri->pvts[chanpos], 1); + } else { + + ast_mutex_lock(&pri->lock); + + ast_log(LOG_WARNING, "Unable to start PBX on channel %d/%d, span %d\n", + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span); + pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_SWITCH_CONGESTION); + pri->pvts[chanpos]->call = NULL; + } + } + } else { + ast_verb(3, "Extension '%s' in context '%s' from '%s' does not exist. Rejecting call on channel %d/%d, span %d\n", + pri->pvts[chanpos]->exten, pri->pvts[chanpos]->context, pri->pvts[chanpos]->cid_num, pri->pvts[chanpos]->logicalspan, + pri->pvts[chanpos]->prioffset, pri->span); + pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_UNALLOCATED); + pri->pvts[chanpos]->call = NULL; + pri->pvts[chanpos]->exten[0] = '\0'; + } + sig_pri_unlock_private(pri->pvts[chanpos]); + } else { + if (e->ring.flexible) + pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION); + else + pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_REQUESTED_CHAN_UNAVAIL); + } + break; + case PRI_EVENT_RINGING: + chanpos = pri_find_principle(pri, e->ringing.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Ringing requested on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->ringing.channel), PRI_CHANNEL(e->ringing.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->ringing.call); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Ringing requested on channel %d/%d not in use on span %d\n", + PRI_SPAN(e->ringing.channel), PRI_CHANNEL(e->ringing.channel), pri->span); + } else { + sig_pri_lock_private(pri->pvts[chanpos]); + sig_pri_set_echocanceller(pri->pvts[chanpos], 1); + pri_queue_control(pri->pvts[chanpos], AST_CONTROL_RINGING, pri); + pri->pvts[chanpos]->alerting = 1; +#ifdef PRI_PROGRESS_MASK + if (e->ringing.progressmask & PRI_PROG_INBAND_AVAILABLE) { +#else + if (e->ringing.progress == 8) { +#endif + } + +#ifdef SUPPORT_USERUSER + if (!ast_strlen_zero(e->ringing.useruserinfo)) { + struct ast_channel *owner = pri->pvts[chanpos]->owner; + sig_pri_unlock_private(pri->pvts[chanpos]); + pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->ringing.useruserinfo); + sig_pri_lock_private(pri->pvts[chanpos]); + } +#endif + + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } + break; + case PRI_EVENT_PROGRESS: + /* Get chan value if e->e is not PRI_EVNT_RINGING */ + chanpos = pri_find_principle(pri, e->proceeding.channel); + if (chanpos > -1) { +#ifdef PRI_PROGRESS_MASK + if ((!pri->pvts[chanpos]->progress) || (e->proceeding.progressmask & PRI_PROG_INBAND_AVAILABLE)) { +#else + if ((!pri->pvts[chanpos]->progress) || (e->proceeding.progress == 8)) { +#endif + struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_PROGRESS, }; + + if (e->proceeding.cause > -1) { + ast_verb(3, "PROGRESS with cause code %d received\n", e->proceeding.cause); + + /* Work around broken, out of spec USER_BUSY cause in a progress message */ + if (e->proceeding.cause == AST_CAUSE_USER_BUSY) { + if (pri->pvts[chanpos]->owner) { + ast_verb(3, "PROGRESS with 'user busy' received, signaling AST_CONTROL_BUSY instead of AST_CONTROL_PROGRESS\n"); + + pri->pvts[chanpos]->owner->hangupcause = e->proceeding.cause; + f.subclass = AST_CONTROL_BUSY; + } + } + } + + sig_pri_lock_private(pri->pvts[chanpos]); + ast_log(LOG_DEBUG, "Queuing frame from PRI_EVENT_PROGRESS on channel %d/%d span %d\n", + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset,pri->span); + pri_queue_frame(pri->pvts[chanpos], &f, pri); +#ifdef PRI_PROGRESS_MASK + if (e->proceeding.progressmask & PRI_PROG_INBAND_AVAILABLE) { +#else + if (e->proceeding.progress == 8) { +#endif + /* Bring voice path up */ + f.subclass = AST_CONTROL_PROGRESS; + pri_queue_frame(pri->pvts[chanpos], &f, pri); + } + pri->pvts[chanpos]->progress = 1; + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } + break; + case PRI_EVENT_PROCEEDING: + chanpos = pri_find_principle(pri, e->proceeding.channel); + if (chanpos > -1) { + if (!pri->pvts[chanpos]->proceeding) { + struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_PROCEEDING, }; + + sig_pri_lock_private(pri->pvts[chanpos]); + ast_log(LOG_DEBUG, "Queuing frame from PRI_EVENT_PROCEEDING on channel %d/%d span %d\n", + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset,pri->span); + pri_queue_frame(pri->pvts[chanpos], &f, pri); +#ifdef PRI_PROGRESS_MASK + if (e->proceeding.progressmask & PRI_PROG_INBAND_AVAILABLE) { +#else + if (e->proceeding.progress == 8) { +#endif + /* Bring voice path up */ + f.subclass = AST_CONTROL_PROGRESS; + pri_queue_frame(pri->pvts[chanpos], &f, pri); + } + pri->pvts[chanpos]->proceeding = 1; + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } + break; + case PRI_EVENT_FACNAME: + chanpos = pri_find_principle(pri, e->facname.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Facility Name requested on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->facname.channel), PRI_CHANNEL(e->facname.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->facname.call); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Facility Name requested on channel %d/%d not in use on span %d\n", + PRI_SPAN(e->facname.channel), PRI_CHANNEL(e->facname.channel), pri->span); + } else { + /* Re-use *69 field for PRI */ + sig_pri_lock_private(pri->pvts[chanpos]); + ast_copy_string(pri->pvts[chanpos]->lastcid_num, e->facname.callingnum, sizeof(pri->pvts[chanpos]->lastcid_num)); + ast_copy_string(pri->pvts[chanpos]->lastcid_name, e->facname.callingname, sizeof(pri->pvts[chanpos]->lastcid_name)); + pri_update_cid(pri->pvts[chanpos], pri); + sig_pri_set_echocanceller(pri->pvts[chanpos], 1); + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } + break; + case PRI_EVENT_ANSWER: + chanpos = pri_find_principle(pri, e->answer.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Answer on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->answer.channel), PRI_CHANNEL(e->answer.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->answer.call); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Answer requested on channel %d/%d not in use on span %d\n", + PRI_SPAN(e->answer.channel), PRI_CHANNEL(e->answer.channel), pri->span); + } else { + sig_pri_lock_private(pri->pvts[chanpos]); + pri_queue_control(pri->pvts[chanpos], AST_CONTROL_ANSWER, pri); + /* Enable echo cancellation if it's not on already */ + sig_pri_set_echocanceller(pri->pvts[chanpos], 1); + +#ifdef SUPPORT_USERUSER + if (!ast_strlen_zero(e->answer.useruserinfo)) { + struct ast_channel *owner = pri->pvts[chanpos]->owner; + sig_pri_unlock_private(pri->pvts[chanpos]); + pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->answer.useruserinfo); + sig_pri_lock_private(pri->pvts[chanpos]); + } +#endif + + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } + break; + case PRI_EVENT_HANGUP: + chanpos = pri_find_principle(pri, e->hangup.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Hangup requested on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->hangup.call); + if (chanpos > -1) { + sig_pri_lock_private(pri->pvts[chanpos]); + if (!pri->pvts[chanpos]->alreadyhungup) { + /* we're calling here dahdi_hangup so once we get there we need to clear p->call after calling pri_hangup */ + pri->pvts[chanpos]->alreadyhungup = 1; + if (pri->pvts[chanpos]->owner) { + /* Queue a BUSY instead of a hangup if our cause is appropriate */ + pri->pvts[chanpos]->owner->hangupcause = e->hangup.cause; + if (pri->pvts[chanpos]->owner->_state == AST_STATE_UP) + ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV); + else { + switch (e->hangup.cause) { + case PRI_CAUSE_USER_BUSY: + pri_queue_control(pri->pvts[chanpos], AST_CONTROL_BUSY, pri); + break; + case PRI_CAUSE_CALL_REJECTED: + case PRI_CAUSE_NETWORK_OUT_OF_ORDER: + case PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION: + case PRI_CAUSE_SWITCH_CONGESTION: + case PRI_CAUSE_DESTINATION_OUT_OF_ORDER: + case PRI_CAUSE_NORMAL_TEMPORARY_FAILURE: + pri_queue_control(pri->pvts[chanpos], AST_CONTROL_CONGESTION, pri); + break; + default: + ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV); + } + } + } + ast_verb(3, "Channel %d/%d, span %d got hangup, cause %d\n", + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span, e->hangup.cause); + } else { + pri_hangup(pri->pri, pri->pvts[chanpos]->call, e->hangup.cause); + pri->pvts[chanpos]->call = NULL; + } + if (e->hangup.cause == PRI_CAUSE_REQUESTED_CHAN_UNAVAIL) { + ast_verb(3, "Forcing restart of channel %d/%d on span %d since channel reported in use\n", + PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span); + pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[chanpos])); + pri->pvts[chanpos]->resetting = 1; + } + if (e->hangup.aoc_units > -1) + ast_verb(3, "Channel %d/%d, span %d received AOC-E charging %d unit%s\n", + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span, (int)e->hangup.aoc_units, (e->hangup.aoc_units == 1) ? "" : "s"); + +#ifdef SUPPORT_USERUSER + if (pri->pvts[chanpos]->owner && !ast_strlen_zero(e->hangup.useruserinfo)) { + struct ast_channel *owner = pri->pvts[chanpos]->owner; + sig_pri_unlock_private(pri->pvts[chanpos]); + pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->hangup.useruserinfo); + sig_pri_lock_private(pri->pvts[chanpos]); + } +#endif + + sig_pri_unlock_private(pri->pvts[chanpos]); + } else { + ast_log(LOG_WARNING, "Hangup on bad channel %d/%d on span %d\n", + PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span); + } + } + break; +#ifndef PRI_EVENT_HANGUP_REQ +#error please update libpri +#endif + case PRI_EVENT_HANGUP_REQ: + chanpos = pri_find_principle(pri, e->hangup.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Hangup REQ requested on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->hangup.call); + if (chanpos > -1) { + sig_pri_lock_private(pri->pvts[chanpos]); + if (pri->pvts[chanpos]->owner) { + pri->pvts[chanpos]->owner->hangupcause = e->hangup.cause; + if (pri->pvts[chanpos]->owner->_state == AST_STATE_UP) + ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV); + else { + switch (e->hangup.cause) { + case PRI_CAUSE_USER_BUSY: + pri_queue_control(pri->pvts[chanpos], AST_CONTROL_BUSY, pri); + break; + case PRI_CAUSE_CALL_REJECTED: + case PRI_CAUSE_NETWORK_OUT_OF_ORDER: + case PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION: + case PRI_CAUSE_SWITCH_CONGESTION: + case PRI_CAUSE_DESTINATION_OUT_OF_ORDER: + case PRI_CAUSE_NORMAL_TEMPORARY_FAILURE: + pri_queue_control(pri->pvts[chanpos], AST_CONTROL_CONGESTION, pri); + break; + default: + ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV); + } + } + ast_verb(3, "Channel %d/%d, span %d got hangup request, cause %d\n", PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span, e->hangup.cause); + if (e->hangup.aoc_units > -1) + ast_verb(3, "Channel %d/%d, span %d received AOC-E charging %d unit%s\n", + pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span, (int)e->hangup.aoc_units, (e->hangup.aoc_units == 1) ? "" : "s"); + } else { + pri_hangup(pri->pri, pri->pvts[chanpos]->call, e->hangup.cause); + pri->pvts[chanpos]->call = NULL; + } + if (e->hangup.cause == PRI_CAUSE_REQUESTED_CHAN_UNAVAIL) { + ast_verb(3, "Forcing restart of channel %d/%d span %d since channel reported in use\n", + PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span); + pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[chanpos])); + pri->pvts[chanpos]->resetting = 1; + } + +#ifdef SUPPORT_USERUSER + if (!ast_strlen_zero(e->hangup.useruserinfo)) { + struct ast_channel *owner = pri->pvts[chanpos]->owner; + sig_pri_unlock_private(pri->pvts[chanpos]); + pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->hangup.useruserinfo); + sig_pri_lock_private(pri->pvts[chanpos]); + } +#endif + + sig_pri_unlock_private(pri->pvts[chanpos]); + } else { + ast_log(LOG_WARNING, "Hangup REQ on bad channel %d/%d on span %d\n", PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span); + } + } + break; + case PRI_EVENT_HANGUP_ACK: + chanpos = pri_find_principle(pri, e->hangup.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Hangup ACK requested on unconfigured channel number %d/%d span %d\n", + PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->hangup.call); + if (chanpos > -1) { + sig_pri_lock_private(pri->pvts[chanpos]); + pri->pvts[chanpos]->call = NULL; + pri->pvts[chanpos]->resetting = 0; + if (pri->pvts[chanpos]->owner) { + ast_verb(3, "Channel %d/%d, span %d got hangup ACK\n", PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span); + } + +#ifdef SUPPORT_USERUSER + if (!ast_strlen_zero(e->hangup.useruserinfo)) { + struct ast_channel *owner = pri->pvts[chanpos]->owner; + sig_pri_unlock_private(pri->pvts[chanpos]); + pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->hangup.useruserinfo); + sig_pri_lock_private(pri->pvts[chanpos]); + } +#endif + + sig_pri_unlock_private(pri->pvts[chanpos]); + } + } + break; + case PRI_EVENT_CONFIG_ERR: + ast_log(LOG_WARNING, "PRI Error on span %d: %s\n", pri->trunkgroup, e->err.err); + break; + case PRI_EVENT_RESTART_ACK: + chanpos = pri_find_principle(pri, e->restartack.channel); + if (chanpos < 0) { + /* Sometime switches (e.g. I421 / British Telecom) don't give us the + channel number, so we have to figure it out... This must be why + everybody resets exactly a channel at a time. */ + for (x = 0; x < pri->numchans; x++) { + if (pri->pvts[x] && pri->pvts[x]->resetting) { + chanpos = x; + sig_pri_lock_private(pri->pvts[chanpos]); + ast_log(LOG_DEBUG, "Assuming restart ack is really for channel %d/%d span %d\n", pri->pvts[chanpos]->logicalspan, + pri->pvts[chanpos]->prioffset, pri->span); + if (pri->pvts[chanpos]->owner) { + ast_log(LOG_WARNING, "Got restart ack on channel %d/%d with owner on span %d\n", pri->pvts[chanpos]->logicalspan, + pri->pvts[chanpos]->prioffset, pri->span); + ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV); + } + pri->pvts[chanpos]->resetting = 0; + ast_verb(3, "B-channel %d/%d successfully restarted on span %d\n", pri->pvts[chanpos]->logicalspan, + pri->pvts[chanpos]->prioffset, pri->span); + sig_pri_unlock_private(pri->pvts[chanpos]); + if (pri->resetting) + pri_check_restart(pri); + break; + } + } + if (chanpos < 0) { + ast_log(LOG_WARNING, "Restart ACK requested on strange channel %d/%d span %d\n", + PRI_SPAN(e->restartack.channel), PRI_CHANNEL(e->restartack.channel), pri->span); + } + } else { + if (pri->pvts[chanpos]) { + sig_pri_lock_private(pri->pvts[chanpos]); + if (pri->pvts[chanpos]->owner) { + ast_log(LOG_WARNING, "Got restart ack on channel %d/%d span %d with owner\n", + PRI_SPAN(e->restartack.channel), PRI_CHANNEL(e->restartack.channel), pri->span); + ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV); + } + pri->pvts[chanpos]->resetting = 0; + ast_verb(3, "B-channel %d/%d successfully restarted on span %d\n", pri->pvts[chanpos]->logicalspan, + pri->pvts[chanpos]->prioffset, pri->span); + sig_pri_unlock_private(pri->pvts[chanpos]); + if (pri->resetting) + pri_check_restart(pri); + } + } + break; + case PRI_EVENT_SETUP_ACK: + chanpos = pri_find_principle(pri, e->setup_ack.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Received SETUP_ACKNOWLEDGE on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->setup_ack.channel), PRI_CHANNEL(e->setup_ack.channel), pri->span); + } else { + chanpos = pri_fixup_principle(pri, chanpos, e->setup_ack.call); + if (chanpos > -1) { + sig_pri_lock_private(pri->pvts[chanpos]); + pri->pvts[chanpos]->setup_ack = 1; + /* Send any queued digits */ + for (x = 0;x < strlen(pri->pvts[chanpos]->dialdest); x++) { + ast_log(LOG_DEBUG, "Sending pending digit '%c'\n", pri->pvts[chanpos]->dialdest[x]); + pri_information(pri->pri, pri->pvts[chanpos]->call, + pri->pvts[chanpos]->dialdest[x]); + } + sig_pri_unlock_private(pri->pvts[chanpos]); + } else + ast_log(LOG_WARNING, "Unable to move channel %d!\n", e->setup_ack.channel); + } + break; + case PRI_EVENT_NOTIFY: + chanpos = pri_find_principle(pri, e->notify.channel); + if (chanpos < 0) { + ast_log(LOG_WARNING, "Received NOTIFY on unconfigured channel %d/%d span %d\n", + PRI_SPAN(e->notify.channel), PRI_CHANNEL(e->notify.channel), pri->span); + } else { + struct ast_frame f = { AST_FRAME_CONTROL, }; + sig_pri_lock_private(pri->pvts[chanpos]); + switch (e->notify.info) { + case PRI_NOTIFY_REMOTE_HOLD: + f.subclass = AST_CONTROL_HOLD; + pri_queue_frame(pri->pvts[chanpos], &f, pri); + break; + case PRI_NOTIFY_REMOTE_RETRIEVAL: + f.subclass = AST_CONTROL_UNHOLD; + pri_queue_frame(pri->pvts[chanpos], &f, pri); + break; + } + sig_pri_unlock_private(pri->pvts[chanpos]); + } + break; + default: + ast_log(LOG_DEBUG, "Event: %d\n", e->e); + } + } + ast_mutex_unlock(&pri->lock); + } + /* Never reached */ + return NULL; +} + +void sig_pri_init_pri(struct sig_pri_pri *pri) +{ + int i; + + memset(pri, 0, sizeof(*pri)); + + ast_mutex_init(&pri->lock); + + pri->master = AST_PTHREADT_NULL; + for (i = 0; i < NUM_DCHANS; i++) + pri->fds[i] = -1; +} + +int sig_pri_hangup(struct sig_pri_chan *p, struct ast_channel *ast) +{ + int res = 0; +#ifdef SUPPORT_USERUSER + const char *useruser = pbx_builtin_getvar_helper(ast, "USERUSERINFO"); +#endif + + ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel); + if (!ast->tech_pvt) { + ast_log(LOG_WARNING, "Asked to hangup channel not connected\n"); + return 0; + } + + p->owner = NULL; + p->outgoing = 0; + p->digital = 0; + p->proceeding = 0; + p->progress = 0; + p->alerting = 0; + p->setup_ack = 0; + p->rdnis[0] = '\0'; + p->exten[0] = '\0'; + + if (!p->call) { + res = 0; + goto exit; + } + + /* Make sure we have a call (or REALLY have a call in the case of a PRI) */ + if (!pri_grab(p, p->pri)) { + if (p->alreadyhungup) { + ast_log(LOG_DEBUG, "Already hungup... Calling hangup once, and clearing call\n"); + +#ifdef SUPPORT_USERUSER + pri_call_set_useruser(p->call, useruser); +#endif + + pri_hangup(p->pri->pri, p->call, -1); + p->call = NULL; + } else { + const char *cause = pbx_builtin_getvar_helper(ast,"PRI_CAUSE"); + int icause = ast->hangupcause ? ast->hangupcause : -1; + ast_log(LOG_DEBUG, "Not yet hungup... Calling hangup once with icause, and clearing call\n"); + +#ifdef SUPPORT_USERUSER + pri_call_set_useruser(p->call, useruser); +#endif + + p->alreadyhungup = 1; + if (cause) { + if (atoi(cause)) + icause = atoi(cause); + } + pri_hangup(p->pri->pri, p->call, icause); + } + if (res < 0) + ast_log(LOG_WARNING, "pri_disconnect failed\n"); + pri_rel(p->pri); + } else { + ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span); + res = -1; + } + +exit: + ast->tech_pvt = NULL; + return res; +} + +int sig_pri_call(struct sig_pri_chan *p, struct ast_channel *ast, char *rdest, int timeout, int layer1) +{ + char dest[256]; /* must be same length as p->dialdest */ + struct pri_sr *sr; + char *c, *l, *n, *s = NULL; +#ifdef SUPPORT_USERUSER + const char *useruser; +#endif + int pridialplan; + int dp_strip; + int prilocaldialplan; + int ldp_strip; + int exclusive; + const char *rr_str; + int redirect_reason; + + ast_log(LOG_DEBUG, "CALLING CID_NAME: %s CID_NUM:: %s\n", ast->cid.cid_name, ast->cid.cid_num); + + if (!p->pri) { + ast_log(LOG_ERROR, "Could not find pri on channel %d\n", p->channel); + return -1; + } + + + if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) { + ast_log(LOG_WARNING, "sig_pri_call called on %s, neither down nor reserved\n", ast->name); + return -1; + } + + ast_copy_string(dest, rdest, sizeof(dest)); + + p->dialdest[0] = '\0'; + p->outgoing = 1; + + c = strchr(dest, '/'); + if (c) + c++; + else + c = dest; + + l = NULL; + n = NULL; + + if (!p->hidecallerid) { + l = ast->connected.id.number; + if (!p->hidecalleridname) { + n = ast->connected.id.name; + } + } + + + if (strlen(c) < p->stripmsd) { + ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd); + return -1; + } + if (pri_grab(p, p->pri)) { + ast_log(LOG_WARNING, "Failed to grab PRI!\n"); + return -1; + } + if (!(p->call = pri_new_call(p->pri->pri))) { + ast_log(LOG_WARNING, "Unable to create call on channel %d\n", p->channel); + pri_rel(p->pri); + return -1; + } + if (!(sr = pri_sr_new())) { + ast_log(LOG_WARNING, "Failed to allocate setup request channel %d\n", p->channel); + pri_destroycall(p->pri->pri, p->call); + p->call = NULL; + pri_rel(p->pri); + return -1; + } + + p->digital = IS_DIGITAL(ast->transfercapability); + /* Add support for exclusive override */ + if (p->priexclusive) + exclusive = 1; + else { + /* otherwise, traditional behavior */ + if (p->pri->nodetype == PRI_NETWORK) + exclusive = 0; + else + exclusive = 1; + } + + pri_sr_set_channel(sr, PVT_TO_CHANNEL(p), exclusive, 1); + pri_sr_set_bearer(sr, p->digital ? PRI_TRANS_CAP_DIGITAL : ast->transfercapability, + (p->digital ? -1 : layer1)); + + if (p->pri->facilityenable) + pri_facility_enable(p->pri->pri); + + ast_verb(3, "Requested transfer capability: 0x%.2x - %s\n", ast->transfercapability, ast_transfercapability2str(ast->transfercapability)); + dp_strip = 0; + pridialplan = p->pri->dialplan - 1; + if (pridialplan == -2 || pridialplan == -3) { /* compute dynamically */ + if (strncmp(c + p->stripmsd, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) { + if (pridialplan == -2) { + dp_strip = strlen(p->pri->internationalprefix); + } + pridialplan = PRI_INTERNATIONAL_ISDN; + } else if (strncmp(c + p->stripmsd, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) { + if (pridialplan == -2) { + dp_strip = strlen(p->pri->nationalprefix); + } + pridialplan = PRI_NATIONAL_ISDN; + } else { + pridialplan = PRI_LOCAL_ISDN; + } + } + while (c[p->stripmsd] > '9' && c[p->stripmsd] != '*' && c[p->stripmsd] != '#') { + switch (c[p->stripmsd]) { + case 'U': + pridialplan = (PRI_TON_UNKNOWN << 4) | (pridialplan & 0xf); + break; + case 'I': + pridialplan = (PRI_TON_INTERNATIONAL << 4) | (pridialplan & 0xf); + break; + case 'N': + pridialplan = (PRI_TON_NATIONAL << 4) | (pridialplan & 0xf); + break; + case 'L': + pridialplan = (PRI_TON_NET_SPECIFIC << 4) | (pridialplan & 0xf); + break; + case 'S': + pridialplan = (PRI_TON_SUBSCRIBER << 4) | (pridialplan & 0xf); + break; + case 'V': + pridialplan = (PRI_TON_ABBREVIATED << 4) | (pridialplan & 0xf); + break; + case 'R': + pridialplan = (PRI_TON_RESERVED << 4) | (pridialplan & 0xf); + break; + case 'u': + pridialplan = PRI_NPI_UNKNOWN | (pridialplan & 0xf0); + break; + case 'e': + pridialplan = PRI_NPI_E163_E164 | (pridialplan & 0xf0); + break; + case 'x': + pridialplan = PRI_NPI_X121 | (pridialplan & 0xf0); + break; + case 'f': + pridialplan = PRI_NPI_F69 | (pridialplan & 0xf0); + break; + case 'n': + pridialplan = PRI_NPI_NATIONAL | (pridialplan & 0xf0); + break; + case 'p': + pridialplan = PRI_NPI_PRIVATE | (pridialplan & 0xf0); + break; + case 'r': + pridialplan = PRI_NPI_RESERVED | (pridialplan & 0xf0); + break; + default: + if (isalpha(c[p->stripmsd])) { + ast_log(LOG_WARNING, "Unrecognized pridialplan %s modifier: %c\n", + c[p->stripmsd] > 'Z' ? "NPI" : "TON", c[p->stripmsd]); + } + break; + } + c++; + } + pri_sr_set_called(sr, c + p->stripmsd + dp_strip, pridialplan, s ? 1 : 0); + + ldp_strip = 0; + prilocaldialplan = p->pri->localdialplan - 1; + if ((l != NULL) && (prilocaldialplan == -2 || prilocaldialplan == -3)) { /* compute dynamically */ + if (strncmp(l, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) { + if (prilocaldialplan == -2) { + ldp_strip = strlen(p->pri->internationalprefix); + } + prilocaldialplan = PRI_INTERNATIONAL_ISDN; + } else if (strncmp(l, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) { + if (prilocaldialplan == -2) { + ldp_strip = strlen(p->pri->nationalprefix); + } + prilocaldialplan = PRI_NATIONAL_ISDN; + } else { + prilocaldialplan = PRI_LOCAL_ISDN; + } + } + if (l != NULL) { + while (*l > '9' && *l != '*' && *l != '#') { + switch (*l) { + case 'U': + prilocaldialplan = (PRI_TON_UNKNOWN << 4) | (prilocaldialplan & 0xf); + break; + case 'I': + prilocaldialplan = (PRI_TON_INTERNATIONAL << 4) | (prilocaldialplan & 0xf); + break; + case 'N': + prilocaldialplan = (PRI_TON_NATIONAL << 4) | (prilocaldialplan & 0xf); + break; + case 'L': + prilocaldialplan = (PRI_TON_NET_SPECIFIC << 4) | (prilocaldialplan & 0xf); + break; + case 'S': + prilocaldialplan = (PRI_TON_SUBSCRIBER << 4) | (prilocaldialplan & 0xf); + break; + case 'V': + prilocaldialplan = (PRI_TON_ABBREVIATED << 4) | (prilocaldialplan & 0xf); + break; + case 'R': + prilocaldialplan = (PRI_TON_RESERVED << 4) | (prilocaldialplan & 0xf); + break; + case 'u': + prilocaldialplan = PRI_NPI_UNKNOWN | (prilocaldialplan & 0xf0); + break; + case 'e': + prilocaldialplan = PRI_NPI_E163_E164 | (prilocaldialplan & 0xf0); + break; + case 'x': + prilocaldialplan = PRI_NPI_X121 | (prilocaldialplan & 0xf0); + break; + case 'f': + prilocaldialplan = PRI_NPI_F69 | (prilocaldialplan & 0xf0); + break; + case 'n': + prilocaldialplan = PRI_NPI_NATIONAL | (prilocaldialplan & 0xf0); + break; + case 'p': + prilocaldialplan = PRI_NPI_PRIVATE | (prilocaldialplan & 0xf0); + break; + case 'r': + prilocaldialplan = PRI_NPI_RESERVED | (prilocaldialplan & 0xf0); + break; + default: + if (isalpha(*l)) { + ast_log(LOG_WARNING, + "Unrecognized prilocaldialplan %s modifier: %c\n", + *l > 'Z' ? "NPI" : "TON", *l); + } + break; + } + l++; + } + } + pri_sr_set_caller(sr, l ? (l + ldp_strip) : NULL, n, prilocaldialplan, + p->use_callingpres ? ast->cid.cid_pres : (l ? PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN : PRES_NUMBER_NOT_AVAILABLE)); + if ((rr_str = pbx_builtin_getvar_helper(ast, "PRIREDIRECTREASON"))) { + if (!strcasecmp(rr_str, "UNKNOWN")) + redirect_reason = 0; + else if (!strcasecmp(rr_str, "BUSY")) + redirect_reason = 1; + else if (!strcasecmp(rr_str, "NO_REPLY")) + redirect_reason = 2; + else if (!strcasecmp(rr_str, "UNCONDITIONAL")) + redirect_reason = 15; + else + redirect_reason = PRI_REDIR_UNCONDITIONAL; + } else + redirect_reason = PRI_REDIR_UNCONDITIONAL; + pri_sr_set_redirecting(sr, ast->cid.cid_rdnis, p->pri->localdialplan - 1, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, redirect_reason); + +#ifdef SUPPORT_USERUSER + /* User-user info */ + useruser = pbx_builtin_getvar_helper(p->owner, "USERUSERINFO"); + if (useruser) + pri_sr_set_useruser(sr, useruser); +#endif + + if (pri_setup(p->pri->pri, p->call, sr)) { + ast_log(LOG_WARNING, "Unable to setup call to %s (using %s)\n", + c + p->stripmsd + dp_strip, dialplan2str(p->pri->dialplan)); + pri_rel(p->pri); + pri_sr_free(sr); + return -1; + } + pri_sr_free(sr); + ast_setstate(ast, AST_STATE_DIALING); + pri_rel(p->pri); + return 0; +} + +int sig_pri_indicate(struct sig_pri_chan *p, struct ast_channel *chan, int condition, const void *data, size_t datalen) +{ + int res = 0; + + switch (condition) { + case AST_CONTROL_BUSY: + if (p->priindication_oob) { + chan->hangupcause = AST_CAUSE_USER_BUSY; + chan->_softhangup |= AST_SOFTHANGUP_DEV; + res = 0; + } else if (!p->progress && p->pri && !p->outgoing) { + if (p->pri->pri) { + if (!pri_grab(p, p->pri)) { +#ifdef HAVE_PRI_PROG_W_CAUSE + pri_progress_with_cause(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1, PRI_CAUSE_USER_BUSY); /* cause = 17 */ +#else + pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1); +#endif + pri_rel(p->pri); + } else { + ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span); + } + } + p->progress = 1; + res = sig_pri_play_tone(p, SIG_PRI_TONE_BUSY); + } + break; + case AST_CONTROL_RINGING: + if ((!p->alerting) && p->pri && !p->outgoing && (chan->_state != AST_STATE_UP)) { + if (p->pri->pri) { + if (!pri_grab(p, p->pri)) { + pri_acknowledge(p->pri->pri,p->call, PVT_TO_CHANNEL(p), !p->digital); + pri_rel(p->pri); + } else { + ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span); + } + } + p->alerting = 1; + } + res = sig_pri_play_tone(p, SIG_PRI_TONE_RINGTONE); + if (chan->_state != AST_STATE_UP) { + if (chan->_state != AST_STATE_RING) + ast_setstate(chan, AST_STATE_RINGING); + } + break; + case AST_CONTROL_PROCEEDING: + ast_debug(1,"Received AST_CONTROL_PROCEEDING on %s\n",chan->name); + if (!p->proceeding && p->pri && !p->outgoing) { + if (p->pri->pri) { + if (!pri_grab(p, p->pri)) { + pri_proceeding(p->pri->pri,p->call, PVT_TO_CHANNEL(p), !p->digital); + pri_rel(p->pri); + } else { + ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span); + } + } + p->proceeding = 1; + } + /* don't continue in ast_indicate */ + res = 0; + break; + case AST_CONTROL_PROGRESS: + ast_log(LOG_DEBUG,"Received AST_CONTROL_PROGRESS on %s\n",chan->name); + p->digital = 0; /* Digital-only calls isn't allowing any inband progress messages */ + if (!p->progress && p->pri && !p->outgoing) { + if (p->pri->pri) { + if (!pri_grab(p, p->pri)) { + pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1); + pri_rel(p->pri); + } else { + ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span); + } + } + p->progress = 1; + } + /* don't continue in ast_indicate */ + res = 0; + break; + case AST_CONTROL_CONGESTION: + chan->hangupcause = AST_CAUSE_CONGESTION; + if (p->priindication_oob) { + chan->hangupcause = AST_CAUSE_SWITCH_CONGESTION; + chan->_softhangup |= AST_SOFTHANGUP_DEV; + res = 0; + } else if (!p->progress && p->pri && !p->outgoing) { + if (p->pri) { + if (!pri_grab(p, p->pri)) { +#ifdef HAVE_PRI_PROG_W_CAUSE + pri_progress_with_cause(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1, PRI_CAUSE_SWITCH_CONGESTION); /* cause = 42 */ +#else + pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1); +#endif + pri_rel(p->pri); + } else { + ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span); + } + } + p->progress = 1; + res = sig_pri_play_tone(p, SIG_PRI_TONE_CONGESTION); + } + break; + case AST_CONTROL_HOLD: + if (p->pri && !strcasecmp(p->mohinterpret, "passthrough")) { + if (!pri_grab(p, p->pri)) { + res = pri_notify(p->pri->pri, p->call, p->prioffset, PRI_NOTIFY_REMOTE_HOLD); + pri_rel(p->pri); + } else { + ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span); + } + } else + ast_moh_start(chan, data, p->mohinterpret); + break; + case AST_CONTROL_UNHOLD: + if (p->pri && !strcasecmp(p->mohinterpret, "passthrough")) { + if (!pri_grab(p, p->pri)) { + res = pri_notify(p->pri->pri, p->call, p->prioffset, PRI_NOTIFY_REMOTE_RETRIEVAL); + pri_rel(p->pri); + } + } else + ast_moh_stop(chan); + break; + case AST_CONTROL_SRCUPDATE: + res = 0; + break; + case -1: + res = sig_pri_play_tone(p, -1); + break; + } + + return res; +} + +int sig_pri_answer(struct sig_pri_chan *p, struct ast_channel *ast) +{ + int res = 0; + /* Send a pri acknowledge */ + if (!pri_grab(p, p->pri)) { + p->proceeding = 1; + res = pri_answer(p->pri->pri, p->call, 0, !p->digital); + pri_rel(p->pri); + } else { + res = -1; + } + ast_setstate(ast, AST_STATE_UP); + return res; +} + +int sig_pri_available(struct sig_pri_chan *p, int channelmatch, ast_group_t groupmatch, int *reason, int *channelmatched, int *groupmatched) +{ + /* If no owner definitely available */ + if (!p->owner) { + /* Trust PRI */ + if (p->pri) { +#ifdef HAVE_PRI_SERVICE_MESSAGES + char db_chan_name[20], db_answer[5], state; + int why = 0; + + snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, p->pri->span, p->channel); + if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) { + sscanf(db_answer, "%c:%d", &state, &why); + } + if ((p->resetting || p->call) || (why)) { + if (why) { + *reason = AST_CAUSE_REQUESTED_CHAN_UNAVAIL; + } +#else + if (p->resetting || p->call) { +#endif + return 0; + } else { + return 1; + } + } + } + + return 0; +} + +/* If return 0, it means this function was able to handle it (pre setup digits). If non zero, the user of this + * functions should handle it normally (generate inband DTMF) */ +int sig_pri_digit_begin(struct sig_pri_chan *pvt, struct ast_channel *ast, char digit) +{ + if ((ast->_state == AST_STATE_DIALING) && !pvt->proceeding) { + if (pvt->setup_ack) { + if (!pri_grab(pvt, pvt->pri)) { + pri_information(pvt->pri->pri, pvt->call, digit); + pri_rel(pvt->pri); + } else { + ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", pvt->pri->span); + } + } else if (strlen(pvt->dialdest) < sizeof(pvt->dialdest) - 1) { + int res; + ast_debug(1, "Queueing digit '%c' since setup_ack not yet received\n", digit); + res = strlen(pvt->dialdest); + pvt->dialdest[res++] = digit; + pvt->dialdest[res] = '\0'; + } + return 0; + } + return 1; +} + +int sig_pri_start_pri(struct sig_pri_pri *pri) +{ + int x; + int i; + + ast_mutex_init(&pri->lock); + + for (i = 0; i < NUM_DCHANS; i++) { + if (pri->fds[i] == -1) { + break; + } + + switch (pri->sig) { + case SIG_BRI: + pri->dchans[i] = pri_new_bri(pri->fds[i], 1, pri->nodetype, pri->switchtype); + break; + case SIG_BRI_PTMP: + pri->dchans[i] = pri_new_bri(pri->fds[i], 0, pri->nodetype, pri->switchtype); + break; + default: + pri->dchans[i] = pri_new(pri->fds[i], pri->nodetype, pri->switchtype); +#ifdef HAVE_PRI_SERVICE_MESSAGES + if (pri->enable_service_message_support) { + pri_set_service_message_support(pri->dchans[i], 1); + } +#endif + } + + /* Force overlap dial if we're doing GR-303! */ + pri_set_overlapdial(pri->dchans[i], pri->overlapdial); + pri_set_inbanddisconnect(pri->dchans[i], pri->inbanddisconnect); + /* Enslave to master if appropriate */ + if (i) + pri_enslave(pri->dchans[0], pri->dchans[i]); + if (!pri->dchans[i]) { + if (pri->fds[i] > 0) + close(pri->fds[i]); + pri->fds[i] = -1; + ast_log(LOG_ERROR, "Unable to create PRI structure\n"); + return -1; + } + pri_set_debug(pri->dchans[i], 0); + pri_set_nsf(pri->dchans[i], pri->nsf); +#ifdef PRI_GETSET_TIMERS + for (x = 0; x < PRI_MAX_TIMERS; x++) { + if (pri->pritimers[x] != 0) + pri_set_timer(pri->dchans[i], x, pri->pritimers[x]); + } +#endif + } + /* Assume primary is the one we use */ + pri->pri = pri->dchans[0]; + pri->resetpos = -1; + if (ast_pthread_create_background(&pri->master, NULL, pri_dchannel, pri)) { + for (i = 0; i < NUM_DCHANS; i++) { + if (!pri->dchans[i]) + break; + if (pri->fds[i] > 0) + close(pri->fds[i]); + pri->fds[i] = -1; + } + ast_log(LOG_ERROR, "Unable to spawn D-channel: %s\n", strerror(errno)); + return -1; + } + return 0; +} + +void sig_pri_chan_alarm_notify(struct sig_pri_chan *p, int noalarm) +{ + if (!noalarm) { + p->inalarm = 1; + if (!p->pri || !p->pri->pri || (pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0)) { + /* T309 is not enabled : hangup calls when alarm occurs */ + if (p->call) { + if (p->pri && p->pri->pri) { + if (!pri_grab(p, p->pri)) { + pri_hangup(p->pri->pri, p->call, -1); + pri_destroycall(p->pri->pri, p->call); + p->call = NULL; + pri_rel(p->pri); + } else + ast_log(LOG_WARNING, "Failed to grab PRI!\n"); + } else + ast_log(LOG_WARNING, "Failed to grab PRI!\n"); + } else + ast_log(LOG_WARNING, "The PRI Call has not been destroyed\n"); + } + if (p->owner) + ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV); + } else { + p->inalarm = 0; + } +} + +struct sig_pri_chan *sig_pri_chan_new(void *pvt_data, struct sig_pri_callback *callback, struct sig_pri_pri *pri, int logicalspan, int channo) +{ + struct sig_pri_chan *p; + + p = ast_calloc(1, sizeof(*p)); + + if (!p) + return p; + + p->logicalspan = logicalspan; + p->prioffset = channo; + + p->calls = callback; + p->chan_pvt = pvt_data; + + pri->pvts[pri->numchans++] = p; + p->pri = pri; + + return p; +} + +static void build_status(char *s, size_t len, int status, int active) +{ + if (!s || len < 1) { + return; + } + s[0] = '\0'; + if (!(status & DCHAN_NOTINALARM)) + strncat(s, "In Alarm, ", len - strlen(s) - 1); + if (status & DCHAN_UP) + strncat(s, "Up", len - strlen(s) - 1); + else + strncat(s, "Down", len - strlen(s) - 1); + if (active) + strncat(s, ", Active", len - strlen(s) - 1); + else + strncat(s, ", Standby", len - strlen(s) - 1); + s[len - 1] = '\0'; +} + +void sig_pri_cli_show_spans(int fd, int span, struct sig_pri_pri *pri) +{ + char status[256]; + int x; + for (x = 0; x < NUM_DCHANS; x++) { + if (pri->dchans[x]) { + build_status(status, sizeof(status), pri->dchanavail[x], pri->dchans[x] == pri->pri); + ast_cli(fd, "PRI span %d/%d: %s\n", span, x, status); + } + } +} + +void sig_pri_cli_show_span(int fd, int *dchannels, struct sig_pri_pri *pri) +{ + int x; + char status[256]; + + for (x = 0; x < NUM_DCHANS; x++) { + if (pri->dchans[x]) { +#ifdef PRI_DUMP_INFO_STR + char *info_str = NULL; +#endif + ast_cli(fd, "%s D-channel: %d\n", pri_order(x), dchannels[x]); + build_status(status, sizeof(status), pri->dchanavail[x], pri->dchans[x] == pri->pri); + ast_cli(fd, "Status: %s\n", status); +#ifdef PRI_DUMP_INFO_STR + info_str = pri_dump_info_str(pri->pri); + if (info_str) { + ast_cli(fd, "%s", info_str); + free(info_str); + } +#else + pri_dump_info(pri->pri); +#endif + ast_cli(fd, "Overlap Recv: %s\n\n", (pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)?"Yes":"No"); + ast_cli(fd, "\n"); + } + } +} + +int pri_send_keypad_facility_exec(struct sig_pri_chan *p, const char *digits) +{ + sig_pri_lock_private(p); + + if (!p->pri || !p->call) { + ast_debug(1, "Unable to find pri or call on channel!\n"); + sig_pri_unlock_private(p); + return -1; + } + + if (!pri_grab(p, p->pri)) { + pri_keypad_facility(p->pri->pri, p->call, digits); + pri_rel(p->pri); + } else { + ast_debug(1, "Unable to grab pri to send keypad facility!\n"); + sig_pri_unlock_private(p); + return -1; + } + + sig_pri_unlock_private(p); + + return 0; +} + +int pri_send_callrerouting_facility_exec(struct sig_pri_chan *p, enum ast_channel_state chanstate, const char *destination, const char *original, const char *reason) +{ + int res = -1; + + sig_pri_lock_private(p); + + if (!p->pri || !p->call) { + ast_log(LOG_DEBUG, "Unable to find pri or call on channel!\n"); + sig_pri_unlock_private(p); + return -1; + } + + switch (p->pri->sig) { + case SIG_PRI: + if (!pri_grab(p, p->pri)) { + if (chanstate == AST_STATE_RING) { + res = pri_callrerouting_facility(p->pri->pri, p->call, destination, original, reason); + } + pri_rel(p->pri); + } else { + ast_log(LOG_DEBUG, "Unable to grab pri to send callrerouting facility on span %d!\n", p->pri->span); + sig_pri_unlock_private(p); + return -1; + } + break; + } + + sig_pri_unlock_private(p); + + return res; +} + +int pri_maintenance_bservice(struct pri *pri, struct sig_pri_chan *p, int changestatus) +{ + int channel = PVT_TO_CHANNEL(p); + int span = PRI_SPAN(channel); + + return pri_maintenance_service(pri, span, channel, changestatus); +} + +#endif /* HAVE_PRI */ |