8d73327932069bdd1791d7116693b66a7b92fc46
[asterisk/asterisk.git] / channels / sig_pri.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2009, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  * 
21  * \brief PRI signaling module
22  *
23  * \author Matthew Fredrickson <creslin@digium.com>
24  */
25
26
27 #include "asterisk.h"
28
29 #ifdef HAVE_PRI
30
31 #include <errno.h>
32 #include <ctype.h>
33 #include <signal.h>
34
35 #include "asterisk/utils.h"
36 #include "asterisk/options.h"
37 #include "asterisk/pbx.h"
38 #include "asterisk/file.h"
39 #include "asterisk/callerid.h"
40 #include "asterisk/say.h"
41 #include "asterisk/manager.h"
42 #include "asterisk/astdb.h"
43 #include "asterisk/causes.h"
44 #include "asterisk/musiconhold.h"
45 #include "asterisk/cli.h"
46 #include "asterisk/transcap.h"
47 #include "asterisk/features.h"
48
49 #include "sig_pri.h"
50
51 static int pri_matchdigittimeout = 3000;
52
53 static int pri_gendigittimeout = 8000;
54
55 #define DCHAN_NOTINALARM  (1 << 0)
56 #define DCHAN_UP          (1 << 1)
57
58 #define PRI_CHANNEL(p) ((p) & 0xff)
59 #define PRI_SPAN(p) (((p) >> 8) & 0xff)
60 #define PRI_EXPLICIT(p) (((p) >> 16) & 0x01)
61
62
63 #define DCHAN_AVAILABLE (DCHAN_NOTINALARM | DCHAN_UP)
64
65 #define PRI_DEADLOCK_AVOIDANCE(lock) \
66         do { \
67                 sig_pri_unlock_private(p); \
68                 usleep(1); \
69                 sig_pri_lock_private(p); \
70         } while (0)
71
72 static int pri_active_dchan_index(struct sig_pri_pri *pri);
73
74 static inline void pri_rel(struct sig_pri_pri *pri)
75 {
76         ast_mutex_unlock(&pri->lock);
77 }
78
79 static unsigned int PVT_TO_CHANNEL(struct sig_pri_chan *p)
80 {
81         int explicit;
82
83         if (p->pri->dchan_logical_span[pri_active_dchan_index(p->pri)] == p->logicalspan)
84                 explicit = 1;
85         else
86                 explicit = 0;
87
88         return (((p)->prioffset) | ((p)->logicalspan << 8) | (explicit ? 0x10000 : 0));
89 }
90
91 static void sig_pri_handle_dchan_exception(struct sig_pri_pri *pri, int index)
92 {
93         if (pri->calls->handle_dchan_exception)
94                 pri->calls->handle_dchan_exception(pri, index);
95 }
96
97 static void sig_pri_set_dialing(struct sig_pri_chan *p, int flag)
98 {
99         if (p->calls->set_dialing)
100                 p->calls->set_dialing(p, flag);
101 }
102
103 static void sig_pri_unlock_private(struct sig_pri_chan *p)
104 {
105         if (p->calls->unlock_private)
106                 p->calls->unlock_private(p->chan_pvt);
107 }
108
109 static void sig_pri_lock_private(struct sig_pri_chan *p)
110 {
111         if (p->calls->lock_private)
112                 p->calls->lock_private(p->chan_pvt);
113 }
114
115 static inline int pri_grab(struct sig_pri_chan *p, struct sig_pri_pri *pri)
116 {
117         int res;
118         /* Grab the lock first */
119         do {
120                 res = ast_mutex_trylock(&pri->lock);
121                 if (res) {
122                         PRI_DEADLOCK_AVOIDANCE(p);
123                 }
124         } while (res);
125         /* Then break the poll */
126         pthread_kill(pri->master, SIGURG);
127         return 0;
128 }
129
130 static int sig_pri_set_echocanceller(struct sig_pri_chan *p, int enable)
131 {
132         if (p->calls->set_echocanceller)
133                 return p->calls->set_echocanceller(p->chan_pvt, enable);
134         else
135                 return -1;
136 }
137
138 static void sig_pri_fixup_chans(struct sig_pri_chan *old, struct sig_pri_chan *new)
139 {
140         if (old->calls->fixup_chans)
141                 old->calls->fixup_chans(old->chan_pvt, new->chan_pvt);
142 }
143
144 static int sig_pri_play_tone(struct sig_pri_chan *p, enum sig_pri_tone tone)
145 {
146         if (p->calls->play_tone)
147                 return p->calls->play_tone(p->chan_pvt, tone);
148         else
149                 return -1;
150 }
151
152 static struct ast_channel *sig_pri_new_ast_channel(struct sig_pri_chan *p, int state, int startpbx, int ulaw, int transfercapability, char *exten, const struct ast_channel *requestor)
153 {
154         struct ast_channel *c;
155
156         if (p->calls->new_ast_channel)
157                 c = p->calls->new_ast_channel(p->chan_pvt, state, startpbx, ulaw, transfercapability, exten, requestor);
158         else
159                 return NULL;
160
161         if (!p->owner)
162                 p->owner = c;
163         p->isidlecall = 0;
164         p->alreadyhungup = 0;
165
166         return c;
167 }
168
169 struct ast_channel *sig_pri_request(struct sig_pri_chan *p, enum sig_pri_law law, const struct ast_channel *requestor)
170 {
171         ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel);
172
173         return sig_pri_new_ast_channel(p, AST_STATE_RESERVED, 0, law, 0, p->exten, requestor);
174 }
175
176 int pri_is_up(struct sig_pri_pri *pri)
177 {
178         int x;
179         for (x = 0; x < NUM_DCHANS; x++) {
180                 if (pri->dchanavail[x] == DCHAN_AVAILABLE)
181                         return 1;
182         }
183         return 0;
184 }
185
186 static char *pri_order(int level)
187 {
188         switch (level) {
189         case 0:
190                 return "Primary";
191         case 1:
192                 return "Secondary";
193         case 2:
194                 return "Tertiary";
195         case 3:
196                 return "Quaternary";
197         default:
198                 return "<Unknown>";
199         }               
200 }
201
202 /* Returns index of the active dchan */
203 static int pri_active_dchan_index(struct sig_pri_pri *pri)
204 {
205         int x = -1;
206
207         for (x = 0; x < NUM_DCHANS; x++) {
208                 if ((pri->dchans[x] == pri->pri))
209                         break;
210         }
211
212         return x;
213 }
214
215 static int pri_find_dchan(struct sig_pri_pri *pri)
216 {
217         int oldslot = -1;
218         struct pri *old;
219         int newslot = -1;
220         int x;
221         old = pri->pri;
222         for (x = 0; x < NUM_DCHANS; x++) {
223                 if ((pri->dchanavail[x] == DCHAN_AVAILABLE) && (newslot < 0))
224                         newslot = x;
225                 if (pri->dchans[x] == old) {
226                         oldslot = x;
227                 }
228         }
229         if (newslot < 0) {
230                 newslot = 0;
231                 /* This is annoying to see on non persistent layer 2 connections.  Let's not complain in that case */
232                 if (pri->sig != SIG_BRI_PTMP) {
233                         ast_log(LOG_WARNING, "No D-channels available!  Using Primary channel as D-channel anyway!\n");
234                 }
235         }
236         if (old && (oldslot != newslot))
237                 ast_log(LOG_NOTICE, "Switching from d-channel fd %d to fd %d!\n",
238                         pri->fds[oldslot], pri->fds[newslot]);
239         pri->pri = pri->dchans[newslot];
240         return 0;
241 }
242 static void pri_update_cid(struct sig_pri_chan *p, struct sig_pri_pri *pri)
243 {
244         /* We must unlock the PRI to avoid the possibility of a deadlock */
245         if (pri)
246                 ast_mutex_unlock(&pri->lock);
247         for (;;) {
248                 if (p->owner) {
249                         if (ast_channel_trylock(p->owner)) {
250                                 PRI_DEADLOCK_AVOIDANCE(p);
251                         } else {
252                                 ast_set_callerid(p->owner, S_OR(p->lastcid_num, NULL),
253                                                         S_OR(p->lastcid_name, NULL),
254                                                         S_OR(p->lastcid_num, NULL)
255                                                         );
256                                 ast_channel_unlock(p->owner);
257                                 break;
258                         }
259                 } else
260                         break;
261         }
262         if (pri)
263                 ast_mutex_lock(&pri->lock);
264 }
265
266 static void pri_queue_frame(struct sig_pri_chan *p, struct ast_frame *f, struct sig_pri_pri *pri)
267 {
268         /* We must unlock the PRI to avoid the possibility of a deadlock */
269         if (pri)
270                 ast_mutex_unlock(&pri->lock);
271         for (;;) {
272                 if (p->owner) {
273                         if (ast_channel_trylock(p->owner)) {
274                                 PRI_DEADLOCK_AVOIDANCE(p);
275                         } else {
276                                 ast_queue_frame(p->owner, f);
277                                 ast_channel_unlock(p->owner);
278                                 break;
279                         }
280                 } else
281                         break;
282         }
283         if (pri)
284                 ast_mutex_lock(&pri->lock);
285 }
286
287 static void pri_queue_control(struct sig_pri_chan *p, int subclass, struct sig_pri_pri *pri)
288 {
289         struct ast_frame f = {AST_FRAME_CONTROL, };
290
291         f.subclass = subclass;
292         pri_queue_frame(p, &f, pri);
293 }
294
295 static int pri_find_principle(struct sig_pri_pri *pri, int channel)
296 {
297         int x;
298         int span = PRI_SPAN(channel);
299         int principle = -1;
300         int explicit = PRI_EXPLICIT(channel);
301         channel = PRI_CHANNEL(channel);
302
303         if (!explicit) {
304                 int index = pri_active_dchan_index(pri);
305                 if (index == -1)
306                         return -1;
307                 span = pri->dchan_logical_span[index];
308         }
309
310         for (x = 0; x < pri->numchans; x++) {
311                 if (pri->pvts[x] && (pri->pvts[x]->prioffset == channel) && (pri->pvts[x]->logicalspan == span)) {
312                         principle = x;
313                         break;
314                 }
315         }
316         
317         return principle;
318 }
319
320 static int pri_fixup_principle(struct sig_pri_pri *pri, int principle, q931_call *c)
321 {
322         int x;
323         if (!c) {
324                 if (principle < 0)
325                         return -1;
326                 return principle;
327         }
328         if ((principle > -1) && 
329                 (principle < pri->numchans) && 
330                 (pri->pvts[principle]) && 
331                 (pri->pvts[principle]->call == c))
332                 return principle;
333         /* First, check for other bearers */
334         for (x = 0; x < pri->numchans; x++) {
335                 if (!pri->pvts[x])
336                         continue;
337                 if (pri->pvts[x]->call == c) {
338                         /* Found our call */
339                         if (principle != x) {
340                                 struct sig_pri_chan *new = pri->pvts[principle], *old = pri->pvts[x];
341
342                                 ast_verb(3, "Moving call from channel %d to channel %d\n",
343                                                 old->channel, new->channel);
344                                 if (new->owner) {
345                                         ast_log(LOG_WARNING, "Can't fix up channel from %d to %d because %d is already in use\n",
346                                                 old->channel, new->channel, new->channel);
347                                         return -1;
348                                 }
349
350                                 sig_pri_fixup_chans(old, new);
351                                 /* Fix it all up now */
352                                 new->owner = old->owner;
353                                 old->owner = NULL;
354
355                                 new->call = old->call;
356                                 old->call = NULL;
357
358                         }
359                         return principle;
360                 }
361         }
362         ast_log(LOG_WARNING, "Call specified, but not found?\n");
363         return -1;
364 }
365
366 static char * redirectingreason2str(int redirectingreason)
367 {
368         switch (redirectingreason) {
369         case 0:
370                 return "UNKNOWN";
371         case 1:
372                 return "BUSY";
373         case 2:
374                 return "NO_REPLY";
375         case 0xF:
376                 return "UNCONDITIONAL";
377         default:
378                 return "NOREDIRECT";
379         }
380 }
381
382 static char *dialplan2str(int dialplan)
383 {
384         if (dialplan == -1) {
385                 return("Dynamically set dialplan in ISDN");
386         }
387         return (pri_plan2str(dialplan));
388 }
389
390 static void apply_plan_to_number(char *buf, size_t size, const struct sig_pri_pri *pri, const char *number, const int plan)
391 {
392         switch (plan) {
393         case PRI_INTERNATIONAL_ISDN:            /* Q.931 dialplan == 0x11 international dialplan => prepend international prefix digits */
394                 snprintf(buf, size, "%s%s", pri->internationalprefix, number);
395                 break;
396         case PRI_NATIONAL_ISDN:                 /* Q.931 dialplan == 0x21 national dialplan => prepend national prefix digits */
397                 snprintf(buf, size, "%s%s", pri->nationalprefix, number);
398                 break;
399         case PRI_LOCAL_ISDN:                    /* Q.931 dialplan == 0x41 local dialplan => prepend local prefix digits */
400                 snprintf(buf, size, "%s%s", pri->localprefix, number);
401                 break;
402         case PRI_PRIVATE:                       /* Q.931 dialplan == 0x49 private dialplan => prepend private prefix digits */
403                 snprintf(buf, size, "%s%s", pri->privateprefix, number);
404                 break;
405         case PRI_UNKNOWN:                       /* Q.931 dialplan == 0x00 unknown dialplan => prepend unknown prefix digits */
406                 snprintf(buf, size, "%s%s", pri->unknownprefix, number);
407                 break;
408         default:                                /* other Q.931 dialplan => don't twiddle with callingnum */
409                 snprintf(buf, size, "%s", number);
410                 break;
411         }
412 }
413
414 static int pri_check_restart(struct sig_pri_pri *pri)
415 {
416 #ifdef HAVE_PRI_SERVICE_MESSAGES
417 tryanotherpos:
418 #endif
419         do {
420                 pri->resetpos++;
421         } while ((pri->resetpos < pri->numchans) &&
422                 (!pri->pvts[pri->resetpos] ||
423                 pri->pvts[pri->resetpos]->call ||
424                 pri->pvts[pri->resetpos]->resetting));
425         if (pri->resetpos < pri->numchans) {
426 #ifdef HAVE_PRI_SERVICE_MESSAGES
427                 char db_chan_name[20], db_answer[5], state;
428                 int why;
429
430                 /* check if the channel is out of service */
431                 ast_mutex_lock(&pri->pvts[pri->resetpos]->service_lock);
432                 snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->pvts[pri->resetpos]->pri->span, pri->pvts[pri->resetpos]->channel);
433                 ast_mutex_unlock(&pri->pvts[pri->resetpos]->service_lock);
434
435                 /* if so, try next channel */
436                 if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) {
437                         sscanf(db_answer, "%c:%d", &state, &why);
438                         if (why) {
439                                 ast_log(LOG_NOTICE, "span '%d' channel '%d' out-of-service (reason: %s), not sending RESTART\n", pri->span,
440                                 pri->pvts[pri->resetpos]->channel, (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end");
441                                 goto tryanotherpos;
442                         }
443                 }
444 #endif
445
446                 /* Mark the channel as resetting and restart it */
447                 pri->pvts[pri->resetpos]->resetting = 1;
448                 pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[pri->resetpos]));
449         } else {
450                 pri->resetting = 0;
451                 time(&pri->lastreset);
452         }
453         return 0;
454 }
455
456 static int pri_find_empty_chan(struct sig_pri_pri *pri, int backwards)
457 {
458         int x;
459         if (backwards)
460                 x = pri->numchans;
461         else
462                 x = 0;
463         for (;;) {
464                 if (backwards && (x < 0))
465                         break;
466                 if (!backwards && (x >= pri->numchans))
467                         break;
468                 if (pri->pvts[x] && !pri->pvts[x]->inalarm && !pri->pvts[x]->owner) {
469                         ast_debug(1, "Found empty available channel %d/%d\n", 
470                                 pri->pvts[x]->logicalspan, pri->pvts[x]->prioffset);
471                         return x;
472                 }
473                 if (backwards)
474                         x--;
475                 else
476                         x++;
477         }
478         return -1;
479 }
480
481 static void *do_idle_thread(void *vchan)
482 {
483         struct ast_channel *chan = vchan;
484         struct sig_pri_chan *pvt = chan->tech_pvt;
485         struct ast_frame *f;
486         char ex[80];
487         /* Wait up to 30 seconds for an answer */
488         int newms, ms = 30000;
489         ast_verb(3, "Initiating idle call on channel %s\n", chan->name);
490         snprintf(ex, sizeof(ex), "%d/%s", pvt->channel, pvt->pri->idledial);
491         if (ast_call(chan, ex, 0)) {
492                 ast_log(LOG_WARNING, "Idle dial failed on '%s' to '%s'\n", chan->name, ex);
493                 ast_hangup(chan);
494                 return NULL;
495         }
496         while ((newms = ast_waitfor(chan, ms)) > 0) {
497                 f = ast_read(chan);
498                 if (!f) {
499                         /* Got hangup */
500                         break;
501                 }
502                 if (f->frametype == AST_FRAME_CONTROL) {
503                         switch (f->subclass) {
504                         case AST_CONTROL_ANSWER:
505                                 /* Launch the PBX */
506                                 ast_copy_string(chan->exten, pvt->pri->idleext, sizeof(chan->exten));
507                                 ast_copy_string(chan->context, pvt->pri->idlecontext, sizeof(chan->context));
508                                 chan->priority = 1;
509                                 ast_verb(4, "Idle channel '%s' answered, sending to %s@%s\n", chan->name, chan->exten, chan->context);
510                                 ast_pbx_run(chan);
511                                 /* It's already hungup, return immediately */
512                                 return NULL;
513                         case AST_CONTROL_BUSY:
514                                 ast_verb(4, "Idle channel '%s' busy, waiting...\n", chan->name);
515                                 break;
516                         case AST_CONTROL_CONGESTION:
517                                 ast_verb(4, "Idle channel '%s' congested, waiting...\n", chan->name);
518                                 break;
519                         };
520                 }
521                 ast_frfree(f);
522                 ms = newms;
523         }
524         /* Hangup the channel since nothing happend */
525         ast_hangup(chan);
526         return NULL;
527 }
528
529 static void *pri_ss_thread(void *data)
530 {
531         struct sig_pri_chan *p = data;
532         struct ast_channel *chan = p->owner;
533         char exten[AST_MAX_EXTENSION];
534         int res;
535         int len;
536         int timeout;
537
538         /* in the bizarre case where the channel has become a zombie before we
539            even get started here, abort safely
540         */
541         if (!p) {
542                 ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", chan->name);
543                 ast_hangup(chan);
544                 return NULL;
545         }
546
547         ast_verb(3, "Starting simple switch on '%s'\n", chan->name);
548
549         /* Now loop looking for an extension */
550         ast_copy_string(exten, p->exten, sizeof(exten));
551         len = strlen(exten);
552         res = 0;
553         while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
554                 if (len && !ast_ignore_pattern(chan->context, exten))
555                         sig_pri_play_tone(p, -1);
556                 else
557                         sig_pri_play_tone(p, SIG_PRI_TONE_DIALTONE);
558                 if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num))
559                         timeout = pri_matchdigittimeout;
560                 else
561                         timeout = pri_gendigittimeout;
562                 res = ast_waitfordigit(chan, timeout);
563                 if (res < 0) {
564                         ast_log(LOG_DEBUG, "waitfordigit returned < 0...\n");
565                         ast_hangup(chan);
566                         return NULL;
567                 } else if (res) {
568                         exten[len++] = res;
569                         exten[len] = '\0';
570                 } else
571                         goto exit;
572         }
573         /* if no extension was received ('unspecified') on overlap call, use the 's' extension */
574         if (ast_strlen_zero(exten)) {
575                 ast_verb(3, "Going to extension s|1 because of empty extension received on overlap call\n");
576                 exten[0] = 's';
577                 exten[1] = '\0';
578         }
579         sig_pri_play_tone(p, -1);
580         if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) {
581                 /* Start the real PBX */
582                 ast_copy_string(chan->exten, exten, sizeof(chan->exten));
583                 sig_pri_set_echocanceller(p, 1);
584                 ast_setstate(chan, AST_STATE_RING);
585                 res = ast_pbx_run(chan);
586                 if (res) {
587                         ast_log(LOG_WARNING, "PBX exited non-zero!\n");
588                 }
589         } else {
590                 ast_log(LOG_DEBUG, "No such possible extension '%s' in context '%s'\n", exten, chan->context);
591                 chan->hangupcause = AST_CAUSE_UNALLOCATED;
592                 ast_hangup(chan);
593                 p->exten[0] = '\0';
594                 /* Since we send release complete here, we won't get one */
595                 p->call = NULL;
596         }
597         return NULL;
598
599 exit:
600         res = sig_pri_play_tone(p, SIG_PRI_TONE_CONGESTION);
601         if (res < 0)
602                         ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel);
603         ast_hangup(chan);
604         return NULL;
605 }
606
607 void pri_event_alarm(struct sig_pri_pri *pri, int index, int before_start_pri)
608 {
609         pri->dchanavail[index] &= ~(DCHAN_NOTINALARM | DCHAN_UP);
610         if (!before_start_pri)
611                 pri_find_dchan(pri);
612 }
613
614 void pri_event_noalarm(struct sig_pri_pri *pri, int index, int before_start_pri)
615 {
616         pri->dchanavail[index] |= DCHAN_NOTINALARM;
617         if (!before_start_pri)
618                 pri_restart(pri->dchans[index]);
619 }
620
621 static void *pri_dchannel(void *vpri)
622 {
623         struct sig_pri_pri *pri = vpri;
624         pri_event *e;
625         struct pollfd fds[NUM_DCHANS];
626         int res;
627         int chanpos = 0;
628         int x;
629         struct ast_channel *c;
630         struct timeval tv, lowest, *next;
631         int doidling=0;
632         char *cc;
633         time_t t;
634         int i, which=-1;
635         int numdchans;
636         pthread_t threadid;
637         pthread_attr_t attr;
638         char ani2str[6];
639         char plancallingnum[256];
640         char plancallingani[256];
641         char calledtonstr[10];
642         struct timeval lastidle = { 0, 0 };
643         pthread_t p;
644         struct ast_channel *idle;
645         char idlen[80];
646         int nextidle = -1;
647         int haveidles;
648         int activeidles;
649         
650         gettimeofday(&lastidle, NULL);
651         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
652
653         if (!ast_strlen_zero(pri->idledial) && !ast_strlen_zero(pri->idleext)) {
654                 /* Need to do idle dialing, check to be sure though */
655                 cc = strchr(pri->idleext, '@');
656                 if (cc) {
657                         *cc = '\0';
658                         cc++;
659                         ast_copy_string(pri->idlecontext, cc, sizeof(pri->idlecontext));
660 #if 0
661                         /* Extensions may not be loaded yet */
662                         if (!ast_exists_extension(NULL, pri->idlecontext, pri->idleext, 1, NULL))
663                                 ast_log(LOG_WARNING, "Extension '%s @ %s' does not exist\n", pri->idleext, pri->idlecontext);
664                         else
665 #endif
666                                 doidling = 1;
667                 } else
668                         ast_log(LOG_WARNING, "Idle dial string '%s' lacks '@context'\n", pri->idleext);
669         }
670         for (;;) {
671                 for (i = 0; i < NUM_DCHANS; i++) {
672                         if (!pri->dchans[i])
673                                 break;
674                         fds[i].fd = pri->fds[i];
675                         fds[i].events = POLLIN | POLLPRI;
676                         fds[i].revents = 0;
677                 }
678                 numdchans = i;
679                 time(&t);
680                 ast_mutex_lock(&pri->lock);
681                 if (pri->switchtype != PRI_SWITCH_GR303_TMC && (pri->sig != SIG_BRI_PTMP) && (pri->resetinterval > 0)) {
682                         if (pri->resetting && pri_is_up(pri)) {
683                                 if (pri->resetpos < 0)
684                                         pri_check_restart(pri);
685                         } else {
686                                 if (!pri->resetting     && (t - pri->lastreset) >= pri->resetinterval) {
687                                         pri->resetting = 1;
688                                         pri->resetpos = -1;
689                                 }
690                         }
691                 }
692                 /* Look for any idle channels if appropriate */
693                 if (doidling && pri_is_up(pri)) {
694                         nextidle = -1;
695                         haveidles = 0;
696                         activeidles = 0;
697                         for (x = pri->numchans; x >= 0; x--) {
698                                 if (pri->pvts[x] && !pri->pvts[x]->owner && 
699                                     !pri->pvts[x]->call) {
700                                         if (haveidles < pri->minunused) {
701                                                 haveidles++;
702                                         } else if (!pri->pvts[x]->resetting) {
703                                                 nextidle = x;
704                                                 break;
705                                         }
706                                 } else if (pri->pvts[x] && pri->pvts[x]->owner && pri->pvts[x]->isidlecall)
707                                         activeidles++;
708                         }
709                         if (nextidle > -1) {
710                                 if (ast_tvdiff_ms(ast_tvnow(), lastidle) > 1000) {
711                                         /* Don't create a new idle call more than once per second */
712                                         snprintf(idlen, sizeof(idlen), "%d/%s", pri->pvts[nextidle]->channel, pri->idledial);
713                                         idle = sig_pri_request(pri->pvts[nextidle], AST_FORMAT_ULAW, NULL);
714                                         if (idle) {
715                                                 pri->pvts[nextidle]->isidlecall = 1;
716                                                 if (ast_pthread_create_background(&p, NULL, do_idle_thread, idle)) {
717                                                         ast_log(LOG_WARNING, "Unable to start new thread for idle channel '%s'\n", idle->name);
718                                                         ast_hangup(idle);
719                                                 }
720                                         } else
721                                                 ast_log(LOG_WARNING, "Unable to request channel 'DAHDI/%s' for idle call\n", idlen);
722                                         gettimeofday(&lastidle, NULL);
723                                 }
724                         } else if ((haveidles < pri->minunused) &&
725                                    (activeidles > pri->minidle)) {
726                                 /* Mark something for hangup if there is something 
727                                    that can be hungup */
728                                 for (x = pri->numchans; x >= 0; x--) {
729                                         /* find a candidate channel */
730                                         if (pri->pvts[x] && pri->pvts[x]->owner && pri->pvts[x]->isidlecall) {
731                                                 pri->pvts[x]->owner->_softhangup |= AST_SOFTHANGUP_DEV;
732                                                 haveidles++;
733                                                 /* Stop if we have enough idle channels or
734                                                   can't spare any more active idle ones */
735                                                 if ((haveidles >= pri->minunused) ||
736                                                     (activeidles <= pri->minidle))
737                                                         break;
738                                         } 
739                                 }
740                         }
741                 }
742                 /* Start with reasonable max */
743                 lowest = ast_tv(60, 0);
744                 for (i = 0; i < NUM_DCHANS; i++) {
745                         /* Find lowest available d-channel */
746                         if (!pri->dchans[i])
747                                 break;
748                         if ((next = pri_schedule_next(pri->dchans[i]))) {
749                                 /* We need relative time here */
750                                 tv = ast_tvsub(*next, ast_tvnow());
751                                 if (tv.tv_sec < 0) {
752                                         tv = ast_tv(0,0);
753                                 }
754                                 if (doidling || pri->resetting) {
755                                         if (tv.tv_sec > 1) {
756                                                 tv = ast_tv(1, 0);
757                                         }
758                                 } else {
759                                         if (tv.tv_sec > 60) {
760                                                 tv = ast_tv(60, 0);
761                                         }
762                                 }
763                         } else if (doidling || pri->resetting) {
764                                 /* Make sure we stop at least once per second if we're
765                                    monitoring idle channels */
766                                 tv = ast_tv(1,0);
767                         } else {
768                                 /* Don't poll for more than 60 seconds */
769                                 tv = ast_tv(60, 0);
770                         }
771                         if (!i || ast_tvcmp(tv, lowest) < 0) {
772                                 lowest = tv;
773                         }
774                 }
775                 ast_mutex_unlock(&pri->lock);
776
777                 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
778                 pthread_testcancel();
779                 e = NULL;
780                 res = poll(fds, numdchans, lowest.tv_sec * 1000 + lowest.tv_usec / 1000);
781                 pthread_testcancel();
782                 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
783
784                 ast_mutex_lock(&pri->lock);
785                 if (!res) {
786                         for (which = 0; which < NUM_DCHANS; which++) {
787                                 if (!pri->dchans[which])
788                                         break;
789                                 /* Just a timeout, run the scheduler */
790                                 e = pri_schedule_run(pri->dchans[which]);
791                                 if (e)
792                                         break;
793                         }
794                 } else if (res > -1) {
795                         for (which = 0; which < NUM_DCHANS; which++) {
796                                 if (!pri->dchans[which])
797                                         break;
798                                 if (fds[which].revents & POLLPRI) {
799                                         sig_pri_handle_dchan_exception(pri, which);
800                                 } else if (fds[which].revents & POLLIN) {
801                                         e = pri_check_event(pri->dchans[which]);
802                                 }
803                                 if (e)
804                                         break;
805                         }
806                 } else if (errno != EINTR)
807                         ast_log(LOG_WARNING, "pri_event returned error %d (%s)\n", errno, strerror(errno));
808
809                 if (e) {
810                         if (pri->debug)
811                                 pri_dump_event(pri->dchans[which], e);
812
813                         if (e->e != PRI_EVENT_DCHAN_DOWN) {
814                                 if (!(pri->dchanavail[which] & DCHAN_UP)) {
815                                                 ast_verb(2, "%s D-Channel on span %d up\n", pri_order(which), pri->span);
816                                 }
817                                 pri->dchanavail[which] |= DCHAN_UP;
818                         } else {
819                                 if (pri->dchanavail[which] & DCHAN_UP) {
820                                                 ast_verb(2, "%s D-Channel on span %d down\n", pri_order(which), pri->span);
821                                 }
822                                 pri->dchanavail[which] &= ~DCHAN_UP;
823                         }
824
825                         if ((e->e != PRI_EVENT_DCHAN_UP) && (e->e != PRI_EVENT_DCHAN_DOWN) && (pri->pri != pri->dchans[which]))
826                                 /* Must be an NFAS group that has the secondary dchan active */
827                                 pri->pri = pri->dchans[which];
828
829                         switch (e->e) {
830                         case PRI_EVENT_DCHAN_UP:
831                                 if (!pri->pri) pri_find_dchan(pri);
832
833                                 /* Note presense of D-channel */
834                                 time(&pri->lastreset);
835
836                                 /* Restart in 5 seconds */
837                                 if (pri->resetinterval > -1) {
838                                         pri->lastreset -= pri->resetinterval;
839                                         pri->lastreset += 5;
840                                 }
841                                 pri->resetting = 0;
842                                 /* Take the channels from inalarm condition */
843                                 for (i = 0; i < pri->numchans; i++)
844                                         if (pri->pvts[i]) {
845                                                 pri->pvts[i]->inalarm = 0;
846                                         }
847                                 break;
848                         case PRI_EVENT_DCHAN_DOWN:
849                                 pri_find_dchan(pri);
850                                 if (!pri_is_up(pri)) {
851                                         pri->resetting = 0;
852                                         /* Hangup active channels and put them in alarm mode */
853                                         for (i = 0; i < pri->numchans; i++) {
854                                                 struct sig_pri_chan *p = pri->pvts[i];
855                                                 if (p) {
856                                                         if (!p->pri || !p->pri->pri || pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0) {
857                                                                 /* T309 is not enabled : hangup calls when alarm occurs */
858                                                                 if (p->call) {
859                                                                         if (p->pri && p->pri->pri) {
860                                                                                 pri_hangup(p->pri->pri, p->call, -1);
861                                                                                 pri_destroycall(p->pri->pri, p->call);
862                                                                                 p->call = NULL;
863                                                                         } else
864                                                                                 ast_log(LOG_WARNING, "The PRI Call have not been destroyed\n");
865                                                                 }
866                                                                 if (p->owner)
867                                                                         ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
868                                                         }
869                                                         /* For PTMP connections with non persistent layer 2 we want
870                                                          * to *not* declare inalarm unless there actually is an alarm */
871                                                         if (p->pri->sig != SIG_BRI_PTMP) {
872                                                                 p->inalarm = 1;
873                                                         }
874                                                 }
875                                         }
876                                 }
877                                 break;
878                         case PRI_EVENT_RESTART:
879                                 if (e->restart.channel > -1) {
880                                         chanpos = pri_find_principle(pri, e->restart.channel);
881                                         if (chanpos < 0)
882                                                 ast_log(LOG_WARNING, "Restart requested on odd/unavailable channel number %d/%d on span %d\n", 
883                                                         PRI_SPAN(e->restart.channel), PRI_CHANNEL(e->restart.channel), pri->span);
884                                         else {
885 #ifdef HAVE_PRI_SERVICE_MESSAGES
886                                                 char db_chan_name[20], db_answer[5], state;
887                                                 int why, skipit = 0;
888                                                 
889                                                 ast_mutex_lock(&pri->pvts[chanpos]->service_lock);
890                                                 snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->pvts[chanpos]->pri->span, pri->pvts[chanpos]->channel);
891                                                 ast_mutex_unlock(&pri->pvts[chanpos]->service_lock);
892
893                                                 if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) {
894                                                         sscanf(db_answer, "%c:%d", &state, &why);
895                                                         if (why) {
896                                                                 ast_log(LOG_NOTICE, "span '%d' channel '%d' out-of-service (reason: %s), ignoring RESTART\n", pri->span,
897                                                                         e->restart.channel, (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end");
898                                                                 skipit = 1;
899                                                         } else {
900                                                                 ast_db_del(db_chan_name, SRVST_DBKEY);
901                                                         }
902                                                 }
903                                                 if (!skipit) {
904 #endif
905                                                         ast_verb(3, "B-channel %d/%d restarted on span %d\n", 
906                                                                         PRI_SPAN(e->restart.channel), PRI_CHANNEL(e->restart.channel), pri->span);
907                                                         sig_pri_lock_private(pri->pvts[chanpos]);
908                                                         if (pri->pvts[chanpos]->call) {
909                                                                 pri_destroycall(pri->pri, pri->pvts[chanpos]->call);
910                                                                 pri->pvts[chanpos]->call = NULL;
911                                                         }
912 #ifdef HAVE_PRI_SERVICE_MESSAGES
913                                                 }
914 #endif
915                                                 /* Force soft hangup if appropriate */
916                                                 if (pri->pvts[chanpos]->owner)
917                                                         ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV);
918                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
919                                         }
920                                 } else {
921                                         ast_verb(3, "Restart on requested on entire span %d\n", pri->span);
922                                         for (x = 0; x < pri->numchans; x++)
923                                                 if (pri->pvts[x]) {
924                                                         sig_pri_lock_private(pri->pvts[x]);
925                                                         if (pri->pvts[x]->call) {
926                                                                 pri_destroycall(pri->pri, pri->pvts[x]->call);
927                                                                 pri->pvts[x]->call = NULL;
928                                                         }
929                                                         if (pri->pvts[x]->owner)
930                                                                 ast_softhangup_nolock(pri->pvts[x]->owner, AST_SOFTHANGUP_DEV);
931                                                         sig_pri_unlock_private(pri->pvts[x]);
932                                                 }
933                                 }
934                                 break;
935                         case PRI_EVENT_KEYPAD_DIGIT:
936                                 chanpos = pri_find_principle(pri, e->digit.channel);
937                                 if (chanpos < 0) {
938                                         ast_log(LOG_WARNING, "KEYPAD_DIGITs received on unconfigured channel %d/%d span %d\n", 
939                                                 PRI_SPAN(e->digit.channel), PRI_CHANNEL(e->digit.channel), pri->span);
940                                 } else {
941                                         chanpos = pri_fixup_principle(pri, chanpos, e->digit.call);
942                                         if (chanpos > -1) {
943                                                 sig_pri_lock_private(pri->pvts[chanpos]);
944                                                 /* queue DTMF frame if the PBX for this call was already started (we're forwarding KEYPAD_DIGITs further on */
945                                                 if ((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) && pri->pvts[chanpos]->call==e->digit.call && pri->pvts[chanpos]->owner) {
946                                                         /* how to do that */
947                                                         int digitlen = strlen(e->digit.digits);
948                                                         char digit;
949                                                         int i;                                  
950                                                         for (i = 0; i < digitlen; i++) {        
951                                                                 digit = e->digit.digits[i];
952                                                                 {
953                                                                         struct ast_frame f = { AST_FRAME_DTMF, digit, };
954                                                                         pri_queue_frame(pri->pvts[chanpos], &f, pri);
955                                                                 }
956                                                         }
957                                                 }
958                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
959                                         }
960                                 }
961                                 break;
962                                 
963                         case PRI_EVENT_INFO_RECEIVED:
964                                 chanpos = pri_find_principle(pri, e->ring.channel);
965                                 if (chanpos < 0) {
966                                         ast_log(LOG_WARNING, "INFO received on unconfigured channel %d/%d span %d\n", 
967                                                 PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span);
968                                 } else {
969                                         chanpos = pri_fixup_principle(pri, chanpos, e->ring.call);
970                                         if (chanpos > -1) {
971                                                 sig_pri_lock_private(pri->pvts[chanpos]);
972                                                 /* queue DTMF frame if the PBX for this call was already started (we're forwarding INFORMATION further on */
973                                                 if ((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) && pri->pvts[chanpos]->call==e->ring.call && pri->pvts[chanpos]->owner) {
974                                                         /* how to do that */
975                                                         int digitlen = strlen(e->ring.callednum);
976                                                         char digit;
977                                                         int i;                                  
978                                                         for (i = 0; i < digitlen; i++) {        
979                                                                 digit = e->ring.callednum[i];
980                                                                 {
981                                                                         struct ast_frame f = { AST_FRAME_DTMF, digit, };
982                                                                         pri_queue_frame(pri->pvts[chanpos], &f, pri);
983                                                                 }
984                                                         }
985                                                 }
986                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
987                                         }
988                                 }
989                                 break;
990 #ifdef HAVE_PRI_SERVICE_MESSAGES
991                         case PRI_EVENT_SERVICE:
992                                 chanpos = pri_find_principle(pri, e->service.channel);
993                                 if (chanpos < 0) {
994                                         ast_log(LOG_WARNING, "Received service change status %d on unconfigured channel %d/%d span %d\n",
995                                                 e->service_ack.changestatus, PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span);
996                                 } else {
997                                         char db_chan_name[20], db_answer[5], state;
998                                         int ch, why = -1;
999
1000                                         ast_mutex_lock(&pri->pvts[chanpos]->service_lock);
1001                                         ch = pri->pvts[chanpos]->channel;
1002                                         ast_mutex_unlock(&pri->pvts[chanpos]->service_lock);
1003                                         
1004                                         snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->pvts[chanpos]->pri->span, ch);
1005                                         if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) {
1006                                                 sscanf(db_answer, "%c:%d", &state, &why);
1007                                                 ast_db_del(db_chan_name, SRVST_DBKEY);
1008                                         }
1009                                         switch (e->service.changestatus) {
1010                                         case 0: /* in-service */
1011                                                 if (why > -1) {
1012                                                         if (why & SRVST_NEAREND) {
1013                                                                 snprintf(db_answer, sizeof(db_answer), "%s:%d", SRVST_TYPE_OOS, SRVST_NEAREND);
1014                                                                 ast_db_put(db_chan_name, SRVST_DBKEY, db_answer);
1015                                                                 ast_debug(2, "channel '%d' service state { near: out-of-service,  far: in-service }\n", ch);
1016                                                         }
1017                                                 }
1018                                                 break;
1019                                         case 2: /* out-of-service */
1020                                                 if (why == -1) {
1021                                                         why = SRVST_FAREND;
1022                                                 } else {
1023                                                         why |= SRVST_FAREND;
1024                                                 }
1025                                                 snprintf(db_answer, sizeof(db_answer), "%s:%d", SRVST_TYPE_OOS, why);
1026                                                 ast_db_put(db_chan_name, SRVST_DBKEY, db_answer);
1027                                                 break;
1028                                         default:
1029                                                 ast_log(LOG_ERROR, "Huh?  changestatus is: %d\n", e->service.changestatus);
1030                                         }
1031                                         ast_log(LOG_NOTICE, "Channel %d/%d span %d (logical: %d) received a change of service message, status '%d'\n",
1032                                                 PRI_SPAN(e->service.channel), PRI_CHANNEL(e->service.channel), pri->span, ch, e->service.changestatus);
1033                                 }
1034                                 break;
1035                         case PRI_EVENT_SERVICE_ACK:
1036                                 chanpos = pri_find_principle(pri, e->service_ack.channel);
1037                                 if (chanpos < 0) {
1038                                         ast_log(LOG_WARNING, "Received service acknowledge change status '%d' on unconfigured channel %d/%d span %d\n",
1039                                                 e->service_ack.changestatus, PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span);
1040                                 } else {
1041                                         ast_debug(2, "Channel %d/%d span %d received a change os service acknowledgement message, status '%d'\n",
1042                                                 PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span, e->service_ack.changestatus);
1043                                 }
1044                                 break;
1045 #endif
1046                         case PRI_EVENT_RING:
1047                                 if (e->ring.channel == -1)
1048                                         chanpos = pri_find_empty_chan(pri, 1);
1049                                 else
1050                                         chanpos = pri_find_principle(pri, e->ring.channel);
1051                                 /* if no channel specified find one empty */
1052                                 if (chanpos < 0) {
1053                                         ast_log(LOG_WARNING, "Ring requested on unconfigured channel %d/%d span %d\n", 
1054                                                 PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span);
1055                                 } else {
1056                                         sig_pri_lock_private(pri->pvts[chanpos]);
1057                                         if (pri->pvts[chanpos]->owner) {
1058                                                 if (pri->pvts[chanpos]->call == e->ring.call) {
1059                                                         ast_log(LOG_WARNING, "Duplicate setup requested on channel %d/%d already in use on span %d\n", 
1060                                                                 PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span);
1061                                                         break;
1062                                                 } else {
1063                                                         /* This is where we handle initial glare */
1064                                                         ast_debug(1, "Ring requested on channel %d/%d already in use or previously requested on span %d.  Attempting to renegotiating channel.\n", 
1065                                                         PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span);
1066                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1067                                                         chanpos = -1;
1068                                                 }
1069                                         }
1070                                         if (chanpos > -1)
1071                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1072                                 }
1073                                 if ((chanpos < 0) && (e->ring.flexible))
1074                                         chanpos = pri_find_empty_chan(pri, 1);
1075                                 if (chanpos > -1) {
1076                                         sig_pri_lock_private(pri->pvts[chanpos]);
1077                                         pri->pvts[chanpos]->call = e->ring.call;
1078                                         apply_plan_to_number(plancallingnum, sizeof(plancallingnum), pri, e->ring.callingnum, e->ring.callingplan);
1079                                         if (pri->pvts[chanpos]->use_callerid) {
1080                                                 ast_shrink_phone_number(plancallingnum);
1081                                                 ast_copy_string(pri->pvts[chanpos]->cid_num, plancallingnum, sizeof(pri->pvts[chanpos]->cid_num));
1082 #ifdef PRI_ANI
1083                                                 if (!ast_strlen_zero(e->ring.callingani)) {
1084                                                         apply_plan_to_number(plancallingani, sizeof(plancallingani), pri, e->ring.callingani, e->ring.callingplanani);
1085                                                         ast_shrink_phone_number(plancallingani);
1086                                                         ast_copy_string(pri->pvts[chanpos]->cid_ani, plancallingani, sizeof(pri->pvts[chanpos]->cid_ani));
1087                                                 } else {
1088                                                         pri->pvts[chanpos]->cid_ani[0] = '\0';
1089                                                 }
1090 #endif
1091                                                 ast_copy_string(pri->pvts[chanpos]->cid_name, e->ring.callingname, sizeof(pri->pvts[chanpos]->cid_name));
1092                                                 pri->pvts[chanpos]->cid_ton = e->ring.callingplan; /* this is the callingplan (TON/NPI), e->ring.callingplan>>4 would be the TON */
1093                                         } else {
1094                                                 pri->pvts[chanpos]->cid_num[0] = '\0';
1095                                                 pri->pvts[chanpos]->cid_ani[0] = '\0';
1096                                                 pri->pvts[chanpos]->cid_name[0] = '\0';
1097                                                 pri->pvts[chanpos]->cid_ton = 0;
1098                                         }
1099                                         apply_plan_to_number(pri->pvts[chanpos]->rdnis, sizeof(pri->pvts[chanpos]->rdnis), pri,
1100                                                              e->ring.redirectingnum, e->ring.callingplanrdnis);
1101                                         /* If immediate=yes go to s|1 */
1102                                         if (pri->pvts[chanpos]->immediate) {
1103                                                 ast_verb(3, "Going to extension s|1 because of immediate=yes\n");
1104                                                 pri->pvts[chanpos]->exten[0] = 's';
1105                                                 pri->pvts[chanpos]->exten[1] = '\0';
1106                                         }
1107                                         /* Get called number */
1108                                         else if (!ast_strlen_zero(e->ring.callednum)) {
1109                                                 ast_copy_string(pri->pvts[chanpos]->exten, e->ring.callednum, sizeof(pri->pvts[chanpos]->exten));
1110                                                 ast_copy_string(pri->pvts[chanpos]->dnid, e->ring.callednum, sizeof(pri->pvts[chanpos]->dnid));
1111                                         } else if (pri->overlapdial)
1112                                                 pri->pvts[chanpos]->exten[0] = '\0';
1113                                         else {
1114                                                 /* Some PRI circuits are set up to send _no_ digits.  Handle them as 's'. */
1115                                                 pri->pvts[chanpos]->exten[0] = 's';
1116                                                 pri->pvts[chanpos]->exten[1] = '\0';
1117                                         }
1118                                         /* Set DNID on all incoming calls -- even immediate */
1119                                         if (!ast_strlen_zero(e->ring.callednum))
1120                                                 ast_copy_string(pri->pvts[chanpos]->dnid, e->ring.callednum, sizeof(pri->pvts[chanpos]->dnid));
1121                                         /* No number yet, but received "sending complete"? */
1122                                         if (e->ring.complete && (ast_strlen_zero(e->ring.callednum))) {
1123                                                 ast_verb(3, "Going to extension s|1 because of Complete received\n");
1124                                                 pri->pvts[chanpos]->exten[0] = 's';
1125                                                 pri->pvts[chanpos]->exten[1] = '\0';
1126                                         }
1127                                         /* Make sure extension exists (or in overlap dial mode, can exist) */
1128                                         if (((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) && ast_canmatch_extension(NULL, pri->pvts[chanpos]->context, pri->pvts[chanpos]->exten, 1, pri->pvts[chanpos]->cid_num)) ||
1129                                                 ast_exists_extension(NULL, pri->pvts[chanpos]->context, pri->pvts[chanpos]->exten, 1, pri->pvts[chanpos]->cid_num)) {
1130                                                 /* Setup law */
1131                                                 if (e->ring.complete || !(pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)) {
1132                                                         /* Just announce proceeding */
1133                                                         pri->pvts[chanpos]->proceeding = 1;
1134                                                         pri_proceeding(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 0);
1135                                                 } else {
1136                                                         if (pri->switchtype != PRI_SWITCH_GR303_TMC) 
1137                                                                 pri_need_more_info(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 1);
1138                                                         else
1139                                                                 pri_answer(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 1);
1140                                                 }
1141                                                 /* Get the use_callingpres state */
1142                                                 pri->pvts[chanpos]->callingpres = e->ring.callingpres;
1143                                         
1144                                                 /* Start PBX */
1145                                                 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)) {
1146                                                         /* Release the PRI lock while we create the channel */
1147                                                         ast_mutex_unlock(&pri->lock);
1148
1149                                                         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, NULL);
1150
1151                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1152
1153                                                         if (!ast_strlen_zero(e->ring.callingsubaddr)) {
1154                                                                 pbx_builtin_setvar_helper(c, "CALLINGSUBADDR", e->ring.callingsubaddr);
1155                                                         }
1156                                                         if (e->ring.ani2 >= 0) {
1157                                                                 snprintf(ani2str, 5, "%.2d", e->ring.ani2);
1158                                                                 pbx_builtin_setvar_helper(c, "ANI2", ani2str);
1159                                                                 pri->pvts[chanpos]->cid_ani2 = e->ring.ani2;
1160                                                         }
1161
1162 #ifdef SUPPORT_USERUSER
1163                                                         if (!ast_strlen_zero(e->ring.useruserinfo)) {
1164                                                                 pbx_builtin_setvar_helper(c, "USERUSERINFO", e->ring.useruserinfo);
1165                                                         }
1166 #endif
1167
1168                                                         snprintf(calledtonstr, sizeof(calledtonstr)-1, "%d", e->ring.calledplan);
1169                                                         pbx_builtin_setvar_helper(c, "CALLEDTON", calledtonstr);
1170                                                         if (e->ring.redirectingreason >= 0)
1171                                                                 pbx_builtin_setvar_helper(c, "PRIREDIRECTREASON", redirectingreason2str(e->ring.redirectingreason));
1172 #if defined(HAVE_PRI_REVERSE_CHARGE)
1173                                                         pri->pvts[chanpos]->reverse_charging_indication = e->ring.reversecharge;
1174 #endif
1175
1176                                                         sig_pri_lock_private(pri->pvts[chanpos]);
1177                                                         ast_mutex_lock(&pri->lock);
1178
1179                                                         pthread_attr_init(&attr);
1180                                                         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
1181                                                         if (c && !ast_pthread_create(&threadid, &attr, pri_ss_thread, pri->pvts[chanpos])) {
1182                                                                 ast_verb(3, "Accepting overlap call from '%s' to '%s' on channel %d/%d, span %d\n",
1183                                                                                 plancallingnum, S_OR(pri->pvts[chanpos]->exten, "<unspecified>"),
1184                                                                                 pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span);
1185                                                         } else {
1186                                                                 ast_log(LOG_WARNING, "Unable to start PBX on channel %d/%d, span %d\n", 
1187                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span);
1188                                                                 if (c)
1189                                                                         ast_hangup(c);
1190                                                                 else {
1191                                                                         pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_SWITCH_CONGESTION);
1192                                                                         pri->pvts[chanpos]->call = NULL;
1193                                                                 }
1194                                                         }
1195                                                         pthread_attr_destroy(&attr);
1196                                                 } else  {
1197                                                         ast_mutex_unlock(&pri->lock);
1198                                                         /* Release PRI lock while we create the channel */
1199                                                         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, NULL);
1200                                                 
1201                                                         if (c) {
1202                                                                 char calledtonstr[10];
1203
1204                                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1205
1206                                                                 if (e->ring.ani2 >= 0) {
1207                                                                         snprintf(ani2str, 5, "%d", e->ring.ani2);
1208                                                                         pbx_builtin_setvar_helper(c, "ANI2", ani2str);
1209                                                                         pri->pvts[chanpos]->cid_ani2 = e->ring.ani2;
1210                                                                 }
1211
1212 #ifdef SUPPORT_USERUSER
1213                                                                 if (!ast_strlen_zero(e->ring.useruserinfo)) {
1214                                                                         pbx_builtin_setvar_helper(c, "USERUSERINFO", e->ring.useruserinfo);
1215                                                                 }
1216 #endif
1217
1218                                                                 if (e->ring.redirectingreason >= 0)
1219                                                                         pbx_builtin_setvar_helper(c, "PRIREDIRECTREASON", redirectingreason2str(e->ring.redirectingreason));
1220 #if defined(HAVE_PRI_REVERSE_CHARGE)
1221                                                                 pri->pvts[chanpos]->reverse_charging_indication = e->ring.reversecharge;
1222 #endif
1223
1224                                                                 snprintf(calledtonstr, sizeof(calledtonstr)-1, "%d", e->ring.calledplan);
1225                                                                 pbx_builtin_setvar_helper(c, "CALLEDTON", calledtonstr);
1226
1227                                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1228                                                                 ast_mutex_lock(&pri->lock);
1229
1230                                                                 ast_verb(3, "Accepting call from '%s' to '%s' on channel %d/%d, span %d\n",
1231                                                                                 plancallingnum, pri->pvts[chanpos]->exten, 
1232                                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span);
1233                                                                 sig_pri_set_echocanceller(pri->pvts[chanpos], 1);
1234                                                         } else {
1235
1236                                                                 ast_mutex_lock(&pri->lock);
1237
1238                                                                 ast_log(LOG_WARNING, "Unable to start PBX on channel %d/%d, span %d\n",
1239                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span);
1240                                                                 pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_SWITCH_CONGESTION);
1241                                                                 pri->pvts[chanpos]->call = NULL;
1242                                                         }
1243                                                 }
1244                                         } else {
1245                                                 ast_verb(3, "Extension '%s' in context '%s' from '%s' does not exist.  Rejecting call on channel %d/%d, span %d\n",
1246                                                                 pri->pvts[chanpos]->exten, pri->pvts[chanpos]->context, pri->pvts[chanpos]->cid_num, pri->pvts[chanpos]->logicalspan, 
1247                                                                         pri->pvts[chanpos]->prioffset, pri->span);
1248                                                 pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_UNALLOCATED);
1249                                                 pri->pvts[chanpos]->call = NULL;
1250                                                 pri->pvts[chanpos]->exten[0] = '\0';
1251                                         }
1252                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1253                                 } else {
1254                                         if (e->ring.flexible)
1255                                                 pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION);
1256                                         else
1257                                                 pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_REQUESTED_CHAN_UNAVAIL);
1258                                 }
1259                                 break;
1260                         case PRI_EVENT_RINGING:
1261                                 chanpos = pri_find_principle(pri, e->ringing.channel);
1262                                 if (chanpos < 0) {
1263                                         ast_log(LOG_WARNING, "Ringing requested on unconfigured channel %d/%d span %d\n", 
1264                                                 PRI_SPAN(e->ringing.channel), PRI_CHANNEL(e->ringing.channel), pri->span);
1265                                 } else {
1266                                         chanpos = pri_fixup_principle(pri, chanpos, e->ringing.call);
1267                                         if (chanpos < 0) {
1268                                                 ast_log(LOG_WARNING, "Ringing requested on channel %d/%d not in use on span %d\n", 
1269                                                         PRI_SPAN(e->ringing.channel), PRI_CHANNEL(e->ringing.channel), pri->span);
1270                                         } else {
1271                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1272                                                 sig_pri_set_echocanceller(pri->pvts[chanpos], 1);
1273                                                 pri_queue_control(pri->pvts[chanpos], AST_CONTROL_RINGING, pri);
1274                                                 pri->pvts[chanpos]->alerting = 1;
1275 #ifdef PRI_PROGRESS_MASK
1276                                                 if (e->ringing.progressmask & PRI_PROG_INBAND_AVAILABLE) {
1277 #else
1278                                                 if (e->ringing.progress == 8) {
1279 #endif
1280                                                 }
1281
1282 #ifdef SUPPORT_USERUSER
1283                                                 if (!ast_strlen_zero(e->ringing.useruserinfo)) {
1284                                                         struct ast_channel *owner = pri->pvts[chanpos]->owner;
1285                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1286                                                         pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->ringing.useruserinfo);
1287                                                         sig_pri_lock_private(pri->pvts[chanpos]);
1288                                                 }
1289 #endif
1290
1291                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1292                                         }
1293                                 }
1294                                 break;
1295                         case PRI_EVENT_PROGRESS:
1296                                 /* Get chan value if e->e is not PRI_EVNT_RINGING */
1297                                 chanpos = pri_find_principle(pri, e->proceeding.channel);
1298                                 if (chanpos > -1) {
1299 #ifdef PRI_PROGRESS_MASK
1300                                         if ((!pri->pvts[chanpos]->progress) || (e->proceeding.progressmask & PRI_PROG_INBAND_AVAILABLE)) {
1301 #else
1302                                         if ((!pri->pvts[chanpos]->progress) || (e->proceeding.progress == 8)) {
1303 #endif
1304                                                 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_PROGRESS, };
1305
1306                                                 if (e->proceeding.cause > -1) {
1307                                                         ast_verb(3, "PROGRESS with cause code %d received\n", e->proceeding.cause);
1308
1309                                                         /* Work around broken, out of spec USER_BUSY cause in a progress message */
1310                                                         if (e->proceeding.cause == AST_CAUSE_USER_BUSY) {
1311                                                                 if (pri->pvts[chanpos]->owner) {
1312                                                                         ast_verb(3, "PROGRESS with 'user busy' received, signaling AST_CONTROL_BUSY instead of AST_CONTROL_PROGRESS\n");
1313
1314                                                                         pri->pvts[chanpos]->owner->hangupcause = e->proceeding.cause;
1315                                                                         f.subclass = AST_CONTROL_BUSY;
1316                                                                 }
1317                                                         }
1318                                                 }
1319                                                 
1320                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1321                                                 ast_log(LOG_DEBUG, "Queuing frame from PRI_EVENT_PROGRESS on channel %d/%d span %d\n",
1322                                                                 pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset,pri->span);
1323                                                 pri_queue_frame(pri->pvts[chanpos], &f, pri);
1324 #ifdef PRI_PROGRESS_MASK
1325                                                 if (e->proceeding.progressmask & PRI_PROG_INBAND_AVAILABLE) {
1326 #else
1327                                                 if (e->proceeding.progress == 8) {
1328 #endif
1329                                                         /* Bring voice path up */
1330                                                         f.subclass = AST_CONTROL_PROGRESS;
1331                                                         pri_queue_frame(pri->pvts[chanpos], &f, pri);
1332                                                 }
1333                                                 pri->pvts[chanpos]->progress = 1;
1334                                                 sig_pri_set_dialing(pri->pvts[chanpos], 0);
1335                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1336                                         }
1337                                 }
1338                                 break;
1339                         case PRI_EVENT_PROCEEDING:
1340                                 chanpos = pri_find_principle(pri, e->proceeding.channel);
1341                                 if (chanpos > -1) {
1342                                         if (!pri->pvts[chanpos]->proceeding) {
1343                                                 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_PROCEEDING, };
1344                                                 
1345                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1346                                                 ast_log(LOG_DEBUG, "Queuing frame from PRI_EVENT_PROCEEDING on channel %d/%d span %d\n",
1347                                                                 pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset,pri->span);
1348                                                 pri_queue_frame(pri->pvts[chanpos], &f, pri);
1349 #ifdef PRI_PROGRESS_MASK
1350                                                 if (e->proceeding.progressmask & PRI_PROG_INBAND_AVAILABLE) {
1351 #else
1352                                                 if (e->proceeding.progress == 8) {
1353 #endif
1354                                                         /* Bring voice path up */
1355                                                         f.subclass = AST_CONTROL_PROGRESS;
1356                                                         pri_queue_frame(pri->pvts[chanpos], &f, pri);
1357                                                 }
1358                                                 pri->pvts[chanpos]->proceeding = 1;
1359                                                 sig_pri_set_dialing(pri->pvts[chanpos], 0);
1360                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1361                                         }
1362                                 }
1363                                 break;
1364                         case PRI_EVENT_FACNAME:
1365                                 chanpos = pri_find_principle(pri, e->facname.channel);
1366                                 if (chanpos < 0) {
1367                                         ast_log(LOG_WARNING, "Facility Name requested on unconfigured channel %d/%d span %d\n", 
1368                                                 PRI_SPAN(e->facname.channel), PRI_CHANNEL(e->facname.channel), pri->span);
1369                                 } else {
1370                                         chanpos = pri_fixup_principle(pri, chanpos, e->facname.call);
1371                                         if (chanpos < 0) {
1372                                                 ast_log(LOG_WARNING, "Facility Name requested on channel %d/%d not in use on span %d\n", 
1373                                                         PRI_SPAN(e->facname.channel), PRI_CHANNEL(e->facname.channel), pri->span);
1374                                         } else {
1375                                                 /* Re-use *69 field for PRI */
1376                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1377                                                 ast_copy_string(pri->pvts[chanpos]->lastcid_num, e->facname.callingnum, sizeof(pri->pvts[chanpos]->lastcid_num));
1378                                                 ast_copy_string(pri->pvts[chanpos]->lastcid_name, e->facname.callingname, sizeof(pri->pvts[chanpos]->lastcid_name));
1379                                                 pri_update_cid(pri->pvts[chanpos], pri);
1380                                                 sig_pri_set_echocanceller(pri->pvts[chanpos], 1);
1381                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1382                                         }
1383                                 }
1384                                 break;                          
1385                         case PRI_EVENT_ANSWER:
1386                                 chanpos = pri_find_principle(pri, e->answer.channel);
1387                                 if (chanpos < 0) {
1388                                         ast_log(LOG_WARNING, "Answer on unconfigured channel %d/%d span %d\n", 
1389                                                 PRI_SPAN(e->answer.channel), PRI_CHANNEL(e->answer.channel), pri->span);
1390                                 } else {
1391                                         chanpos = pri_fixup_principle(pri, chanpos, e->answer.call);
1392                                         if (chanpos < 0) {
1393                                                 ast_log(LOG_WARNING, "Answer requested on channel %d/%d not in use on span %d\n", 
1394                                                         PRI_SPAN(e->answer.channel), PRI_CHANNEL(e->answer.channel), pri->span);
1395                                         } else {
1396                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1397                                                 pri_queue_control(pri->pvts[chanpos], AST_CONTROL_ANSWER, pri);
1398                                                 /* Enable echo cancellation if it's not on already */
1399                                                 sig_pri_set_dialing(pri->pvts[chanpos], 0);
1400                                                 sig_pri_set_echocanceller(pri->pvts[chanpos], 1);
1401
1402 #ifdef SUPPORT_USERUSER
1403                                                 if (!ast_strlen_zero(e->answer.useruserinfo)) {
1404                                                         struct ast_channel *owner = pri->pvts[chanpos]->owner;
1405                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1406                                                         pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->answer.useruserinfo);
1407                                                         sig_pri_lock_private(pri->pvts[chanpos]);
1408                                                 }
1409 #endif
1410
1411                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1412                                         }
1413                                 }
1414                                 break;                          
1415                         case PRI_EVENT_HANGUP:
1416                                 chanpos = pri_find_principle(pri, e->hangup.channel);
1417                                 if (chanpos < 0) {
1418                                         ast_log(LOG_WARNING, "Hangup requested on unconfigured channel %d/%d span %d\n", 
1419                                                 PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span);
1420                                 } else {
1421                                         chanpos = pri_fixup_principle(pri, chanpos, e->hangup.call);
1422                                         if (chanpos > -1) {
1423                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1424                                                 if (!pri->pvts[chanpos]->alreadyhungup) {
1425                                                         /* we're calling here dahdi_hangup so once we get there we need to clear p->call after calling pri_hangup */
1426                                                         pri->pvts[chanpos]->alreadyhungup = 1;
1427                                                         if (pri->pvts[chanpos]->owner) {
1428                                                                 /* Queue a BUSY instead of a hangup if our cause is appropriate */
1429                                                                 pri->pvts[chanpos]->owner->hangupcause = e->hangup.cause;
1430                                                                 if (pri->pvts[chanpos]->owner->_state == AST_STATE_UP)
1431                                                                         ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV);
1432                                                                 else {
1433                                                                         switch (e->hangup.cause) {
1434                                                                                 case PRI_CAUSE_USER_BUSY:
1435                                                                                         pri_queue_control(pri->pvts[chanpos], AST_CONTROL_BUSY, pri);
1436                                                                                         break;
1437                                                                                 case PRI_CAUSE_CALL_REJECTED:
1438                                                                                 case PRI_CAUSE_NETWORK_OUT_OF_ORDER:
1439                                                                                 case PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION:
1440                                                                                 case PRI_CAUSE_SWITCH_CONGESTION:
1441                                                                                 case PRI_CAUSE_DESTINATION_OUT_OF_ORDER:
1442                                                                                 case PRI_CAUSE_NORMAL_TEMPORARY_FAILURE:
1443                                                                                         pri_queue_control(pri->pvts[chanpos], AST_CONTROL_CONGESTION, pri);
1444                                                                                         break;
1445                                                                                 default:
1446                                                                                         ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV);
1447                                                                         }
1448                                                                 }
1449                                                         }
1450                                                         ast_verb(3, "Channel %d/%d, span %d got hangup, cause %d\n", 
1451                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span, e->hangup.cause);
1452                                                 } else {
1453                                                         pri_hangup(pri->pri, pri->pvts[chanpos]->call, e->hangup.cause);
1454                                                         pri->pvts[chanpos]->call = NULL;
1455                                                 }
1456                                                 if (e->hangup.cause == PRI_CAUSE_REQUESTED_CHAN_UNAVAIL) {
1457                                                         ast_verb(3, "Forcing restart of channel %d/%d on span %d since channel reported in use\n", 
1458                                                                         PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span);
1459                                                         pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[chanpos]));
1460                                                         pri->pvts[chanpos]->resetting = 1;
1461                                                 }
1462                                                 if (e->hangup.aoc_units > -1)
1463                                                         ast_verb(3, "Channel %d/%d, span %d received AOC-E charging %d unit%s\n",
1464                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span, (int)e->hangup.aoc_units, (e->hangup.aoc_units == 1) ? "" : "s");
1465
1466 #ifdef SUPPORT_USERUSER
1467                                                 if (pri->pvts[chanpos]->owner && !ast_strlen_zero(e->hangup.useruserinfo)) {
1468                                                         struct ast_channel *owner = pri->pvts[chanpos]->owner;
1469                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1470                                                         pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->hangup.useruserinfo);
1471                                                         sig_pri_lock_private(pri->pvts[chanpos]);
1472                                                 }
1473 #endif
1474
1475                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1476                                         } else {
1477                                                 ast_log(LOG_WARNING, "Hangup on bad channel %d/%d on span %d\n", 
1478                                                         PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span);
1479                                         }
1480                                 } 
1481                                 break;
1482 #ifndef PRI_EVENT_HANGUP_REQ
1483 #error please update libpri
1484 #endif
1485                         case PRI_EVENT_HANGUP_REQ:
1486                                 chanpos = pri_find_principle(pri, e->hangup.channel);
1487                                 if (chanpos < 0) {
1488                                         ast_log(LOG_WARNING, "Hangup REQ requested on unconfigured channel %d/%d span %d\n", 
1489                                                 PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span);
1490                                 } else {
1491                                         chanpos = pri_fixup_principle(pri, chanpos, e->hangup.call);
1492                                         if (chanpos > -1) {
1493                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1494                                                 if (pri->pvts[chanpos]->owner) {
1495                                                         pri->pvts[chanpos]->owner->hangupcause = e->hangup.cause;
1496                                                         if (pri->pvts[chanpos]->owner->_state == AST_STATE_UP)
1497                                                                 ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV);
1498                                                         else {
1499                                                                 switch (e->hangup.cause) {
1500                                                                         case PRI_CAUSE_USER_BUSY:
1501                                                                                 pri_queue_control(pri->pvts[chanpos], AST_CONTROL_BUSY, pri);
1502                                                                                 break;
1503                                                                         case PRI_CAUSE_CALL_REJECTED:
1504                                                                         case PRI_CAUSE_NETWORK_OUT_OF_ORDER:
1505                                                                         case PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION:
1506                                                                         case PRI_CAUSE_SWITCH_CONGESTION:
1507                                                                         case PRI_CAUSE_DESTINATION_OUT_OF_ORDER:
1508                                                                         case PRI_CAUSE_NORMAL_TEMPORARY_FAILURE:
1509                                                                                 pri_queue_control(pri->pvts[chanpos], AST_CONTROL_CONGESTION, pri);
1510                                                                                 break;
1511                                                                         default:
1512                                                                                 ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV);
1513                                                                 }
1514                                                         }
1515                                                         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);
1516                                                         if (e->hangup.aoc_units > -1)
1517                                                                 ast_verb(3, "Channel %d/%d, span %d received AOC-E charging %d unit%s\n",
1518                                                                                 pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span, (int)e->hangup.aoc_units, (e->hangup.aoc_units == 1) ? "" : "s");
1519                                                 } else {
1520                                                         pri_hangup(pri->pri, pri->pvts[chanpos]->call, e->hangup.cause);
1521                                                         pri->pvts[chanpos]->call = NULL;
1522                                                 }
1523                                                 if (e->hangup.cause == PRI_CAUSE_REQUESTED_CHAN_UNAVAIL) {
1524                                                         ast_verb(3, "Forcing restart of channel %d/%d span %d since channel reported in use\n", 
1525                                                                         PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span);
1526                                                         pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[chanpos]));
1527                                                         pri->pvts[chanpos]->resetting = 1;
1528                                                 }
1529
1530 #ifdef SUPPORT_USERUSER
1531                                                 if (!ast_strlen_zero(e->hangup.useruserinfo)) {
1532                                                         struct ast_channel *owner = pri->pvts[chanpos]->owner;
1533                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1534                                                         pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->hangup.useruserinfo);
1535                                                         sig_pri_lock_private(pri->pvts[chanpos]);
1536                                                 }
1537 #endif
1538
1539                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1540                                         } else {
1541                                                 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);
1542                                         }
1543                                 } 
1544                                 break;
1545                         case PRI_EVENT_HANGUP_ACK:
1546                                 chanpos = pri_find_principle(pri, e->hangup.channel);
1547                                 if (chanpos < 0) {
1548                                         ast_log(LOG_WARNING, "Hangup ACK requested on unconfigured channel number %d/%d span %d\n", 
1549                                                 PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span);
1550                                 } else {
1551                                         chanpos = pri_fixup_principle(pri, chanpos, e->hangup.call);
1552                                         if (chanpos > -1) {
1553                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1554                                                 pri->pvts[chanpos]->call = NULL;
1555                                                 pri->pvts[chanpos]->resetting = 0;
1556                                                 if (pri->pvts[chanpos]->owner) {
1557                                                         ast_verb(3, "Channel %d/%d, span %d got hangup ACK\n", PRI_SPAN(e->hangup.channel), PRI_CHANNEL(e->hangup.channel), pri->span);
1558                                                 }
1559
1560 #ifdef SUPPORT_USERUSER
1561                                                 if (!ast_strlen_zero(e->hangup.useruserinfo)) {
1562                                                         struct ast_channel *owner = pri->pvts[chanpos]->owner;
1563                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1564                                                         pbx_builtin_setvar_helper(owner, "USERUSERINFO", e->hangup.useruserinfo);
1565                                                         sig_pri_lock_private(pri->pvts[chanpos]);
1566                                                 }
1567 #endif
1568
1569                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1570                                         }
1571                                 }
1572                                 break;
1573                         case PRI_EVENT_CONFIG_ERR:
1574                                 ast_log(LOG_WARNING, "PRI Error on span %d: %s\n", pri->trunkgroup, e->err.err);
1575                                 break;
1576                         case PRI_EVENT_RESTART_ACK:
1577                                 chanpos = pri_find_principle(pri, e->restartack.channel);
1578                                 if (chanpos < 0) {
1579                                         /* Sometime switches (e.g. I421 / British Telecom) don't give us the
1580                                            channel number, so we have to figure it out...  This must be why
1581                                            everybody resets exactly a channel at a time. */
1582                                         for (x = 0; x < pri->numchans; x++) {
1583                                                 if (pri->pvts[x] && pri->pvts[x]->resetting) {
1584                                                         chanpos = x;
1585                                                         sig_pri_lock_private(pri->pvts[chanpos]);
1586                                                         ast_log(LOG_DEBUG, "Assuming restart ack is really for channel %d/%d span %d\n", pri->pvts[chanpos]->logicalspan, 
1587                                                                         pri->pvts[chanpos]->prioffset, pri->span);
1588                                                         if (pri->pvts[chanpos]->owner) {
1589                                                                 ast_log(LOG_WARNING, "Got restart ack on channel %d/%d with owner on span %d\n", pri->pvts[chanpos]->logicalspan, 
1590                                                                         pri->pvts[chanpos]->prioffset, pri->span);
1591                                                                 ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV);
1592                                                         }
1593                                                         pri->pvts[chanpos]->resetting = 0;
1594                                                         ast_verb(3, "B-channel %d/%d successfully restarted on span %d\n", pri->pvts[chanpos]->logicalspan, 
1595                                                                         pri->pvts[chanpos]->prioffset, pri->span);
1596                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1597                                                         if (pri->resetting)
1598                                                                 pri_check_restart(pri);
1599                                                         break;
1600                                                 }
1601                                         }
1602                                         if (chanpos < 0) {
1603                                                 ast_log(LOG_WARNING, "Restart ACK requested on strange channel %d/%d span %d\n", 
1604                                                         PRI_SPAN(e->restartack.channel), PRI_CHANNEL(e->restartack.channel), pri->span);
1605                                         }
1606                                 } else {
1607                                         if (pri->pvts[chanpos]) {
1608                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1609                                                 if (pri->pvts[chanpos]->owner) {
1610                                                         ast_log(LOG_WARNING, "Got restart ack on channel %d/%d span %d with owner\n",
1611                                                                 PRI_SPAN(e->restartack.channel), PRI_CHANNEL(e->restartack.channel), pri->span);
1612                                                         ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV);
1613                                                 }
1614                                                 pri->pvts[chanpos]->resetting = 0;
1615                                                 ast_verb(3, "B-channel %d/%d successfully restarted on span %d\n", pri->pvts[chanpos]->logicalspan, 
1616                                                                         pri->pvts[chanpos]->prioffset, pri->span);
1617                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1618                                                 if (pri->resetting)
1619                                                         pri_check_restart(pri);
1620                                         }
1621                                 }
1622                                 break;
1623                         case PRI_EVENT_SETUP_ACK:
1624                                 chanpos = pri_find_principle(pri, e->setup_ack.channel);
1625                                 if (chanpos < 0) {
1626                                         ast_log(LOG_WARNING, "Received SETUP_ACKNOWLEDGE on unconfigured channel %d/%d span %d\n", 
1627                                                 PRI_SPAN(e->setup_ack.channel), PRI_CHANNEL(e->setup_ack.channel), pri->span);
1628                                 } else {
1629                                         chanpos = pri_fixup_principle(pri, chanpos, e->setup_ack.call);
1630                                         if (chanpos > -1) {
1631                                                 sig_pri_lock_private(pri->pvts[chanpos]);
1632                                                 pri->pvts[chanpos]->setup_ack = 1;
1633                                                 /* Send any queued digits */
1634                                                 for (x = 0;x < strlen(pri->pvts[chanpos]->dialdest); x++) {
1635                                                         ast_log(LOG_DEBUG, "Sending pending digit '%c'\n", pri->pvts[chanpos]->dialdest[x]);
1636                                                         pri_information(pri->pri, pri->pvts[chanpos]->call, 
1637                                                                 pri->pvts[chanpos]->dialdest[x]);
1638                                                 }
1639                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
1640                                         } else
1641                                                 ast_log(LOG_WARNING, "Unable to move channel %d!\n", e->setup_ack.channel);
1642                                 }
1643                                 break;
1644                         case PRI_EVENT_NOTIFY:
1645                                 chanpos = pri_find_principle(pri, e->notify.channel);
1646                                 if (chanpos < 0) {
1647                                         ast_log(LOG_WARNING, "Received NOTIFY on unconfigured channel %d/%d span %d\n",
1648                                                 PRI_SPAN(e->notify.channel), PRI_CHANNEL(e->notify.channel), pri->span);
1649                                 } else {
1650                                         struct ast_frame f = { AST_FRAME_CONTROL, };
1651                                         sig_pri_lock_private(pri->pvts[chanpos]);
1652                                         switch (e->notify.info) {
1653                                         case PRI_NOTIFY_REMOTE_HOLD:
1654                                                 f.subclass = AST_CONTROL_HOLD;
1655                                                 pri_queue_frame(pri->pvts[chanpos], &f, pri);
1656                                                 break;
1657                                         case PRI_NOTIFY_REMOTE_RETRIEVAL:
1658                                                 f.subclass = AST_CONTROL_UNHOLD;
1659                                                 pri_queue_frame(pri->pvts[chanpos], &f, pri);
1660                                                 break;
1661                                         }
1662                                         sig_pri_unlock_private(pri->pvts[chanpos]);
1663                                 }
1664                                 break;
1665                         default:
1666                                 ast_log(LOG_DEBUG, "Event: %d\n", e->e);
1667                         }
1668                 }       
1669                 ast_mutex_unlock(&pri->lock);
1670         }
1671         /* Never reached */
1672         return NULL;
1673 }
1674
1675 void sig_pri_init_pri(struct sig_pri_pri *pri)
1676 {
1677         int i;
1678
1679         memset(pri, 0, sizeof(*pri));
1680
1681         ast_mutex_init(&pri->lock);
1682
1683         pri->master = AST_PTHREADT_NULL;
1684         for (i = 0; i < NUM_DCHANS; i++)
1685                 pri->fds[i] = -1;
1686 }
1687
1688 int sig_pri_hangup(struct sig_pri_chan *p, struct ast_channel *ast)
1689 {
1690         int res = 0;
1691 #ifdef SUPPORT_USERUSER
1692         const char *useruser = pbx_builtin_getvar_helper(ast, "USERUSERINFO");
1693 #endif
1694
1695         ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel);
1696         if (!ast->tech_pvt) {
1697                 ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
1698                 return 0;
1699         }
1700         
1701         p->owner = NULL;
1702         p->outgoing = 0;
1703         p->digital = 0;
1704         p->proceeding = 0;
1705         p->progress = 0;
1706         p->alerting = 0;
1707         p->setup_ack = 0;
1708         p->rdnis[0] = '\0';
1709         p->exten[0] = '\0';
1710         sig_pri_set_dialing(p, 0);
1711         
1712         if (!p->call) {
1713                 res = 0;
1714                 goto exit;
1715         }
1716
1717         /* Make sure we have a call (or REALLY have a call in the case of a PRI) */
1718         if (!pri_grab(p, p->pri)) {
1719                 if (p->alreadyhungup) {
1720                         ast_log(LOG_DEBUG, "Already hungup...  Calling hangup once, and clearing call\n");
1721
1722 #ifdef SUPPORT_USERUSER
1723                         pri_call_set_useruser(p->call, useruser);
1724 #endif
1725
1726                         pri_hangup(p->pri->pri, p->call, -1);
1727                         p->call = NULL;
1728                 } else {
1729                         const char *cause = pbx_builtin_getvar_helper(ast,"PRI_CAUSE");
1730                         int icause = ast->hangupcause ? ast->hangupcause : -1;
1731                         ast_log(LOG_DEBUG, "Not yet hungup...  Calling hangup once with icause, and clearing call\n");
1732
1733 #ifdef SUPPORT_USERUSER
1734                         pri_call_set_useruser(p->call, useruser);
1735 #endif
1736
1737                         p->alreadyhungup = 1;
1738                         if (cause) {
1739                                 if (atoi(cause))
1740                                         icause = atoi(cause);
1741                         }
1742                         pri_hangup(p->pri->pri, p->call, icause);
1743                 }
1744                 if (res < 0) 
1745                         ast_log(LOG_WARNING, "pri_disconnect failed\n");
1746                 pri_rel(p->pri);                        
1747         } else {
1748                 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
1749                 res = -1;
1750         }
1751
1752 exit:
1753         ast->tech_pvt = NULL;
1754         return res;
1755 }
1756
1757 int sig_pri_call(struct sig_pri_chan *p, struct ast_channel *ast, char *rdest, int timeout, int layer1)
1758 {
1759         char dest[256]; /* must be same length as p->dialdest */
1760         struct pri_sr *sr;
1761         char *c, *l, *n, *s = NULL;
1762 #ifdef SUPPORT_USERUSER
1763         const char *useruser;
1764 #endif
1765         int pridialplan;
1766         int dp_strip;
1767         int prilocaldialplan;
1768         int ldp_strip;
1769         int exclusive;
1770         const char *rr_str;
1771         int redirect_reason;
1772
1773         ast_log(LOG_DEBUG, "CALLING CID_NAME: %s CID_NUM:: %s\n", ast->cid.cid_name, ast->cid.cid_num);
1774
1775         if (!p->pri) {
1776                 ast_log(LOG_ERROR, "Could not find pri on channel %d\n", p->channel);
1777                 return -1;
1778         }
1779
1780
1781         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1782                 ast_log(LOG_WARNING, "sig_pri_call called on %s, neither down nor reserved\n", ast->name);
1783                 return -1;
1784         }
1785
1786         ast_copy_string(dest, rdest, sizeof(dest));
1787
1788         p->dialdest[0] = '\0';
1789         p->outgoing = 1;
1790
1791         c = strchr(dest, '/');
1792         if (c) {
1793                 c++;
1794         } else {
1795                 c = "";
1796         }
1797
1798         l = NULL;
1799         n = NULL;
1800
1801         if (!p->hidecallerid) {
1802                 l = ast->connected.id.number;
1803                 if (!p->hidecalleridname) {
1804                         n = ast->connected.id.name;
1805                 }
1806         }
1807
1808
1809         if (strlen(c) < p->stripmsd) {
1810                 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
1811                 return -1;
1812         }
1813         if (pri_grab(p, p->pri)) {
1814                 ast_log(LOG_WARNING, "Failed to grab PRI!\n");
1815                 return -1;
1816         }
1817         if (!(p->call = pri_new_call(p->pri->pri))) {
1818                 ast_log(LOG_WARNING, "Unable to create call on channel %d\n", p->channel);
1819                 pri_rel(p->pri);
1820                 return -1;
1821         }
1822         if (!(sr = pri_sr_new())) {
1823                 ast_log(LOG_WARNING, "Failed to allocate setup request channel %d\n", p->channel);
1824                 pri_destroycall(p->pri->pri, p->call);
1825                 p->call = NULL;
1826                 pri_rel(p->pri);
1827                 return -1;
1828         }
1829
1830         p->digital = IS_DIGITAL(ast->transfercapability);
1831
1832         /* Should the picked channel be used exclusively? */
1833         if (p->priexclusive || p->pri->nodetype == PRI_NETWORK) {
1834                 exclusive = 1;
1835         } else {
1836                 exclusive = 0;
1837         }
1838         
1839         pri_sr_set_channel(sr, PVT_TO_CHANNEL(p), exclusive, 1);
1840         pri_sr_set_bearer(sr, p->digital ? PRI_TRANS_CAP_DIGITAL : ast->transfercapability, 
1841                                 (p->digital ? -1 : layer1));
1842                                         
1843         if (p->pri->facilityenable)
1844                 pri_facility_enable(p->pri->pri);
1845
1846         ast_verb(3, "Requested transfer capability: 0x%.2x - %s\n", ast->transfercapability, ast_transfercapability2str(ast->transfercapability));
1847         dp_strip = 0;
1848         pridialplan = p->pri->dialplan - 1;
1849         if (pridialplan == -2 || pridialplan == -3) { /* compute dynamically */
1850                 if (strncmp(c + p->stripmsd, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) {
1851                         if (pridialplan == -2) {
1852                                 dp_strip = strlen(p->pri->internationalprefix);
1853                         }
1854                         pridialplan = PRI_INTERNATIONAL_ISDN;
1855                 } else if (strncmp(c + p->stripmsd, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) {
1856                         if (pridialplan == -2) {
1857                                 dp_strip = strlen(p->pri->nationalprefix);
1858                         }
1859                         pridialplan = PRI_NATIONAL_ISDN;
1860                 } else {
1861                         pridialplan = PRI_LOCAL_ISDN;
1862                 }
1863         }
1864         while (c[p->stripmsd] > '9' && c[p->stripmsd] != '*' && c[p->stripmsd] != '#') {
1865                 switch (c[p->stripmsd]) {
1866                 case 'U':
1867                         pridialplan = (PRI_TON_UNKNOWN << 4) | (pridialplan & 0xf);
1868                         break;
1869                 case 'I':
1870                         pridialplan = (PRI_TON_INTERNATIONAL << 4) | (pridialplan & 0xf);
1871                         break;
1872                 case 'N':
1873                         pridialplan = (PRI_TON_NATIONAL << 4) | (pridialplan & 0xf);
1874                         break;
1875                 case 'L':
1876                         pridialplan = (PRI_TON_NET_SPECIFIC << 4) | (pridialplan & 0xf);
1877                         break;
1878                 case 'S':
1879                         pridialplan = (PRI_TON_SUBSCRIBER << 4) | (pridialplan & 0xf);
1880                         break;
1881                 case 'V':
1882                         pridialplan = (PRI_TON_ABBREVIATED << 4) | (pridialplan & 0xf);
1883                         break;
1884                 case 'R':
1885                         pridialplan = (PRI_TON_RESERVED << 4) | (pridialplan & 0xf);
1886                         break;
1887                 case 'u':
1888                         pridialplan = PRI_NPI_UNKNOWN | (pridialplan & 0xf0);
1889                         break;
1890                 case 'e':
1891                         pridialplan = PRI_NPI_E163_E164 | (pridialplan & 0xf0);
1892                         break;
1893                 case 'x':
1894                         pridialplan = PRI_NPI_X121 | (pridialplan & 0xf0);
1895                         break;
1896                 case 'f':
1897                         pridialplan = PRI_NPI_F69 | (pridialplan & 0xf0);
1898                         break;
1899                 case 'n':
1900                         pridialplan = PRI_NPI_NATIONAL | (pridialplan & 0xf0);
1901                         break;
1902                 case 'p':
1903                         pridialplan = PRI_NPI_PRIVATE | (pridialplan & 0xf0);
1904                         break;
1905                 case 'r':
1906                         pridialplan = PRI_NPI_RESERVED | (pridialplan & 0xf0);
1907                         break;
1908 #if defined(HAVE_PRI_REVERSE_CHARGE)
1909                 case 'C':
1910                         pri_sr_set_reversecharge(sr, PRI_REVERSECHARGE_REQUESTED);
1911                         break;
1912 #endif
1913                 default:
1914                         if (isalpha(c[p->stripmsd])) {
1915                                 ast_log(LOG_WARNING, "Unrecognized pridialplan %s modifier: %c\n",
1916                                         c[p->stripmsd] > 'Z' ? "NPI" : "TON", c[p->stripmsd]);
1917                         }
1918                         break;
1919                 }
1920                 c++;
1921         }
1922         pri_sr_set_called(sr, c + p->stripmsd + dp_strip, pridialplan, s ? 1 : 0);
1923
1924         ldp_strip = 0;
1925         prilocaldialplan = p->pri->localdialplan - 1;
1926         if ((l != NULL) && (prilocaldialplan == -2 || prilocaldialplan == -3)) { /* compute dynamically */
1927                 if (strncmp(l, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) {
1928                         if (prilocaldialplan == -2) {
1929                                 ldp_strip = strlen(p->pri->internationalprefix);
1930                         }
1931                         prilocaldialplan = PRI_INTERNATIONAL_ISDN;
1932                 } else if (strncmp(l, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) {
1933                         if (prilocaldialplan == -2) {
1934                                 ldp_strip = strlen(p->pri->nationalprefix);
1935                         }
1936                         prilocaldialplan = PRI_NATIONAL_ISDN;
1937                 } else {
1938                         prilocaldialplan = PRI_LOCAL_ISDN;
1939                 }
1940         }
1941         if (l != NULL) {
1942                 while (*l > '9' && *l != '*' && *l != '#') {
1943                         switch (*l) {
1944                         case 'U':
1945                                 prilocaldialplan = (PRI_TON_UNKNOWN << 4) | (prilocaldialplan & 0xf);
1946                                 break;
1947                         case 'I':
1948                                 prilocaldialplan = (PRI_TON_INTERNATIONAL << 4) | (prilocaldialplan & 0xf);
1949                                 break;
1950                         case 'N':
1951                                 prilocaldialplan = (PRI_TON_NATIONAL << 4) | (prilocaldialplan & 0xf);
1952                                 break;
1953                         case 'L':
1954                                 prilocaldialplan = (PRI_TON_NET_SPECIFIC << 4) | (prilocaldialplan & 0xf);
1955                                 break;
1956                         case 'S':
1957                                 prilocaldialplan = (PRI_TON_SUBSCRIBER << 4) | (prilocaldialplan & 0xf);
1958                                 break;
1959                         case 'V':
1960                                 prilocaldialplan = (PRI_TON_ABBREVIATED << 4) | (prilocaldialplan & 0xf);
1961                                 break;
1962                         case 'R':
1963                                 prilocaldialplan = (PRI_TON_RESERVED << 4) | (prilocaldialplan & 0xf);
1964                                 break;
1965                         case 'u':
1966                                 prilocaldialplan = PRI_NPI_UNKNOWN | (prilocaldialplan & 0xf0);
1967                                 break;
1968                         case 'e':
1969                                 prilocaldialplan = PRI_NPI_E163_E164 | (prilocaldialplan & 0xf0);
1970                                 break;
1971                         case 'x':
1972                                 prilocaldialplan = PRI_NPI_X121 | (prilocaldialplan & 0xf0);
1973                                 break;
1974                         case 'f':
1975                                 prilocaldialplan = PRI_NPI_F69 | (prilocaldialplan & 0xf0);
1976                                 break;
1977                         case 'n':
1978                                 prilocaldialplan = PRI_NPI_NATIONAL | (prilocaldialplan & 0xf0);
1979                                 break;
1980                         case 'p':
1981                                 prilocaldialplan = PRI_NPI_PRIVATE | (prilocaldialplan & 0xf0);
1982                                 break;
1983                         case 'r':
1984                                 prilocaldialplan = PRI_NPI_RESERVED | (prilocaldialplan & 0xf0);
1985                                 break;
1986                         default:
1987                                 if (isalpha(*l)) {
1988                                         ast_log(LOG_WARNING,
1989                                                 "Unrecognized prilocaldialplan %s modifier: %c\n",
1990                                                 *l > 'Z' ? "NPI" : "TON", *l);
1991                                 }
1992                                 break;
1993                         }
1994                         l++;
1995                 }
1996         }
1997         pri_sr_set_caller(sr, l ? (l + ldp_strip) : NULL, n, prilocaldialplan,
1998                 p->use_callingpres ? ast->cid.cid_pres : (l ? PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN : PRES_NUMBER_NOT_AVAILABLE));
1999         if ((rr_str = pbx_builtin_getvar_helper(ast, "PRIREDIRECTREASON"))) {
2000                 if (!strcasecmp(rr_str, "UNKNOWN"))
2001                         redirect_reason = 0;
2002                 else if (!strcasecmp(rr_str, "BUSY"))
2003                         redirect_reason = 1;
2004                 else if (!strcasecmp(rr_str, "NO_REPLY"))
2005                         redirect_reason = 2;
2006                 else if (!strcasecmp(rr_str, "UNCONDITIONAL"))
2007                         redirect_reason = 15;
2008                 else
2009                         redirect_reason = PRI_REDIR_UNCONDITIONAL;
2010         } else
2011                 redirect_reason = PRI_REDIR_UNCONDITIONAL;
2012         pri_sr_set_redirecting(sr, ast->cid.cid_rdnis, p->pri->localdialplan - 1, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, redirect_reason);
2013
2014 #ifdef SUPPORT_USERUSER
2015         /* User-user info */
2016         useruser = pbx_builtin_getvar_helper(p->owner, "USERUSERINFO");
2017         if (useruser)
2018                 pri_sr_set_useruser(sr, useruser);
2019 #endif
2020
2021         if (pri_setup(p->pri->pri, p->call, sr)) {
2022                 ast_log(LOG_WARNING, "Unable to setup call to %s (using %s)\n", 
2023                         c + p->stripmsd + dp_strip, dialplan2str(p->pri->dialplan));
2024                 pri_rel(p->pri);
2025                 pri_sr_free(sr);
2026                 return -1;
2027         }
2028         pri_sr_free(sr);
2029         ast_setstate(ast, AST_STATE_DIALING);
2030         sig_pri_set_dialing(p, 1);
2031         pri_rel(p->pri);
2032         return 0;
2033 }
2034
2035 int sig_pri_indicate(struct sig_pri_chan *p, struct ast_channel *chan, int condition, const void *data, size_t datalen)
2036 {
2037         int res = 0;
2038
2039         switch (condition) {
2040         case AST_CONTROL_BUSY:
2041                 if (p->priindication_oob) {
2042                         chan->hangupcause = AST_CAUSE_USER_BUSY;
2043                         chan->_softhangup |= AST_SOFTHANGUP_DEV;
2044                         res = 0;
2045                 } else if (!p->progress && p->pri && !p->outgoing) {
2046                         if (p->pri->pri) {
2047                                 if (!pri_grab(p, p->pri)) {
2048 #ifdef HAVE_PRI_PROG_W_CAUSE
2049                                         pri_progress_with_cause(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1, PRI_CAUSE_USER_BUSY); /* cause = 17 */
2050 #else
2051                                         pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1);
2052 #endif
2053                                         pri_rel(p->pri);
2054                                 } else {
2055                                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
2056                                 }
2057                         }
2058                         p->progress = 1;
2059                         res = sig_pri_play_tone(p, SIG_PRI_TONE_BUSY);
2060                 }
2061                 break;
2062         case AST_CONTROL_RINGING:
2063                 if ((!p->alerting) && p->pri && !p->outgoing && (chan->_state != AST_STATE_UP)) {
2064                         if (p->pri->pri) {              
2065                                 if (!pri_grab(p, p->pri)) {
2066                                         pri_acknowledge(p->pri->pri,p->call, PVT_TO_CHANNEL(p), !p->digital);
2067                                         pri_rel(p->pri);
2068                                 } else {
2069                                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
2070                                 }
2071                         }
2072                         p->alerting = 1;
2073                 }
2074                 res = sig_pri_play_tone(p, SIG_PRI_TONE_RINGTONE);
2075                 if (chan->_state != AST_STATE_UP) {
2076                         if (chan->_state != AST_STATE_RING)
2077                                 ast_setstate(chan, AST_STATE_RINGING);
2078                 }
2079                 break;
2080         case AST_CONTROL_PROCEEDING:
2081                 ast_debug(1,"Received AST_CONTROL_PROCEEDING on %s\n",chan->name);
2082                 if (!p->proceeding && p->pri && !p->outgoing) {
2083                         if (p->pri->pri) {              
2084                                 if (!pri_grab(p, p->pri)) {
2085                                         pri_proceeding(p->pri->pri,p->call, PVT_TO_CHANNEL(p), !p->digital);
2086                                         pri_rel(p->pri);
2087                                 } else {
2088                                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
2089                                 }
2090                         }
2091                         p->proceeding = 1;
2092                         sig_pri_set_dialing(p, 0);
2093                 }
2094                 /* don't continue in ast_indicate */
2095                 res = 0;
2096                 break;
2097         case AST_CONTROL_PROGRESS:
2098                 ast_log(LOG_DEBUG,"Received AST_CONTROL_PROGRESS on %s\n",chan->name);
2099                 p->digital = 0; /* Digital-only calls isn't allowing any inband progress messages */
2100                 if (!p->progress && p->pri && !p->outgoing) {
2101                         if (p->pri->pri) {              
2102                                 if (!pri_grab(p, p->pri)) {
2103                                         pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1);
2104                                         pri_rel(p->pri);
2105                                 } else {
2106                                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
2107                                 }
2108                         }
2109                         p->progress = 1;
2110                 }
2111                 /* don't continue in ast_indicate */
2112                 res = 0;
2113                 break;
2114         case AST_CONTROL_CONGESTION:
2115                 chan->hangupcause = AST_CAUSE_CONGESTION;
2116                 if (p->priindication_oob) {
2117                         chan->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
2118                         chan->_softhangup |= AST_SOFTHANGUP_DEV;
2119                         res = 0;
2120                 } else if (!p->progress && p->pri && !p->outgoing) {
2121                         if (p->pri) {           
2122                                 if (!pri_grab(p, p->pri)) {
2123 #ifdef HAVE_PRI_PROG_W_CAUSE
2124                                         pri_progress_with_cause(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1, PRI_CAUSE_SWITCH_CONGESTION); /* cause = 42 */
2125 #else
2126                                         pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1);
2127 #endif
2128                                         pri_rel(p->pri);
2129                                 } else {
2130                                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
2131                                 }
2132                         }
2133                         p->progress = 1;
2134                         res = sig_pri_play_tone(p, SIG_PRI_TONE_CONGESTION);
2135                 }
2136                 break;
2137         case AST_CONTROL_HOLD:
2138                 if (p->pri && !strcasecmp(p->mohinterpret, "passthrough")) {
2139                         if (!pri_grab(p, p->pri)) {
2140                                 res = pri_notify(p->pri->pri, p->call, p->prioffset, PRI_NOTIFY_REMOTE_HOLD);
2141                                 pri_rel(p->pri);
2142                         } else {
2143                                 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
2144                         }
2145                 } else
2146                         ast_moh_start(chan, data, p->mohinterpret);
2147                 break;
2148         case AST_CONTROL_UNHOLD:
2149                 if (p->pri && !strcasecmp(p->mohinterpret, "passthrough")) {
2150                         if (!pri_grab(p, p->pri)) {
2151                                 res = pri_notify(p->pri->pri, p->call, p->prioffset, PRI_NOTIFY_REMOTE_RETRIEVAL);
2152                                 pri_rel(p->pri);
2153                         }
2154                 } else
2155                         ast_moh_stop(chan);
2156                 break;
2157         case AST_CONTROL_SRCUPDATE:
2158                 res = 0;
2159                 break;
2160         case -1:
2161                 res = sig_pri_play_tone(p, -1);
2162                 break;
2163         }
2164
2165         return res;
2166 }
2167
2168 int sig_pri_answer(struct sig_pri_chan *p, struct ast_channel *ast)
2169 {
2170         int res = 0;
2171         /* Send a pri acknowledge */
2172         if (!pri_grab(p, p->pri)) {
2173                 p->proceeding = 1;
2174                 sig_pri_set_dialing(p, 0);
2175                 res = pri_answer(p->pri->pri, p->call, 0, !p->digital);
2176                 pri_rel(p->pri);
2177         } else {
2178                 res = -1;
2179         }
2180         ast_setstate(ast, AST_STATE_UP);
2181         return res;
2182 }
2183
2184 int sig_pri_available(struct sig_pri_chan *p, int channelmatch, ast_group_t groupmatch, int *reason, int *channelmatched, int *groupmatched)
2185 {
2186         /* If no owner definitely available */
2187         if (!p->owner) {
2188                 /* Trust PRI */
2189                 if (p->pri) {
2190 #ifdef HAVE_PRI_SERVICE_MESSAGES
2191                         char db_chan_name[20], db_answer[5], state;
2192                         int why = 0;
2193                                                 
2194                         snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, p->pri->span, p->channel);
2195                         if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) {
2196                                 sscanf(db_answer, "%c:%d", &state, &why);
2197                         }
2198                         if ((p->resetting || p->call) || (why)) {
2199                                 if (why) {
2200                                         *reason = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
2201                                 }
2202 #else
2203                         if (p->resetting || p->call) {
2204 #endif
2205                                 return 0;
2206                         } else {
2207                                 return 1;
2208                         }
2209                 }
2210         }
2211
2212         return 0;
2213 }
2214
2215 /* If return 0, it means this function was able to handle it (pre setup digits).  If non zero, the user of this
2216  * functions should handle it normally (generate inband DTMF) */
2217 int sig_pri_digit_begin(struct sig_pri_chan *pvt, struct ast_channel *ast, char digit)
2218 {
2219         if ((ast->_state == AST_STATE_DIALING) && !pvt->proceeding) {
2220                 if (pvt->setup_ack) {
2221                         if (!pri_grab(pvt, pvt->pri)) {
2222                                 pri_information(pvt->pri->pri, pvt->call, digit);
2223                                 pri_rel(pvt->pri);
2224                         } else {
2225                                 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", pvt->pri->span);
2226                         }
2227                 } else if (strlen(pvt->dialdest) < sizeof(pvt->dialdest) - 1) {
2228                         int res;
2229                         ast_debug(1, "Queueing digit '%c' since setup_ack not yet received\n", digit);
2230                         res = strlen(pvt->dialdest);
2231                         pvt->dialdest[res++] = digit;
2232                         pvt->dialdest[res] = '\0';
2233                 }
2234                 return 0;
2235         }
2236         return 1;
2237 }
2238
2239 int sig_pri_start_pri(struct sig_pri_pri *pri)
2240 {
2241         int x;
2242         int i;
2243         
2244         ast_mutex_init(&pri->lock);
2245
2246         for (i = 0; i < NUM_DCHANS; i++) {
2247                 if (pri->fds[i] == -1) {
2248                         break;
2249                 }
2250
2251                 switch (pri->sig) {
2252                 case SIG_BRI:
2253                         pri->dchans[i] = pri_new_bri(pri->fds[i], 1, pri->nodetype, pri->switchtype);
2254                         break;
2255                 case SIG_BRI_PTMP:
2256                         pri->dchans[i] = pri_new_bri(pri->fds[i], 0, pri->nodetype, pri->switchtype);
2257                         break;
2258                 default:
2259                         pri->dchans[i] = pri_new(pri->fds[i], pri->nodetype, pri->switchtype);
2260 #ifdef HAVE_PRI_SERVICE_MESSAGES
2261                                 if (pri->enable_service_message_support) {
2262                                         pri_set_service_message_support(pri->dchans[i], 1);
2263                                 }
2264 #endif
2265                 }
2266
2267                 /* Force overlap dial if we're doing GR-303! */
2268                 pri_set_overlapdial(pri->dchans[i], pri->overlapdial);
2269                 pri_set_inbanddisconnect(pri->dchans[i], pri->inbanddisconnect);
2270                 /* Enslave to master if appropriate */
2271                 if (i)
2272                         pri_enslave(pri->dchans[0], pri->dchans[i]);
2273                 if (!pri->dchans[i]) {
2274                         if (pri->fds[i] > 0)
2275                                 close(pri->fds[i]);
2276                         pri->fds[i] = -1;
2277                         ast_log(LOG_ERROR, "Unable to create PRI structure\n");
2278                         return -1;
2279                 }
2280                 pri_set_debug(pri->dchans[i], 0);
2281                 pri_set_nsf(pri->dchans[i], pri->nsf);
2282 #ifdef PRI_GETSET_TIMERS
2283                 for (x = 0; x < PRI_MAX_TIMERS; x++) {
2284                         if (pri->pritimers[x] != 0)
2285                                 pri_set_timer(pri->dchans[i], x, pri->pritimers[x]);
2286                 }
2287 #endif
2288         }
2289         /* Assume primary is the one we use */
2290         pri->pri = pri->dchans[0];
2291         pri->resetpos = -1;
2292         if (ast_pthread_create_background(&pri->master, NULL, pri_dchannel, pri)) {
2293                 for (i = 0; i < NUM_DCHANS; i++) {
2294                         if (!pri->dchans[i])
2295                                 break;
2296                         if (pri->fds[i] > 0)
2297                                 close(pri->fds[i]);
2298                         pri->fds[i] = -1;
2299                 }
2300                 ast_log(LOG_ERROR, "Unable to spawn D-channel: %s\n", strerror(errno));
2301                 return -1;
2302         }
2303         return 0;
2304 }
2305
2306 void sig_pri_chan_alarm_notify(struct sig_pri_chan *p, int noalarm)
2307 {
2308         if (!noalarm) {
2309                 p->inalarm = 1;
2310                 if (!p->pri || !p->pri->pri || (pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0)) {
2311                         /* T309 is not enabled : hangup calls when alarm occurs */
2312                         if (p->call) {
2313                                 if (p->pri && p->pri->pri) {
2314                                         if (!pri_grab(p, p->pri)) {
2315                                                 pri_hangup(p->pri->pri, p->call, -1);
2316                                                 pri_destroycall(p->pri->pri, p->call);
2317                                                 p->call = NULL;
2318                                                 pri_rel(p->pri);
2319                                         } else
2320                                                 ast_log(LOG_WARNING, "Failed to grab PRI!\n");
2321                                 } else
2322                                         ast_log(LOG_WARNING, "Failed to grab PRI!\n");
2323                         } else
2324                                 ast_log(LOG_WARNING, "The PRI Call has not been destroyed\n");
2325                 }
2326                 if (p->owner)
2327                         ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
2328         } else {
2329                 p->inalarm = 0;
2330         }
2331 }
2332
2333 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)
2334 {
2335         struct sig_pri_chan *p;
2336
2337         p = ast_calloc(1, sizeof(*p));
2338
2339         if (!p)
2340                 return p;
2341
2342         p->logicalspan = logicalspan;
2343         p->prioffset = channo;
2344
2345         p->calls = callback;
2346         p->chan_pvt = pvt_data;
2347
2348         pri->pvts[pri->numchans++] = p;
2349         p->pri = pri;
2350
2351         return p;
2352 }
2353
2354 static void build_status(char *s, size_t len, int status, int active)
2355 {
2356         if (!s || len < 1) {
2357                 return;
2358         }
2359         s[0] = '\0';
2360         if (!(status & DCHAN_NOTINALARM))
2361                 strncat(s, "In Alarm, ", len - strlen(s) - 1);
2362         if (status & DCHAN_UP)
2363                 strncat(s, "Up", len - strlen(s) - 1);
2364         else
2365                 strncat(s, "Down", len - strlen(s) - 1);
2366         if (active)
2367                 strncat(s, ", Active", len - strlen(s) - 1);
2368         else
2369                 strncat(s, ", Standby", len - strlen(s) - 1);
2370         s[len - 1] = '\0';
2371 }
2372
2373 void sig_pri_cli_show_spans(int fd, int span, struct sig_pri_pri *pri)
2374 {
2375         char status[256];
2376         int x;
2377         for (x = 0; x < NUM_DCHANS; x++) {
2378                 if (pri->dchans[x]) {
2379                         build_status(status, sizeof(status), pri->dchanavail[x], pri->dchans[x] == pri->pri);
2380                         ast_cli(fd, "PRI span %d/%d: %s\n", span, x, status);
2381                 }
2382         }
2383 }
2384
2385 void sig_pri_cli_show_span(int fd, int *dchannels, struct sig_pri_pri *pri)
2386 {
2387         int x;
2388         char status[256];
2389
2390         for (x = 0; x < NUM_DCHANS; x++) {
2391                 if (pri->dchans[x]) {
2392 #ifdef PRI_DUMP_INFO_STR
2393                         char *info_str = NULL;
2394 #endif
2395                         ast_cli(fd, "%s D-channel: %d\n", pri_order(x), dchannels[x]);
2396                         build_status(status, sizeof(status), pri->dchanavail[x], pri->dchans[x] == pri->pri);
2397                         ast_cli(fd, "Status: %s\n", status);
2398 #ifdef PRI_DUMP_INFO_STR
2399                         info_str = pri_dump_info_str(pri->pri);
2400                         if (info_str) {
2401                                 ast_cli(fd, "%s", info_str);
2402                                 free(info_str);
2403                         }
2404 #else
2405                         pri_dump_info(pri->pri);
2406 #endif
2407                         ast_cli(fd, "Overlap Recv: %s\n\n", (pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)?"Yes":"No");
2408                         ast_cli(fd, "\n");
2409                 }
2410         }
2411 }
2412
2413 int pri_send_keypad_facility_exec(struct sig_pri_chan *p, const char *digits)
2414 {
2415         sig_pri_lock_private(p);
2416
2417         if (!p->pri || !p->call) {
2418                 ast_debug(1, "Unable to find pri or call on channel!\n");
2419                 sig_pri_unlock_private(p);
2420                 return -1;
2421         }
2422
2423         if (!pri_grab(p, p->pri)) {
2424                 pri_keypad_facility(p->pri->pri, p->call, digits);
2425                 pri_rel(p->pri);
2426         } else {
2427                 ast_debug(1, "Unable to grab pri to send keypad facility!\n");
2428                 sig_pri_unlock_private(p);
2429                 return -1;
2430         }
2431
2432         sig_pri_unlock_private(p);
2433
2434         return 0;
2435 }
2436
2437 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)
2438 {
2439         int res = -1;
2440
2441         sig_pri_lock_private(p);
2442
2443         if (!p->pri || !p->call) {
2444                 ast_log(LOG_DEBUG, "Unable to find pri or call on channel!\n");
2445                 sig_pri_unlock_private(p);
2446                 return -1;
2447         }
2448
2449         switch (p->pri->sig) {
2450         case SIG_PRI:
2451                 if (!pri_grab(p, p->pri)) {
2452                         if (chanstate == AST_STATE_RING) {
2453                                 res = pri_callrerouting_facility(p->pri->pri, p->call, destination, original, reason);
2454                         }
2455                         pri_rel(p->pri);
2456                 } else {
2457                         ast_log(LOG_DEBUG, "Unable to grab pri to send callrerouting facility on span %d!\n", p->pri->span);
2458                         sig_pri_unlock_private(p);
2459                         return -1;
2460                 }
2461                 break;
2462         }
2463
2464         sig_pri_unlock_private(p);
2465
2466         return res;
2467 }
2468
2469 int pri_maintenance_bservice(struct pri *pri, struct sig_pri_chan *p, int changestatus)
2470 {
2471         int channel = PVT_TO_CHANNEL(p);
2472         int span = PRI_SPAN(channel);
2473
2474         return pri_maintenance_service(pri, span, channel, changestatus);
2475 }
2476
2477 #endif /* HAVE_PRI */