Replace direct access to channel name with accessor functions
[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/app.h"
39 #include "asterisk/file.h"
40 #include "asterisk/callerid.h"
41 #include "asterisk/say.h"
42 #include "asterisk/manager.h"
43 #include "asterisk/astdb.h"
44 #include "asterisk/causes.h"
45 #include "asterisk/musiconhold.h"
46 #include "asterisk/cli.h"
47 #include "asterisk/transcap.h"
48 #include "asterisk/features.h"
49 #include "asterisk/aoc.h"
50
51 #include "sig_pri.h"
52 #ifndef PRI_EVENT_FACILITY
53 #error please update libpri
54 #endif
55
56 /* define this to send PRI user-user information elements */
57 #undef SUPPORT_USERUSER
58
59 /*!
60  * Define to make always pick a channel if allowed.  Useful for
61  * testing channel shifting.
62  */
63 //#define ALWAYS_PICK_CHANNEL   1
64
65 /*!
66  * Define to force a RESTART on a channel that returns a cause
67  * code of PRI_CAUSE_REQUESTED_CHAN_UNAVAIL(44).  If the cause
68  * is because of a stuck channel on the peer and the channel is
69  * always the next channel we pick for an outgoing call then
70  * this can help.
71  */
72 #define FORCE_RESTART_UNAVAIL_CHANS             1
73
74 #if defined(HAVE_PRI_CCSS)
75 struct sig_pri_cc_agent_prv {
76         /*! Asterisk span D channel control structure. */
77         struct sig_pri_span *pri;
78         /*! CC id value to use with libpri. -1 if invalid. */
79         long cc_id;
80         /*! TRUE if CC has been requested and we are waiting for the response. */
81         unsigned char cc_request_response_pending;
82 };
83
84 struct sig_pri_cc_monitor_instance {
85         /*! \brief Asterisk span D channel control structure. */
86         struct sig_pri_span *pri;
87         /*! CC id value to use with libpri. (-1 if already canceled). */
88         long cc_id;
89         /*! CC core id value. */
90         int core_id;
91         /*! Device name(Channel name less sequence number) */
92         char name[1];
93 };
94
95 /*! Upper level agent/monitor type name. */
96 static const char *sig_pri_cc_type_name;
97 /*! Container of sig_pri monitor instances. */
98 static struct ao2_container *sig_pri_cc_monitors;
99 #endif  /* defined(HAVE_PRI_CCSS) */
100
101 static int pri_matchdigittimeout = 3000;
102
103 static int pri_gendigittimeout = 8000;
104
105 #define DCHAN_NOTINALARM  (1 << 0)
106 #define DCHAN_UP          (1 << 1)
107
108 /* Defines to help decode the encoded event channel id. */
109 #define PRI_CHANNEL(p)  ((p) & 0xff)
110 #define PRI_SPAN(p)             (((p) >> 8) & 0xff)
111 #define PRI_EXPLICIT    (1 << 16)
112 #define PRI_CIS_CALL    (1 << 17)       /* Call is using the D channel only. */
113 #define PRI_HELD_CALL   (1 << 18)
114
115
116 #define DCHAN_AVAILABLE (DCHAN_NOTINALARM | DCHAN_UP)
117
118 #define PRI_DEADLOCK_AVOIDANCE(p) \
119         do { \
120                 sig_pri_unlock_private(p); \
121                 usleep(1); \
122                 sig_pri_lock_private(p); \
123         } while (0)
124
125 static int pri_active_dchan_index(struct sig_pri_span *pri);
126
127 static const char *sig_pri_call_level2str(enum sig_pri_call_level level)
128 {
129         switch (level) {
130         case SIG_PRI_CALL_LEVEL_IDLE:
131                 return "Idle";
132         case SIG_PRI_CALL_LEVEL_SETUP:
133                 return "Setup";
134         case SIG_PRI_CALL_LEVEL_OVERLAP:
135                 return "Overlap";
136         case SIG_PRI_CALL_LEVEL_PROCEEDING:
137                 return "Proceeding";
138         case SIG_PRI_CALL_LEVEL_ALERTING:
139                 return "Alerting";
140         case SIG_PRI_CALL_LEVEL_CONNECT:
141                 return "Connect";
142         }
143         return "Unknown";
144 }
145
146 static inline void pri_rel(struct sig_pri_span *pri)
147 {
148         ast_mutex_unlock(&pri->lock);
149 }
150
151 static unsigned int PVT_TO_CHANNEL(struct sig_pri_chan *p)
152 {
153         int res = (((p)->prioffset) | ((p)->logicalspan << 8) | (p->mastertrunkgroup ? PRI_EXPLICIT : 0));
154         ast_debug(5, "prioffset: %d mastertrunkgroup: %d logicalspan: %d result: %d\n",
155                 p->prioffset, p->mastertrunkgroup, p->logicalspan, res);
156
157         return res;
158 }
159
160 static void sig_pri_handle_dchan_exception(struct sig_pri_span *pri, int index)
161 {
162         if (pri->calls->handle_dchan_exception)
163                 pri->calls->handle_dchan_exception(pri, index);
164 }
165
166 static void sig_pri_set_dialing(struct sig_pri_chan *p, int is_dialing)
167 {
168         if (p->calls->set_dialing) {
169                 p->calls->set_dialing(p->chan_pvt, is_dialing);
170         }
171 }
172
173 static void sig_pri_set_digital(struct sig_pri_chan *p, int is_digital)
174 {
175         p->digital = is_digital;
176         if (p->calls->set_digital) {
177                 p->calls->set_digital(p->chan_pvt, is_digital);
178         }
179 }
180
181 void sig_pri_set_alarm(struct sig_pri_chan *p, int in_alarm)
182 {
183         /*
184          * Clear the channel restart flag when the channel alarm changes
185          * to prevent the flag from getting stuck when the link goes
186          * down.
187          */
188         p->resetting = 0;
189
190         p->inalarm = in_alarm;
191         if (p->calls->set_alarm) {
192                 p->calls->set_alarm(p->chan_pvt, in_alarm);
193         }
194 }
195
196 static const char *sig_pri_get_orig_dialstring(struct sig_pri_chan *p)
197 {
198         if (p->calls->get_orig_dialstring) {
199                 return p->calls->get_orig_dialstring(p->chan_pvt);
200         }
201         ast_log(LOG_ERROR, "get_orig_dialstring callback not defined\n");
202         return "";
203 }
204
205 #if defined(HAVE_PRI_CCSS)
206 static void sig_pri_make_cc_dialstring(struct sig_pri_chan *p, char *buf, size_t buf_size)
207 {
208         if (p->calls->make_cc_dialstring) {
209                 p->calls->make_cc_dialstring(p->chan_pvt, buf, buf_size);
210         } else {
211                 ast_log(LOG_ERROR, "make_cc_dialstring callback not defined\n");
212                 buf[0] = '\0';
213         }
214 }
215 #endif  /* defined(HAVE_PRI_CCSS) */
216
217 /*!
218  * \internal
219  * \brief Reevaluate the PRI span device state.
220  * \since 1.8
221  *
222  * \param pri PRI span control structure.
223  *
224  * \return Nothing
225  *
226  * \note Assumes the pri->lock is already obtained.
227  */
228 static void sig_pri_span_devstate_changed(struct sig_pri_span *pri)
229 {
230         if (pri->calls->update_span_devstate) {
231                 pri->calls->update_span_devstate(pri);
232         }
233 }
234
235 /*!
236  * \internal
237  * \brief Set the caller id information in the parent module.
238  * \since 1.8
239  *
240  * \param p sig_pri channel structure.
241  *
242  * \return Nothing
243  */
244 static void sig_pri_set_caller_id(struct sig_pri_chan *p)
245 {
246         struct ast_party_caller caller;
247
248         if (p->calls->set_callerid) {
249                 ast_party_caller_init(&caller);
250
251                 caller.id.name.str = p->cid_name;
252                 caller.id.name.presentation = p->callingpres;
253                 caller.id.name.valid = 1;
254
255                 caller.id.number.str = p->cid_num;
256                 caller.id.number.plan = p->cid_ton;
257                 caller.id.number.presentation = p->callingpres;
258                 caller.id.number.valid = 1;
259
260                 if (!ast_strlen_zero(p->cid_subaddr)) {
261                         caller.id.subaddress.valid = 1;
262                         //caller.id.subaddress.type = 0;/* nsap */
263                         //caller.id.subaddress.odd_even_indicator = 0;
264                         caller.id.subaddress.str = p->cid_subaddr;
265                 }
266                 caller.id.tag = p->user_tag;
267
268                 caller.ani.number.str = p->cid_ani;
269                 //caller.ani.number.plan = p->xxx;
270                 //caller.ani.number.presentation = p->xxx;
271                 caller.ani.number.valid = 1;
272
273                 caller.ani2 = p->cid_ani2;
274                 p->calls->set_callerid(p->chan_pvt, &caller);
275         }
276 }
277
278 /*!
279  * \internal
280  * \brief Set the Dialed Number Identifier.
281  * \since 1.8
282  *
283  * \param p sig_pri channel structure.
284  * \param dnid Dialed Number Identifier string.
285  *
286  * \return Nothing
287  */
288 static void sig_pri_set_dnid(struct sig_pri_chan *p, const char *dnid)
289 {
290         if (p->calls->set_dnid) {
291                 p->calls->set_dnid(p->chan_pvt, dnid);
292         }
293 }
294
295 /*!
296  * \internal
297  * \brief Set the Redirecting Directory Number Information Service (RDNIS).
298  * \since 1.8
299  *
300  * \param p sig_pri channel structure.
301  * \param rdnis Redirecting Directory Number Information Service (RDNIS) string.
302  *
303  * \return Nothing
304  */
305 static void sig_pri_set_rdnis(struct sig_pri_chan *p, const char *rdnis)
306 {
307         if (p->calls->set_rdnis) {
308                 p->calls->set_rdnis(p->chan_pvt, rdnis);
309         }
310 }
311
312 static void sig_pri_unlock_private(struct sig_pri_chan *p)
313 {
314         if (p->calls->unlock_private)
315                 p->calls->unlock_private(p->chan_pvt);
316 }
317
318 static void sig_pri_lock_private(struct sig_pri_chan *p)
319 {
320         if (p->calls->lock_private)
321                 p->calls->lock_private(p->chan_pvt);
322 }
323
324 static void sig_pri_deadlock_avoidance_private(struct sig_pri_chan *p)
325 {
326         if (p->calls->deadlock_avoidance_private) {
327                 p->calls->deadlock_avoidance_private(p->chan_pvt);
328         } else {
329                 /* Fallback to the old way if callback not present. */
330                 PRI_DEADLOCK_AVOIDANCE(p);
331         }
332 }
333
334 static void pri_grab(struct sig_pri_chan *p, struct sig_pri_span *pri)
335 {
336         int res;
337
338         /* Grab the lock first */
339         do {
340                 res = ast_mutex_trylock(&pri->lock);
341                 if (res) {
342                         sig_pri_deadlock_avoidance_private(p);
343                 }
344         } while (res);
345         /* Then break the poll */
346         pthread_kill(pri->master, SIGURG);
347 }
348
349 /*!
350  * \internal
351  * \brief Convert PRI redirecting reason to asterisk version.
352  * \since 1.8
353  *
354  * \param pri_reason PRI redirecting reason.
355  *
356  * \return Equivalent asterisk redirecting reason value.
357  */
358 static enum AST_REDIRECTING_REASON pri_to_ast_reason(int pri_reason)
359 {
360         enum AST_REDIRECTING_REASON ast_reason;
361
362         switch (pri_reason) {
363         case PRI_REDIR_FORWARD_ON_BUSY:
364                 ast_reason = AST_REDIRECTING_REASON_USER_BUSY;
365                 break;
366         case PRI_REDIR_FORWARD_ON_NO_REPLY:
367                 ast_reason = AST_REDIRECTING_REASON_NO_ANSWER;
368                 break;
369         case PRI_REDIR_DEFLECTION:
370                 ast_reason = AST_REDIRECTING_REASON_DEFLECTION;
371                 break;
372         case PRI_REDIR_UNCONDITIONAL:
373                 ast_reason = AST_REDIRECTING_REASON_UNCONDITIONAL;
374                 break;
375         case PRI_REDIR_UNKNOWN:
376         default:
377                 ast_reason = AST_REDIRECTING_REASON_UNKNOWN;
378                 break;
379         }
380
381         return ast_reason;
382 }
383
384 /*!
385  * \internal
386  * \brief Convert asterisk redirecting reason to PRI version.
387  * \since 1.8
388  *
389  * \param ast_reason Asterisk redirecting reason.
390  *
391  * \return Equivalent PRI redirecting reason value.
392  */
393 static int ast_to_pri_reason(enum AST_REDIRECTING_REASON ast_reason)
394 {
395         int pri_reason;
396
397         switch (ast_reason) {
398         case AST_REDIRECTING_REASON_USER_BUSY:
399                 pri_reason = PRI_REDIR_FORWARD_ON_BUSY;
400                 break;
401         case AST_REDIRECTING_REASON_NO_ANSWER:
402                 pri_reason = PRI_REDIR_FORWARD_ON_NO_REPLY;
403                 break;
404         case AST_REDIRECTING_REASON_UNCONDITIONAL:
405                 pri_reason = PRI_REDIR_UNCONDITIONAL;
406                 break;
407         case AST_REDIRECTING_REASON_DEFLECTION:
408                 pri_reason = PRI_REDIR_DEFLECTION;
409                 break;
410         case AST_REDIRECTING_REASON_UNKNOWN:
411         default:
412                 pri_reason = PRI_REDIR_UNKNOWN;
413                 break;
414         }
415
416         return pri_reason;
417 }
418
419 /*!
420  * \internal
421  * \brief Convert PRI number presentation to asterisk version.
422  * \since 1.8
423  *
424  * \param pri_presentation PRI number presentation.
425  *
426  * \return Equivalent asterisk number presentation value.
427  */
428 static int pri_to_ast_presentation(int pri_presentation)
429 {
430         int ast_presentation;
431
432         switch (pri_presentation) {
433         case PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
434                 ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
435                 break;
436         case PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
437                 ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
438                 break;
439         case PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
440                 ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN;
441                 break;
442         case PRES_ALLOWED_NETWORK_NUMBER:
443                 ast_presentation = AST_PRES_ALLOWED_NETWORK_NUMBER;
444                 break;
445         case PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
446                 ast_presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
447                 break;
448         case PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
449                 ast_presentation = AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
450                 break;
451         case PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
452                 ast_presentation = AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN;
453                 break;
454         case PRES_PROHIB_NETWORK_NUMBER:
455                 ast_presentation = AST_PRES_PROHIB_NETWORK_NUMBER;
456                 break;
457         case PRES_NUMBER_NOT_AVAILABLE:
458                 ast_presentation = AST_PRES_NUMBER_NOT_AVAILABLE;
459                 break;
460         default:
461                 ast_presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
462                 break;
463         }
464
465         return ast_presentation;
466 }
467
468 /*!
469  * \internal
470  * \brief Convert asterisk number presentation to PRI version.
471  * \since 1.8
472  *
473  * \param ast_presentation Asterisk number presentation.
474  *
475  * \return Equivalent PRI number presentation value.
476  */
477 static int ast_to_pri_presentation(int ast_presentation)
478 {
479         int pri_presentation;
480
481         switch (ast_presentation) {
482         case AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
483                 pri_presentation = PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
484                 break;
485         case AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
486                 pri_presentation = PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
487                 break;
488         case AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
489                 pri_presentation = PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN;
490                 break;
491         case AST_PRES_ALLOWED_NETWORK_NUMBER:
492                 pri_presentation = PRES_ALLOWED_NETWORK_NUMBER;
493                 break;
494         case AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
495                 pri_presentation = PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
496                 break;
497         case AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
498                 pri_presentation = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
499                 break;
500         case AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
501                 pri_presentation = PRES_PROHIB_USER_NUMBER_FAILED_SCREEN;
502                 break;
503         case AST_PRES_PROHIB_NETWORK_NUMBER:
504                 pri_presentation = PRES_PROHIB_NETWORK_NUMBER;
505                 break;
506         case AST_PRES_NUMBER_NOT_AVAILABLE:
507                 pri_presentation = PRES_NUMBER_NOT_AVAILABLE;
508                 break;
509         default:
510                 pri_presentation = PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
511                 break;
512         }
513
514         return pri_presentation;
515 }
516
517 /*!
518  * \internal
519  * \brief Convert PRI name char_set to asterisk version.
520  * \since 1.8
521  *
522  * \param pri_char_set PRI name char_set.
523  *
524  * \return Equivalent asterisk name char_set value.
525  */
526 static enum AST_PARTY_CHAR_SET pri_to_ast_char_set(int pri_char_set)
527 {
528         enum AST_PARTY_CHAR_SET ast_char_set;
529
530         switch (pri_char_set) {
531         default:
532         case PRI_CHAR_SET_UNKNOWN:
533                 ast_char_set = AST_PARTY_CHAR_SET_UNKNOWN;
534                 break;
535         case PRI_CHAR_SET_ISO8859_1:
536                 ast_char_set = AST_PARTY_CHAR_SET_ISO8859_1;
537                 break;
538         case PRI_CHAR_SET_WITHDRAWN:
539                 ast_char_set = AST_PARTY_CHAR_SET_WITHDRAWN;
540                 break;
541         case PRI_CHAR_SET_ISO8859_2:
542                 ast_char_set = AST_PARTY_CHAR_SET_ISO8859_2;
543                 break;
544         case PRI_CHAR_SET_ISO8859_3:
545                 ast_char_set = AST_PARTY_CHAR_SET_ISO8859_3;
546                 break;
547         case PRI_CHAR_SET_ISO8859_4:
548                 ast_char_set = AST_PARTY_CHAR_SET_ISO8859_4;
549                 break;
550         case PRI_CHAR_SET_ISO8859_5:
551                 ast_char_set = AST_PARTY_CHAR_SET_ISO8859_5;
552                 break;
553         case PRI_CHAR_SET_ISO8859_7:
554                 ast_char_set = AST_PARTY_CHAR_SET_ISO8859_7;
555                 break;
556         case PRI_CHAR_SET_ISO10646_BMPSTRING:
557                 ast_char_set = AST_PARTY_CHAR_SET_ISO10646_BMPSTRING;
558                 break;
559         case PRI_CHAR_SET_ISO10646_UTF_8STRING:
560                 ast_char_set = AST_PARTY_CHAR_SET_ISO10646_UTF_8STRING;
561                 break;
562         }
563
564         return ast_char_set;
565 }
566
567 /*!
568  * \internal
569  * \brief Convert asterisk name char_set to PRI version.
570  * \since 1.8
571  *
572  * \param ast_char_set Asterisk name char_set.
573  *
574  * \return Equivalent PRI name char_set value.
575  */
576 static int ast_to_pri_char_set(enum AST_PARTY_CHAR_SET ast_char_set)
577 {
578         int pri_char_set;
579
580         switch (ast_char_set) {
581         default:
582         case AST_PARTY_CHAR_SET_UNKNOWN:
583                 pri_char_set = PRI_CHAR_SET_UNKNOWN;
584                 break;
585         case AST_PARTY_CHAR_SET_ISO8859_1:
586                 pri_char_set = PRI_CHAR_SET_ISO8859_1;
587                 break;
588         case AST_PARTY_CHAR_SET_WITHDRAWN:
589                 pri_char_set = PRI_CHAR_SET_WITHDRAWN;
590                 break;
591         case AST_PARTY_CHAR_SET_ISO8859_2:
592                 pri_char_set = PRI_CHAR_SET_ISO8859_2;
593                 break;
594         case AST_PARTY_CHAR_SET_ISO8859_3:
595                 pri_char_set = PRI_CHAR_SET_ISO8859_3;
596                 break;
597         case AST_PARTY_CHAR_SET_ISO8859_4:
598                 pri_char_set = PRI_CHAR_SET_ISO8859_4;
599                 break;
600         case AST_PARTY_CHAR_SET_ISO8859_5:
601                 pri_char_set = PRI_CHAR_SET_ISO8859_5;
602                 break;
603         case AST_PARTY_CHAR_SET_ISO8859_7:
604                 pri_char_set = PRI_CHAR_SET_ISO8859_7;
605                 break;
606         case AST_PARTY_CHAR_SET_ISO10646_BMPSTRING:
607                 pri_char_set = PRI_CHAR_SET_ISO10646_BMPSTRING;
608                 break;
609         case AST_PARTY_CHAR_SET_ISO10646_UTF_8STRING:
610                 pri_char_set = PRI_CHAR_SET_ISO10646_UTF_8STRING;
611                 break;
612         }
613
614         return pri_char_set;
615 }
616
617 #if defined(HAVE_PRI_SUBADDR)
618 /*!
619  * \internal
620  * \brief Fill in the asterisk party subaddress from the given PRI party subaddress.
621  * \since 1.8
622  *
623  * \param ast_subaddress Asterisk party subaddress structure.
624  * \param pri_subaddress PRI party subaddress structure.
625  *
626  * \return Nothing
627  *
628  */
629 static void sig_pri_set_subaddress(struct ast_party_subaddress *ast_subaddress, const struct pri_party_subaddress *pri_subaddress)
630 {
631         char *cnum, *ptr;
632         int x, len;
633
634         if (ast_subaddress->str) {
635                 ast_free(ast_subaddress->str);
636         }
637         if (pri_subaddress->length <= 0) {
638                 ast_party_subaddress_init(ast_subaddress);
639                 return;
640         }
641
642         if (!pri_subaddress->type) {
643                 /* NSAP */
644                 ast_subaddress->str = ast_strdup((char *) pri_subaddress->data);
645         } else {
646                 /* User Specified */
647                 if (!(cnum = ast_malloc(2 * pri_subaddress->length + 1))) {
648                         ast_party_subaddress_init(ast_subaddress);
649                         return;
650                 }
651
652                 ptr = cnum;
653                 len = pri_subaddress->length - 1; /* -1 account for zero based indexing */
654                 for (x = 0; x < len; ++x) {
655                         ptr += sprintf(ptr, "%02x", pri_subaddress->data[x]);
656                 }
657
658                 if (pri_subaddress->odd_even_indicator) {
659                         /* ODD */
660                         sprintf(ptr, "%01x", (pri_subaddress->data[len]) >> 4);
661                 } else {
662                         /* EVEN */
663                         sprintf(ptr, "%02x", pri_subaddress->data[len]);
664                 }
665                 ast_subaddress->str = cnum;
666         }
667         ast_subaddress->type = pri_subaddress->type;
668         ast_subaddress->odd_even_indicator = pri_subaddress->odd_even_indicator;
669         ast_subaddress->valid = 1;
670 }
671 #endif  /* defined(HAVE_PRI_SUBADDR) */
672
673 #if defined(HAVE_PRI_SUBADDR)
674 static unsigned char ast_pri_pack_hex_char(char c)
675 {
676         unsigned char res;
677
678         if (c < '0') {
679                 res = 0;
680         } else if (c < ('9' + 1)) {
681                 res = c - '0';
682         } else if (c < 'A') {
683                 res = 0;
684         } else if (c < ('F' + 1)) {
685                 res = c - 'A' + 10;
686         } else if (c < 'a') {
687                 res = 0;
688         } else if (c < ('f' + 1)) {
689                 res = c - 'a' + 10;
690         } else {
691                 res = 0;
692         }
693         return res;
694 }
695 #endif  /* defined(HAVE_PRI_SUBADDR) */
696
697 #if defined(HAVE_PRI_SUBADDR)
698 /*!
699  * \internal
700  * \brief Convert a null terminated hexadecimal string to a packed hex byte array.
701  * \details left justified, with 0 padding if odd length.
702  * \since 1.8
703  *
704  * \param dst pointer to packed byte array.
705  * \param src pointer to null terminated hexadecimal string.
706  * \param maxlen destination array size.
707  *
708  * \return Length of byte array
709  *
710  * \note The dst is not an ASCIIz string.
711  * \note The src is an ASCIIz hex string.
712  */
713 static int ast_pri_pack_hex_string(unsigned char *dst, char *src, int maxlen)
714 {
715         int res = 0;
716         int len = strlen(src);
717
718         if (len > (2 * maxlen)) {
719                 len = 2 * maxlen;
720         }
721
722         res = len / 2 + len % 2;
723
724         while (len > 1) {
725                 *dst = ast_pri_pack_hex_char(*src) << 4;
726                 src++;
727                 *dst |= ast_pri_pack_hex_char(*src);
728                 dst++, src++;
729                 len -= 2;
730         }
731         if (len) { /* 1 left */
732                 *dst = ast_pri_pack_hex_char(*src) << 4;
733         }
734         return res;
735 }
736 #endif  /* defined(HAVE_PRI_SUBADDR) */
737
738 #if defined(HAVE_PRI_SUBADDR)
739 /*!
740  * \internal
741  * \brief Fill in the PRI party subaddress from the given asterisk party subaddress.
742  * \since 1.8
743  *
744  * \param pri_subaddress PRI party subaddress structure.
745  * \param ast_subaddress Asterisk party subaddress structure.
746  *
747  * \return Nothing
748  *
749  * \note Assumes that pri_subaddress has been previously memset to zero.
750  */
751 static void sig_pri_party_subaddress_from_ast(struct pri_party_subaddress *pri_subaddress, const struct ast_party_subaddress *ast_subaddress)
752 {
753         if (ast_subaddress->valid && !ast_strlen_zero(ast_subaddress->str)) {
754                 pri_subaddress->type = ast_subaddress->type;
755                 if (!ast_subaddress->type) {
756                         /* 0 = NSAP */
757                         ast_copy_string((char *) pri_subaddress->data, ast_subaddress->str,
758                                 sizeof(pri_subaddress->data));
759                         pri_subaddress->length = strlen((char *) pri_subaddress->data);
760                         pri_subaddress->odd_even_indicator = 0;
761                         pri_subaddress->valid = 1;
762                 } else {
763                         /* 2 = User Specified */
764                         /*
765                          * Copy HexString to packed HexData,
766                          * if odd length then right pad trailing byte with 0
767                          */
768                         int length = ast_pri_pack_hex_string(pri_subaddress->data,
769                                 ast_subaddress->str, sizeof(pri_subaddress->data));
770
771                         pri_subaddress->length = length; /* packed data length */
772
773                         length = strlen(ast_subaddress->str);
774                         if (length > 2 * sizeof(pri_subaddress->data)) {
775                                 pri_subaddress->odd_even_indicator = 0;
776                         } else {
777                                 pri_subaddress->odd_even_indicator = (length & 1);
778                         }
779                         pri_subaddress->valid = 1;
780                 }
781         }
782 }
783 #endif  /* defined(HAVE_PRI_SUBADDR) */
784
785 /*!
786  * \internal
787  * \brief Fill in the PRI party name from the given asterisk party name.
788  * \since 1.8
789  *
790  * \param pri_name PRI party name structure.
791  * \param ast_name Asterisk party name structure.
792  *
793  * \return Nothing
794  *
795  * \note Assumes that pri_name has been previously memset to zero.
796  */
797 static void sig_pri_party_name_from_ast(struct pri_party_name *pri_name, const struct ast_party_name *ast_name)
798 {
799         if (!ast_name->valid) {
800                 return;
801         }
802         pri_name->valid = 1;
803         pri_name->presentation = ast_to_pri_presentation(ast_name->presentation);
804         pri_name->char_set = ast_to_pri_char_set(ast_name->char_set);
805         if (!ast_strlen_zero(ast_name->str)) {
806                 ast_copy_string(pri_name->str, ast_name->str, sizeof(pri_name->str));
807         }
808 }
809
810 /*!
811  * \internal
812  * \brief Fill in the PRI party number from the given asterisk party number.
813  * \since 1.8
814  *
815  * \param pri_number PRI party number structure.
816  * \param ast_number Asterisk party number structure.
817  *
818  * \return Nothing
819  *
820  * \note Assumes that pri_number has been previously memset to zero.
821  */
822 static void sig_pri_party_number_from_ast(struct pri_party_number *pri_number, const struct ast_party_number *ast_number)
823 {
824         if (!ast_number->valid) {
825                 return;
826         }
827         pri_number->valid = 1;
828         pri_number->presentation = ast_to_pri_presentation(ast_number->presentation);
829         pri_number->plan = ast_number->plan;
830         if (!ast_strlen_zero(ast_number->str)) {
831                 ast_copy_string(pri_number->str, ast_number->str, sizeof(pri_number->str));
832         }
833 }
834
835 /*!
836  * \internal
837  * \brief Fill in the PRI party id from the given asterisk party id.
838  * \since 1.8
839  *
840  * \param pri_id PRI party id structure.
841  * \param ast_id Asterisk party id structure.
842  *
843  * \return Nothing
844  *
845  * \note Assumes that pri_id has been previously memset to zero.
846  */
847 static void sig_pri_party_id_from_ast(struct pri_party_id *pri_id, const struct ast_party_id *ast_id)
848 {
849         sig_pri_party_name_from_ast(&pri_id->name, &ast_id->name);
850         sig_pri_party_number_from_ast(&pri_id->number, &ast_id->number);
851 #if defined(HAVE_PRI_SUBADDR)
852         sig_pri_party_subaddress_from_ast(&pri_id->subaddress, &ast_id->subaddress);
853 #endif  /* defined(HAVE_PRI_SUBADDR) */
854 }
855
856 /*!
857  * \internal
858  * \brief Update the PRI redirecting information for the current call.
859  * \since 1.8
860  *
861  * \param pvt sig_pri private channel structure.
862  * \param ast Asterisk channel
863  *
864  * \return Nothing
865  *
866  * \note Assumes that the PRI lock is already obtained.
867  */
868 static void sig_pri_redirecting_update(struct sig_pri_chan *pvt, struct ast_channel *ast)
869 {
870         struct pri_party_redirecting pri_redirecting;
871
872 /*! \todo XXX Original called data can be put in a channel data store that is inherited. */
873
874         memset(&pri_redirecting, 0, sizeof(pri_redirecting));
875         sig_pri_party_id_from_ast(&pri_redirecting.from, &ast->redirecting.from);
876         sig_pri_party_id_from_ast(&pri_redirecting.to, &ast->redirecting.to);
877         pri_redirecting.count = ast->redirecting.count;
878         pri_redirecting.reason = ast_to_pri_reason(ast->redirecting.reason);
879
880         pri_redirecting_update(pvt->pri->pri, pvt->call, &pri_redirecting);
881 }
882
883 /*!
884  * \internal
885  * \brief Reset DTMF detector.
886  * \since 1.8
887  *
888  * \param p sig_pri channel structure.
889  *
890  * \return Nothing
891  */
892 static void sig_pri_dsp_reset_and_flush_digits(struct sig_pri_chan *p)
893 {
894         if (p->calls->dsp_reset_and_flush_digits) {
895                 p->calls->dsp_reset_and_flush_digits(p->chan_pvt);
896         }
897 }
898
899 static int sig_pri_set_echocanceller(struct sig_pri_chan *p, int enable)
900 {
901         if (p->calls->set_echocanceller)
902                 return p->calls->set_echocanceller(p->chan_pvt, enable);
903         else
904                 return -1;
905 }
906
907 static void sig_pri_fixup_chans(struct sig_pri_chan *old_chan, struct sig_pri_chan *new_chan)
908 {
909         if (old_chan->calls->fixup_chans)
910                 old_chan->calls->fixup_chans(old_chan->chan_pvt, new_chan->chan_pvt);
911 }
912
913 static int sig_pri_play_tone(struct sig_pri_chan *p, enum sig_pri_tone tone)
914 {
915         if (p->calls->play_tone)
916                 return p->calls->play_tone(p->chan_pvt, tone);
917         else
918                 return -1;
919 }
920
921 static struct ast_channel *sig_pri_new_ast_channel(struct sig_pri_chan *p, int state, int ulaw, int transfercapability, char *exten, const struct ast_channel *requestor)
922 {
923         struct ast_channel *c;
924
925         if (p->calls->new_ast_channel) {
926                 c = p->calls->new_ast_channel(p->chan_pvt, state, ulaw, exten, requestor);
927         } else {
928                 return NULL;
929         }
930         if (!c) {
931                 return NULL;
932         }
933
934         if (!p->owner)
935                 p->owner = c;
936         p->isidlecall = 0;
937         p->alreadyhungup = 0;
938         c->transfercapability = transfercapability;
939         pbx_builtin_setvar_helper(c, "TRANSFERCAPABILITY",
940                 ast_transfercapability2str(transfercapability));
941         if (transfercapability & AST_TRANS_CAP_DIGITAL) {
942                 sig_pri_set_digital(p, 1);
943         }
944         if (p->pri) {
945                 ast_mutex_lock(&p->pri->lock);
946                 sig_pri_span_devstate_changed(p->pri);
947                 ast_mutex_unlock(&p->pri->lock);
948         }
949
950         return c;
951 }
952
953 /*!
954  * \internal
955  * \brief Open the PRI channel media path.
956  * \since 1.8
957  *
958  * \param p Channel private control structure.
959  *
960  * \return Nothing
961  */
962 static void sig_pri_open_media(struct sig_pri_chan *p)
963 {
964         if (p->no_b_channel) {
965                 return;
966         }
967
968         if (p->calls->open_media) {
969                 p->calls->open_media(p->chan_pvt);
970         }
971 }
972
973 /*!
974  * \internal
975  * \brief Post an AMI B channel association event.
976  * \since 1.8
977  *
978  * \param p Channel private control structure.
979  *
980  * \note Assumes the private and owner are locked.
981  *
982  * \return Nothing
983  */
984 static void sig_pri_ami_channel_event(struct sig_pri_chan *p)
985 {
986         if (p->calls->ami_channel_event) {
987                 p->calls->ami_channel_event(p->chan_pvt, p->owner);
988         }
989 }
990
991 struct ast_channel *sig_pri_request(struct sig_pri_chan *p, enum sig_pri_law law, const struct ast_channel *requestor, int transfercapability)
992 {
993         struct ast_channel *ast;
994
995         ast_debug(1, "%s %d\n", __FUNCTION__, p->channel);
996
997         p->outgoing = 1;
998         ast = sig_pri_new_ast_channel(p, AST_STATE_RESERVED, law, transfercapability, p->exten, requestor);
999         if (!ast) {
1000                 p->outgoing = 0;
1001         }
1002         return ast;
1003 }
1004
1005 int pri_is_up(struct sig_pri_span *pri)
1006 {
1007         int x;
1008         for (x = 0; x < SIG_PRI_NUM_DCHANS; x++) {
1009                 if (pri->dchanavail[x] == DCHAN_AVAILABLE)
1010                         return 1;
1011         }
1012         return 0;
1013 }
1014
1015 static const char *pri_order(int level)
1016 {
1017         switch (level) {
1018         case 0:
1019                 return "Primary";
1020         case 1:
1021                 return "Secondary";
1022         case 2:
1023                 return "Tertiary";
1024         case 3:
1025                 return "Quaternary";
1026         default:
1027                 return "<Unknown>";
1028         }
1029 }
1030
1031 /* Returns index of the active dchan */
1032 static int pri_active_dchan_index(struct sig_pri_span *pri)
1033 {
1034         int x;
1035
1036         for (x = 0; x < SIG_PRI_NUM_DCHANS; x++) {
1037                 if ((pri->dchans[x] == pri->pri))
1038                         return x;
1039         }
1040
1041         ast_log(LOG_WARNING, "No active dchan found!\n");
1042         return -1;
1043 }
1044
1045 static void pri_find_dchan(struct sig_pri_span *pri)
1046 {
1047         struct pri *old;
1048         int oldslot = -1;
1049         int newslot = -1;
1050         int idx;
1051
1052         old = pri->pri;
1053         for (idx = 0; idx < SIG_PRI_NUM_DCHANS; ++idx) {
1054                 if (!pri->dchans[idx]) {
1055                         /* No more D channels defined on the span. */
1056                         break;
1057                 }
1058                 if (pri->dchans[idx] == old) {
1059                         oldslot = idx;
1060                 }
1061                 if (newslot < 0 && pri->dchanavail[idx] == DCHAN_AVAILABLE) {
1062                         newslot = idx;
1063                 }
1064         }
1065         /* At this point, idx is a count of how many D-channels are defined on the span. */
1066
1067         if (1 < idx) {
1068                 /* We have several D-channels defined on the span.  (NFAS PRI setup) */
1069                 if (newslot < 0) {
1070                         /* No D-channels available.  Default to the primary D-channel. */
1071                         newslot = 0;
1072
1073                         if (!pri->no_d_channels) {
1074                                 pri->no_d_channels = 1;
1075                                 if (old && oldslot != newslot) {
1076                                         ast_log(LOG_WARNING,
1077                                                 "Span %d: No D-channels up!  Switching selected D-channel from %s to %s.\n",
1078                                                 pri->span, pri_order(oldslot), pri_order(newslot));
1079                                 } else {
1080                                         ast_log(LOG_WARNING, "Span %d: No D-channels up!\n", pri->span);
1081                                 }
1082                         }
1083                 } else {
1084                         pri->no_d_channels = 0;
1085                 }
1086                 if (old && oldslot != newslot) {
1087                         ast_log(LOG_NOTICE,
1088                                 "Switching selected D-channel from %s (fd %d) to %s (fd %d)!\n",
1089                                 pri_order(oldslot), pri->fds[oldslot],
1090                                 pri_order(newslot), pri->fds[newslot]);
1091                 }
1092         } else {
1093                 if (newslot < 0) {
1094                         /* The only D-channel is not up. */
1095                         newslot = 0;
1096
1097                         if (!pri->no_d_channels) {
1098                                 pri->no_d_channels = 1;
1099
1100                                 /*
1101                                  * This is annoying to see on non-persistent layer 2
1102                                  * connections.  Let's not complain in that case.
1103                                  */
1104                                 if (pri->sig != SIG_BRI_PTMP) {
1105                                         ast_log(LOG_WARNING, "Span %d: D-channel is down!\n", pri->span);
1106                                 }
1107                         }
1108                 } else {
1109                         pri->no_d_channels = 0;
1110                 }
1111         }
1112         pri->pri = pri->dchans[newslot];
1113 }
1114
1115 /*!
1116  * \internal
1117  * \brief Determine if a private channel structure is in use.
1118  * \since 1.8
1119  *
1120  * \param pvt Channel to determine if in use.
1121  *
1122  * \return TRUE if the channel is in use.
1123  */
1124 static int sig_pri_is_chan_in_use(struct sig_pri_chan *pvt)
1125 {
1126         return pvt->owner || pvt->call || pvt->allocated || pvt->resetting || pvt->inalarm;
1127 }
1128
1129 /*!
1130  * \brief Determine if a private channel structure is available.
1131  * \since 1.8
1132  *
1133  * \param pvt Channel to determine if available.
1134  *
1135  * \return TRUE if the channel is available.
1136  */
1137 int sig_pri_is_chan_available(struct sig_pri_chan *pvt)
1138 {
1139         return !sig_pri_is_chan_in_use(pvt)
1140 #if defined(HAVE_PRI_SERVICE_MESSAGES)
1141                 /* And not out-of-service */
1142                 && !pvt->service_status
1143 #endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
1144                 ;
1145 }
1146
1147 /*!
1148  * \internal
1149  * \brief Obtain the sig_pri owner channel lock if the owner exists.
1150  * \since 1.8
1151  *
1152  * \param pri PRI span control structure.
1153  * \param chanpos Channel position in the span.
1154  *
1155  * \note Assumes the pri->lock is already obtained.
1156  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
1157  *
1158  * \return Nothing
1159  */
1160 static void sig_pri_lock_owner(struct sig_pri_span *pri, int chanpos)
1161 {
1162         for (;;) {
1163                 if (!pri->pvts[chanpos]->owner) {
1164                         /* There is no owner lock to get. */
1165                         break;
1166                 }
1167                 if (!ast_channel_trylock(pri->pvts[chanpos]->owner)) {
1168                         /* We got the lock */
1169                         break;
1170                 }
1171                 /* We must unlock the PRI to avoid the possibility of a deadlock */
1172                 ast_mutex_unlock(&pri->lock);
1173                 sig_pri_deadlock_avoidance_private(pri->pvts[chanpos]);
1174                 ast_mutex_lock(&pri->lock);
1175         }
1176 }
1177
1178 /*!
1179  * \internal
1180  * \brief Queue the given frame onto the owner channel.
1181  * \since 1.8
1182  *
1183  * \param pri PRI span control structure.
1184  * \param chanpos Channel position in the span.
1185  * \param frame Frame to queue onto the owner channel.
1186  *
1187  * \note Assumes the pri->lock is already obtained.
1188  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
1189  *
1190  * \return Nothing
1191  */
1192 static void pri_queue_frame(struct sig_pri_span *pri, int chanpos, struct ast_frame *frame)
1193 {
1194         sig_pri_lock_owner(pri, chanpos);
1195         if (pri->pvts[chanpos]->owner) {
1196                 ast_queue_frame(pri->pvts[chanpos]->owner, frame);
1197                 ast_channel_unlock(pri->pvts[chanpos]->owner);
1198         }
1199 }
1200
1201 /*!
1202  * \internal
1203  * \brief Queue a control frame of the specified subclass onto the owner channel.
1204  * \since 1.8
1205  *
1206  * \param pri PRI span control structure.
1207  * \param chanpos Channel position in the span.
1208  * \param subclass Control frame subclass to queue onto the owner channel.
1209  *
1210  * \note Assumes the pri->lock is already obtained.
1211  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
1212  *
1213  * \return Nothing
1214  */
1215 static void pri_queue_control(struct sig_pri_span *pri, int chanpos, int subclass)
1216 {
1217         struct ast_frame f = {AST_FRAME_CONTROL, };
1218         struct sig_pri_chan *p = pri->pvts[chanpos];
1219
1220         if (p->calls->queue_control) {
1221                 p->calls->queue_control(p->chan_pvt, subclass);
1222         }
1223
1224         f.subclass.integer = subclass;
1225         pri_queue_frame(pri, chanpos, &f);
1226 }
1227
1228 /*!
1229  * \internal
1230  * \brief Find the channel associated with the libpri call.
1231  * \since 10.0
1232  *
1233  * \param pri PRI span control structure.
1234  * \param call LibPRI opaque call pointer to find.
1235  *
1236  * \note Assumes the pri->lock is already obtained.
1237  *
1238  * \retval array-index into private pointer array on success.
1239  * \retval -1 on error.
1240  */
1241 static int pri_find_principle_by_call(struct sig_pri_span *pri, q931_call *call)
1242 {
1243         int idx;
1244
1245         if (!call) {
1246                 /* Cannot find a call without a call. */
1247                 return -1;
1248         }
1249         for (idx = 0; idx < pri->numchans; ++idx) {
1250                 if (pri->pvts[idx] && pri->pvts[idx]->call == call) {
1251                         /* Found the principle */
1252                         return idx;
1253                 }
1254         }
1255         return -1;
1256 }
1257
1258 /*!
1259  * \internal
1260  * \brief Kill the call.
1261  * \since 10.0
1262  *
1263  * \param pri PRI span control structure.
1264  * \param call LibPRI opaque call pointer to find.
1265  * \param cause Reason call was killed.
1266  *
1267  * \note Assumes the pvt->pri->lock is already obtained.
1268  *
1269  * \return Nothing
1270  */
1271 static void sig_pri_kill_call(struct sig_pri_span *pri, q931_call *call, int cause)
1272 {
1273         int chanpos;
1274
1275         chanpos = pri_find_principle_by_call(pri, call);
1276         if (chanpos < 0) {
1277                 pri_hangup(pri->pri, call, cause);
1278                 return;
1279         }
1280         sig_pri_lock_private(pri->pvts[chanpos]);
1281         if (!pri->pvts[chanpos]->owner) {
1282                 pri_hangup(pri->pri, call, cause);
1283                 pri->pvts[chanpos]->call = NULL;
1284                 sig_pri_unlock_private(pri->pvts[chanpos]);
1285                 sig_pri_span_devstate_changed(pri);
1286                 return;
1287         }
1288         pri->pvts[chanpos]->owner->hangupcause = cause;
1289         pri_queue_control(pri, chanpos, AST_CONTROL_HANGUP);
1290         sig_pri_unlock_private(pri->pvts[chanpos]);
1291 }
1292
1293 /*!
1294  * \internal
1295  * \brief Find the private structure for the libpri call.
1296  *
1297  * \param pri PRI span control structure.
1298  * \param channel LibPRI encoded channel ID.
1299  * \param call LibPRI opaque call pointer.
1300  *
1301  * \note Assumes the pri->lock is already obtained.
1302  *
1303  * \retval array-index into private pointer array on success.
1304  * \retval -1 on error.
1305  */
1306 static int pri_find_principle(struct sig_pri_span *pri, int channel, q931_call *call)
1307 {
1308         int x;
1309         int span;
1310         int principle;
1311         int prioffset;
1312
1313         if (channel < 0) {
1314                 /* Channel is not picked yet. */
1315                 return -1;
1316         }
1317
1318         prioffset = PRI_CHANNEL(channel);
1319         if (!prioffset || (channel & PRI_HELD_CALL)) {
1320                 /* Find the call waiting call or held call. */
1321                 return pri_find_principle_by_call(pri, call);
1322         }
1323
1324         span = PRI_SPAN(channel);
1325         if (!(channel & PRI_EXPLICIT)) {
1326                 int index;
1327
1328                 index = pri_active_dchan_index(pri);
1329                 if (index == -1) {
1330                         return -1;
1331                 }
1332                 span = pri->dchan_logical_span[index];
1333         }
1334
1335         principle = -1;
1336         for (x = 0; x < pri->numchans; x++) {
1337                 if (pri->pvts[x]
1338                         && pri->pvts[x]->prioffset == prioffset
1339                         && pri->pvts[x]->logicalspan == span
1340                         && !pri->pvts[x]->no_b_channel) {
1341                         principle = x;
1342                         break;
1343                 }
1344         }
1345
1346         return principle;
1347 }
1348
1349 /*!
1350  * \internal
1351  * \brief Fixup the private structure associated with the libpri call.
1352  *
1353  * \param pri PRI span control structure.
1354  * \param principle Array-index into private array to move call to if not already there.
1355  * \param call LibPRI opaque call pointer to find if need to move call.
1356  *
1357  * \note Assumes the pri->lock is already obtained.
1358  *
1359  * \retval principle on success.
1360  * \retval -1 on error.
1361  */
1362 static int pri_fixup_principle(struct sig_pri_span *pri, int principle, q931_call *call)
1363 {
1364         int x;
1365
1366         if (principle < 0 || pri->numchans <= principle) {
1367                 /* Out of rannge */
1368                 return -1;
1369         }
1370         if (!call) {
1371                 /* No call */
1372                 return principle;
1373         }
1374         if (pri->pvts[principle] && pri->pvts[principle]->call == call) {
1375                 /* Call is already on the specified principle. */
1376                 return principle;
1377         }
1378
1379         /* Find the old principle location. */
1380         for (x = 0; x < pri->numchans; x++) {
1381                 struct sig_pri_chan *new_chan;
1382                 struct sig_pri_chan *old_chan;
1383
1384                 if (!pri->pvts[x] || pri->pvts[x]->call != call) {
1385                         continue;
1386                 }
1387
1388                 /* Found our call */
1389                 new_chan = pri->pvts[principle];
1390                 old_chan = pri->pvts[x];
1391
1392                 /* Get locks to safely move to the new private structure. */
1393                 sig_pri_lock_private(old_chan);
1394                 sig_pri_lock_owner(pri, x);
1395                 sig_pri_lock_private(new_chan);
1396
1397                 ast_verb(3, "Moving call (%s) from channel %d to %d.\n",
1398                         old_chan->owner ? ast_channel_name(old_chan->owner) : "",
1399                         old_chan->channel, new_chan->channel);
1400                 if (!sig_pri_is_chan_available(new_chan)) {
1401                         ast_log(LOG_WARNING,
1402                                 "Can't move call (%s) from channel %d to %d.  It is already in use.\n",
1403                                 old_chan->owner ? ast_channel_name(old_chan->owner) : "",
1404                                 old_chan->channel, new_chan->channel);
1405                         sig_pri_unlock_private(new_chan);
1406                         if (old_chan->owner) {
1407                                 ast_channel_unlock(old_chan->owner);
1408                         }
1409                         sig_pri_unlock_private(old_chan);
1410                         return -1;
1411                 }
1412
1413                 sig_pri_fixup_chans(old_chan, new_chan);
1414
1415                 /* Fix it all up now */
1416                 new_chan->owner = old_chan->owner;
1417                 old_chan->owner = NULL;
1418
1419                 new_chan->call = old_chan->call;
1420                 old_chan->call = NULL;
1421
1422                 /* Transfer flags from the old channel. */
1423 #if defined(HAVE_PRI_AOC_EVENTS)
1424                 new_chan->aoc_s_request_invoke_id_valid = old_chan->aoc_s_request_invoke_id_valid;
1425                 new_chan->waiting_for_aoce = old_chan->waiting_for_aoce;
1426                 new_chan->holding_aoce = old_chan->holding_aoce;
1427 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
1428                 new_chan->alreadyhungup = old_chan->alreadyhungup;
1429                 new_chan->isidlecall = old_chan->isidlecall;
1430                 new_chan->progress = old_chan->progress;
1431                 new_chan->allocated = old_chan->allocated;
1432                 new_chan->outgoing = old_chan->outgoing;
1433                 new_chan->digital = old_chan->digital;
1434 #if defined(HAVE_PRI_CALL_WAITING)
1435                 new_chan->is_call_waiting = old_chan->is_call_waiting;
1436 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
1437
1438 #if defined(HAVE_PRI_AOC_EVENTS)
1439                 old_chan->aoc_s_request_invoke_id_valid = 0;
1440                 old_chan->waiting_for_aoce = 0;
1441                 old_chan->holding_aoce = 0;
1442 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
1443                 old_chan->alreadyhungup = 0;
1444                 old_chan->isidlecall = 0;
1445                 old_chan->progress = 0;
1446                 old_chan->allocated = 0;
1447                 old_chan->outgoing = 0;
1448                 old_chan->digital = 0;
1449 #if defined(HAVE_PRI_CALL_WAITING)
1450                 old_chan->is_call_waiting = 0;
1451 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
1452
1453                 /* More stuff to transfer to the new channel. */
1454                 new_chan->call_level = old_chan->call_level;
1455                 old_chan->call_level = SIG_PRI_CALL_LEVEL_IDLE;
1456 #if defined(HAVE_PRI_REVERSE_CHARGE)
1457                 new_chan->reverse_charging_indication = old_chan->reverse_charging_indication;
1458 #endif  /* defined(HAVE_PRI_REVERSE_CHARGE) */
1459 #if defined(HAVE_PRI_SETUP_KEYPAD)
1460                 strcpy(new_chan->keypad_digits, old_chan->keypad_digits);
1461 #endif  /* defined(HAVE_PRI_SETUP_KEYPAD) */
1462                 strcpy(new_chan->moh_suggested, old_chan->moh_suggested);
1463                 new_chan->moh_state = old_chan->moh_state;
1464                 old_chan->moh_state = SIG_PRI_MOH_STATE_IDLE;
1465
1466 #if defined(HAVE_PRI_AOC_EVENTS)
1467                 new_chan->aoc_s_request_invoke_id = old_chan->aoc_s_request_invoke_id;
1468                 new_chan->aoc_e = old_chan->aoc_e;
1469 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
1470                 strcpy(new_chan->user_tag, old_chan->user_tag);
1471
1472                 if (new_chan->no_b_channel) {
1473                         /* Copy the real channel configuration to the no B channel interface. */
1474                         new_chan->hidecallerid = old_chan->hidecallerid;
1475                         new_chan->hidecalleridname = old_chan->hidecalleridname;
1476                         new_chan->immediate = old_chan->immediate;
1477                         new_chan->priexclusive = old_chan->priexclusive;
1478                         new_chan->priindication_oob = old_chan->priindication_oob;
1479                         new_chan->use_callerid = old_chan->use_callerid;
1480                         new_chan->use_callingpres = old_chan->use_callingpres;
1481                         new_chan->stripmsd = old_chan->stripmsd;
1482                         strcpy(new_chan->context, old_chan->context);
1483                         strcpy(new_chan->mohinterpret, old_chan->mohinterpret);
1484
1485                         /* Become a member of the old channel span/trunk-group. */
1486                         new_chan->logicalspan = old_chan->logicalspan;
1487                         new_chan->mastertrunkgroup = old_chan->mastertrunkgroup;
1488                 } else if (old_chan->no_b_channel) {
1489                         /*
1490                          * We are transitioning from a held/call-waiting channel to a
1491                          * real channel so we need to make sure that the media path is
1492                          * open.  (Needed especially if the channel is natively
1493                          * bridged.)
1494                          */
1495                         sig_pri_open_media(new_chan);
1496                 }
1497
1498                 if (new_chan->owner) {
1499                         sig_pri_ami_channel_event(new_chan);
1500                 }
1501
1502                 sig_pri_unlock_private(old_chan);
1503                 if (new_chan->owner) {
1504                         ast_channel_unlock(new_chan->owner);
1505                 }
1506                 sig_pri_unlock_private(new_chan);
1507
1508                 return principle;
1509         }
1510         ast_verb(3, "Call specified, but not found.\n");
1511         return -1;
1512 }
1513
1514 /*!
1515  * \internal
1516  * \brief Find and fixup the private structure associated with the libpri call.
1517  *
1518  * \param pri PRI span control structure.
1519  * \param channel LibPRI encoded channel ID.
1520  * \param call LibPRI opaque call pointer.
1521  *
1522  * \details
1523  * This is a combination of pri_find_principle() and pri_fixup_principle()
1524  * to reduce code redundancy and to make handling several PRI_EVENT_xxx's
1525  * consistent for the current architecture.
1526  *
1527  * \note Assumes the pri->lock is already obtained.
1528  *
1529  * \retval array-index into private pointer array on success.
1530  * \retval -1 on error.
1531  */
1532 static int pri_find_fixup_principle(struct sig_pri_span *pri, int channel, q931_call *call)
1533 {
1534         int chanpos;
1535
1536         chanpos = pri_find_principle(pri, channel, call);
1537         if (chanpos < 0) {
1538                 ast_log(LOG_WARNING, "Span %d: PRI requested channel %d/%d is unconfigured.\n",
1539                         pri->span, PRI_SPAN(channel), PRI_CHANNEL(channel));
1540                 sig_pri_kill_call(pri, call, PRI_CAUSE_IDENTIFIED_CHANNEL_NOTEXIST);
1541                 return -1;
1542         }
1543         chanpos = pri_fixup_principle(pri, chanpos, call);
1544         if (chanpos < 0) {
1545                 ast_log(LOG_WARNING, "Span %d: PRI requested channel %d/%d is not available.\n",
1546                         pri->span, PRI_SPAN(channel), PRI_CHANNEL(channel));
1547                 /*
1548                  * Using Q.931 section 5.2.3.1 b) as the reason for picking
1549                  * PRI_CAUSE_CHANNEL_UNACCEPTABLE.  Receiving a
1550                  * PRI_CAUSE_REQUESTED_CHAN_UNAVAIL would cause us to restart
1551                  * that channel (which is not specified by Q.931) and kill some
1552                  * other call which would be bad.
1553                  */
1554                 sig_pri_kill_call(pri, call, PRI_CAUSE_CHANNEL_UNACCEPTABLE);
1555                 return -1;
1556         }
1557         return chanpos;
1558 }
1559
1560 static char * redirectingreason2str(int redirectingreason)
1561 {
1562         switch (redirectingreason) {
1563         case 0:
1564                 return "UNKNOWN";
1565         case 1:
1566                 return "BUSY";
1567         case 2:
1568                 return "NO_REPLY";
1569         case 0xF:
1570                 return "UNCONDITIONAL";
1571         default:
1572                 return "NOREDIRECT";
1573         }
1574 }
1575
1576 static char *dialplan2str(int dialplan)
1577 {
1578         if (dialplan == -1) {
1579                 return("Dynamically set dialplan in ISDN");
1580         }
1581         return (pri_plan2str(dialplan));
1582 }
1583
1584 /*!
1585  * \internal
1586  * \brief Apply numbering plan prefix to the given number.
1587  *
1588  * \param buf Buffer to put number into.
1589  * \param size Size of given buffer.
1590  * \param pri PRI span control structure.
1591  * \param number Number to apply numbering plan.
1592  * \param plan Numbering plan to apply.
1593  *
1594  * \return Nothing
1595  */
1596 static void apply_plan_to_number(char *buf, size_t size, const struct sig_pri_span *pri, const char *number, int plan)
1597 {
1598         switch (plan) {
1599         case PRI_INTERNATIONAL_ISDN:            /* Q.931 dialplan == 0x11 international dialplan => prepend international prefix digits */
1600                 snprintf(buf, size, "%s%s", pri->internationalprefix, number);
1601                 break;
1602         case PRI_NATIONAL_ISDN:                 /* Q.931 dialplan == 0x21 national dialplan => prepend national prefix digits */
1603                 snprintf(buf, size, "%s%s", pri->nationalprefix, number);
1604                 break;
1605         case PRI_LOCAL_ISDN:                    /* Q.931 dialplan == 0x41 local dialplan => prepend local prefix digits */
1606                 snprintf(buf, size, "%s%s", pri->localprefix, number);
1607                 break;
1608         case PRI_PRIVATE:                       /* Q.931 dialplan == 0x49 private dialplan => prepend private prefix digits */
1609                 snprintf(buf, size, "%s%s", pri->privateprefix, number);
1610                 break;
1611         case PRI_UNKNOWN:                       /* Q.931 dialplan == 0x00 unknown dialplan => prepend unknown prefix digits */
1612                 snprintf(buf, size, "%s%s", pri->unknownprefix, number);
1613                 break;
1614         default:                                /* other Q.931 dialplan => don't twiddle with callingnum */
1615                 snprintf(buf, size, "%s", number);
1616                 break;
1617         }
1618 }
1619
1620 /*!
1621  * \internal
1622  * \brief Apply numbering plan prefix to the given number if the number exists.
1623  *
1624  * \param buf Buffer to put number into.
1625  * \param size Size of given buffer.
1626  * \param pri PRI span control structure.
1627  * \param number Number to apply numbering plan.
1628  * \param plan Numbering plan to apply.
1629  *
1630  * \return Nothing
1631  */
1632 static void apply_plan_to_existing_number(char *buf, size_t size, const struct sig_pri_span *pri, const char *number, int plan)
1633 {
1634         /* Make sure a number exists so the prefix isn't placed on an empty string. */
1635         if (ast_strlen_zero(number)) {
1636                 if (size) {
1637                         *buf = '\0';
1638                 }
1639                 return;
1640         }
1641         apply_plan_to_number(buf, size, pri, number, plan);
1642 }
1643
1644 /*!
1645  * \internal
1646  * \brief Restart the next channel we think is idle on the span.
1647  *
1648  * \param pri PRI span control structure.
1649  *
1650  * \note Assumes the pri->lock is already obtained.
1651  *
1652  * \return Nothing
1653  */
1654 static void pri_check_restart(struct sig_pri_span *pri)
1655 {
1656 #if defined(HAVE_PRI_SERVICE_MESSAGES)
1657         unsigned why;
1658 #endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
1659
1660         for (++pri->resetpos; pri->resetpos < pri->numchans; ++pri->resetpos) {
1661                 if (!pri->pvts[pri->resetpos]
1662                         || pri->pvts[pri->resetpos]->no_b_channel
1663                         || sig_pri_is_chan_in_use(pri->pvts[pri->resetpos])) {
1664                         continue;
1665                 }
1666 #if defined(HAVE_PRI_SERVICE_MESSAGES)
1667                 why = pri->pvts[pri->resetpos]->service_status;
1668                 if (why) {
1669                         ast_log(LOG_NOTICE,
1670                                 "Span %d: channel %d out-of-service (reason: %s), not sending RESTART\n",
1671                                 pri->span, pri->pvts[pri->resetpos]->channel,
1672                                 (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end");
1673                         continue;
1674                 }
1675 #endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
1676                 break;
1677         }
1678         if (pri->resetpos < pri->numchans) {
1679                 /* Mark the channel as resetting and restart it */
1680                 pri->pvts[pri->resetpos]->resetting = 1;
1681                 pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[pri->resetpos]));
1682         } else {
1683                 pri->resetting = 0;
1684                 time(&pri->lastreset);
1685                 sig_pri_span_devstate_changed(pri);
1686         }
1687 }
1688
1689 #if defined(HAVE_PRI_CALL_WAITING)
1690 /*!
1691  * \internal
1692  * \brief Init the private channel configuration using the span controller.
1693  * \since 1.8
1694  *
1695  * \param pvt Channel to init the configuration.
1696  * \param pri PRI span control structure.
1697  *
1698  * \note Assumes the pri->lock is already obtained.
1699  *
1700  * \return Nothing
1701  */
1702 static void sig_pri_init_config(struct sig_pri_chan *pvt, struct sig_pri_span *pri)
1703 {
1704         pvt->stripmsd = pri->ch_cfg.stripmsd;
1705         pvt->hidecallerid = pri->ch_cfg.hidecallerid;
1706         pvt->hidecalleridname = pri->ch_cfg.hidecalleridname;
1707         pvt->immediate = pri->ch_cfg.immediate;
1708         pvt->priexclusive = pri->ch_cfg.priexclusive;
1709         pvt->priindication_oob = pri->ch_cfg.priindication_oob;
1710         pvt->use_callerid = pri->ch_cfg.use_callerid;
1711         pvt->use_callingpres = pri->ch_cfg.use_callingpres;
1712         ast_copy_string(pvt->context, pri->ch_cfg.context, sizeof(pvt->context));
1713         ast_copy_string(pvt->mohinterpret, pri->ch_cfg.mohinterpret, sizeof(pvt->mohinterpret));
1714
1715         if (pri->calls->init_config) {
1716                 pri->calls->init_config(pvt->chan_pvt, pri);
1717         }
1718 }
1719 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
1720
1721 /*!
1722  * \internal
1723  * \brief Find an empty B-channel interface to use.
1724  *
1725  * \param pri PRI span control structure.
1726  * \param backwards TRUE if the search starts from higher channels.
1727  *
1728  * \note Assumes the pri->lock is already obtained.
1729  *
1730  * \retval array-index into private pointer array on success.
1731  * \retval -1 on error.
1732  */
1733 static int pri_find_empty_chan(struct sig_pri_span *pri, int backwards)
1734 {
1735         int x;
1736         if (backwards)
1737                 x = pri->numchans;
1738         else
1739                 x = 0;
1740         for (;;) {
1741                 if (backwards && (x < 0))
1742                         break;
1743                 if (!backwards && (x >= pri->numchans))
1744                         break;
1745                 if (pri->pvts[x]
1746                         && !pri->pvts[x]->no_b_channel
1747                         && sig_pri_is_chan_available(pri->pvts[x])) {
1748                         ast_debug(1, "Found empty available channel %d/%d\n",
1749                                 pri->pvts[x]->logicalspan, pri->pvts[x]->prioffset);
1750                         return x;
1751                 }
1752                 if (backwards)
1753                         x--;
1754                 else
1755                         x++;
1756         }
1757         return -1;
1758 }
1759
1760 #if defined(HAVE_PRI_CALL_HOLD)
1761 /*!
1762  * \internal
1763  * \brief Find or create an empty no-B-channel interface to use.
1764  * \since 1.8
1765  *
1766  * \param pri PRI span control structure.
1767  *
1768  * \note Assumes the pri->lock is already obtained.
1769  *
1770  * \retval array-index into private pointer array on success.
1771  * \retval -1 on error.
1772  */
1773 static int pri_find_empty_nobch(struct sig_pri_span *pri)
1774 {
1775         int idx;
1776
1777         for (idx = 0; idx < pri->numchans; ++idx) {
1778                 if (pri->pvts[idx]
1779                         && pri->pvts[idx]->no_b_channel
1780                         && sig_pri_is_chan_available(pri->pvts[idx])) {
1781                         ast_debug(1, "Found empty available no B channel interface\n");
1782                         return idx;
1783                 }
1784         }
1785
1786         /* Need to create a new interface. */
1787         if (pri->calls->new_nobch_intf) {
1788                 idx = pri->calls->new_nobch_intf(pri);
1789         } else {
1790                 idx = -1;
1791         }
1792         return idx;
1793 }
1794 #endif  /* defined(HAVE_PRI_CALL_HOLD) */
1795
1796 static void *do_idle_thread(void *v_pvt)
1797 {
1798         struct sig_pri_chan *pvt = v_pvt;
1799         struct ast_channel *chan = pvt->owner;
1800         struct ast_frame *f;
1801         char ex[80];
1802         /* Wait up to 30 seconds for an answer */
1803         int newms, ms = 30000;
1804
1805         ast_verb(3, "Initiating idle call on channel %s\n", ast_channel_name(chan));
1806         snprintf(ex, sizeof(ex), "%d/%s", pvt->channel, pvt->pri->idledial);
1807         if (ast_call(chan, ex, 0)) {
1808                 ast_log(LOG_WARNING, "Idle dial failed on '%s' to '%s'\n", ast_channel_name(chan), ex);
1809                 ast_hangup(chan);
1810                 return NULL;
1811         }
1812         while ((newms = ast_waitfor(chan, ms)) > 0) {
1813                 f = ast_read(chan);
1814                 if (!f) {
1815                         /* Got hangup */
1816                         break;
1817                 }
1818                 if (f->frametype == AST_FRAME_CONTROL) {
1819                         switch (f->subclass.integer) {
1820                         case AST_CONTROL_ANSWER:
1821                                 /* Launch the PBX */
1822                                 ast_copy_string(chan->exten, pvt->pri->idleext, sizeof(chan->exten));
1823                                 ast_copy_string(chan->context, pvt->pri->idlecontext, sizeof(chan->context));
1824                                 chan->priority = 1;
1825                                 ast_verb(4, "Idle channel '%s' answered, sending to %s@%s\n", ast_channel_name(chan), chan->exten, chan->context);
1826                                 ast_pbx_run(chan);
1827                                 /* It's already hungup, return immediately */
1828                                 return NULL;
1829                         case AST_CONTROL_BUSY:
1830                                 ast_verb(4, "Idle channel '%s' busy, waiting...\n", ast_channel_name(chan));
1831                                 break;
1832                         case AST_CONTROL_CONGESTION:
1833                                 ast_verb(4, "Idle channel '%s' congested, waiting...\n", ast_channel_name(chan));
1834                                 break;
1835                         };
1836                 }
1837                 ast_frfree(f);
1838                 ms = newms;
1839         }
1840         /* Hangup the channel since nothing happend */
1841         ast_hangup(chan);
1842         return NULL;
1843 }
1844
1845 static void *pri_ss_thread(void *data)
1846 {
1847         struct sig_pri_chan *p = data;
1848         struct ast_channel *chan = p->owner;
1849         char exten[AST_MAX_EXTENSION];
1850         int res;
1851         int len;
1852         int timeout;
1853
1854         if (!chan) {
1855                 /* We lost the owner before we could get started. */
1856                 return NULL;
1857         }
1858
1859         /*
1860          * In the bizarre case where the channel has become a zombie before we
1861          * even get started here, abort safely.
1862          */
1863         if (!chan->tech_pvt) {
1864                 ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", ast_channel_name(chan));
1865                 ast_hangup(chan);
1866                 return NULL;
1867         }
1868
1869         ast_verb(3, "Starting simple switch on '%s'\n", ast_channel_name(chan));
1870
1871         sig_pri_dsp_reset_and_flush_digits(p);
1872
1873         /* Now loop looking for an extension */
1874         ast_copy_string(exten, p->exten, sizeof(exten));
1875         len = strlen(exten);
1876         res = 0;
1877         while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
1878                 if (len && !ast_ignore_pattern(chan->context, exten))
1879                         sig_pri_play_tone(p, -1);
1880                 else
1881                         sig_pri_play_tone(p, SIG_PRI_TONE_DIALTONE);
1882                 if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num))
1883                         timeout = pri_matchdigittimeout;
1884                 else
1885                         timeout = pri_gendigittimeout;
1886                 res = ast_waitfordigit(chan, timeout);
1887                 if (res < 0) {
1888                         ast_debug(1, "waitfordigit returned < 0...\n");
1889                         ast_hangup(chan);
1890                         return NULL;
1891                 } else if (res) {
1892                         exten[len++] = res;
1893                         exten[len] = '\0';
1894                 } else
1895                         break;
1896         }
1897         /* if no extension was received ('unspecified') on overlap call, use the 's' extension */
1898         if (ast_strlen_zero(exten)) {
1899                 ast_verb(3, "Going to extension s|1 because of empty extension received on overlap call\n");
1900                 exten[0] = 's';
1901                 exten[1] = '\0';
1902         } else {
1903                 ast_free(chan->dialed.number.str);
1904                 chan->dialed.number.str = ast_strdup(exten);
1905
1906                 if (p->pri->append_msn_to_user_tag && p->pri->nodetype != PRI_NETWORK) {
1907                         /*
1908                          * Update the user tag for party id's from this device for this call
1909                          * now that we have a complete MSN from the network.
1910                          */
1911                         snprintf(p->user_tag, sizeof(p->user_tag), "%s_%s", p->pri->initial_user_tag,
1912                                 exten);
1913                         ast_free(chan->caller.id.tag);
1914                         chan->caller.id.tag = ast_strdup(p->user_tag);
1915                 }
1916         }
1917         sig_pri_play_tone(p, -1);
1918         if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) {
1919                 /* Start the real PBX */
1920                 ast_copy_string(chan->exten, exten, sizeof(chan->exten));
1921                 sig_pri_dsp_reset_and_flush_digits(p);
1922 #if defined(ISSUE_16789)
1923                 /*
1924                  * Conditionaled out this code to effectively revert the Mantis
1925                  * issue 16789 change.  It breaks overlap dialing through
1926                  * Asterisk.  There is not enough information available at this
1927                  * point to know if dialing is complete.  The
1928                  * ast_exists_extension(), ast_matchmore_extension(), and
1929                  * ast_canmatch_extension() calls are not adequate to detect a
1930                  * dial through extension pattern of "_9!".
1931                  *
1932                  * Workaround is to use the dialplan Proceeding() application
1933                  * early on non-dial through extensions.
1934                  */
1935                 if ((p->pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)
1936                         && !ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
1937                         sig_pri_lock_private(p);
1938                         if (p->pri->pri) {
1939                                 pri_grab(p, p->pri);
1940                                 if (p->call_level < SIG_PRI_CALL_LEVEL_PROCEEDING) {
1941                                         p->call_level = SIG_PRI_CALL_LEVEL_PROCEEDING;
1942                                 }
1943                                 pri_proceeding(p->pri->pri, p->call, PVT_TO_CHANNEL(p), 0);
1944                                 pri_rel(p->pri);
1945                         }
1946                         sig_pri_unlock_private(p);
1947                 }
1948 #endif  /* defined(ISSUE_16789) */
1949
1950                 sig_pri_set_echocanceller(p, 1);
1951                 ast_setstate(chan, AST_STATE_RING);
1952                 res = ast_pbx_run(chan);
1953                 if (res) {
1954                         ast_log(LOG_WARNING, "PBX exited non-zero!\n");
1955                 }
1956         } else {
1957                 ast_debug(1, "No such possible extension '%s' in context '%s'\n", exten, chan->context);
1958                 chan->hangupcause = AST_CAUSE_UNALLOCATED;
1959                 ast_hangup(chan);
1960                 p->exten[0] = '\0';
1961                 /* Since we send release complete here, we won't get one */
1962                 p->call = NULL;
1963                 ast_mutex_lock(&p->pri->lock);
1964                 sig_pri_span_devstate_changed(p->pri);
1965                 ast_mutex_unlock(&p->pri->lock);
1966         }
1967         return NULL;
1968 }
1969
1970 void pri_event_alarm(struct sig_pri_span *pri, int index, int before_start_pri)
1971 {
1972         pri->dchanavail[index] &= ~(DCHAN_NOTINALARM | DCHAN_UP);
1973         if (!before_start_pri) {
1974                 pri_find_dchan(pri);
1975         }
1976 }
1977
1978 void pri_event_noalarm(struct sig_pri_span *pri, int index, int before_start_pri)
1979 {
1980         pri->dchanavail[index] |= DCHAN_NOTINALARM;
1981         if (!before_start_pri)
1982                 pri_restart(pri->dchans[index]);
1983 }
1984
1985 /*!
1986  * \internal
1987  * \brief Convert libpri party name into asterisk party name.
1988  * \since 1.8
1989  *
1990  * \param ast_name Asterisk party name structure to fill.  Must already be set initialized.
1991  * \param pri_name libpri party name structure containing source information.
1992  *
1993  * \note The filled in ast_name structure needs to be destroyed by
1994  * ast_party_name_free() when it is no longer needed.
1995  *
1996  * \return Nothing
1997  */
1998 static void sig_pri_party_name_convert(struct ast_party_name *ast_name, const struct pri_party_name *pri_name)
1999 {
2000         ast_name->str = ast_strdup(pri_name->str);
2001         ast_name->char_set = pri_to_ast_char_set(pri_name->char_set);
2002         ast_name->presentation = pri_to_ast_presentation(pri_name->presentation);
2003         ast_name->valid = 1;
2004 }
2005
2006 /*!
2007  * \internal
2008  * \brief Convert libpri party number into asterisk party number.
2009  * \since 1.8
2010  *
2011  * \param ast_number Asterisk party number structure to fill.  Must already be set initialized.
2012  * \param pri_number libpri party number structure containing source information.
2013  * \param pri PRI span control structure.
2014  *
2015  * \note The filled in ast_number structure needs to be destroyed by
2016  * ast_party_number_free() when it is no longer needed.
2017  *
2018  * \return Nothing
2019  */
2020 static void sig_pri_party_number_convert(struct ast_party_number *ast_number, const struct pri_party_number *pri_number, struct sig_pri_span *pri)
2021 {
2022         char number[AST_MAX_EXTENSION];
2023
2024         apply_plan_to_existing_number(number, sizeof(number), pri, pri_number->str,
2025                 pri_number->plan);
2026         ast_number->str = ast_strdup(number);
2027         ast_number->plan = pri_number->plan;
2028         ast_number->presentation = pri_to_ast_presentation(pri_number->presentation);
2029         ast_number->valid = 1;
2030 }
2031
2032 /*!
2033  * \internal
2034  * \brief Convert libpri party id into asterisk party id.
2035  * \since 1.8
2036  *
2037  * \param ast_id Asterisk party id structure to fill.  Must already be set initialized.
2038  * \param pri_id libpri party id structure containing source information.
2039  * \param pri PRI span control structure.
2040  *
2041  * \note The filled in ast_id structure needs to be destroyed by
2042  * ast_party_id_free() when it is no longer needed.
2043  *
2044  * \return Nothing
2045  */
2046 static void sig_pri_party_id_convert(struct ast_party_id *ast_id, const struct pri_party_id *pri_id, struct sig_pri_span *pri)
2047 {
2048         if (pri_id->name.valid) {
2049                 sig_pri_party_name_convert(&ast_id->name, &pri_id->name);
2050         }
2051         if (pri_id->number.valid) {
2052                 sig_pri_party_number_convert(&ast_id->number, &pri_id->number, pri);
2053         }
2054 #if defined(HAVE_PRI_SUBADDR)
2055         if (pri_id->subaddress.valid) {
2056                 sig_pri_set_subaddress(&ast_id->subaddress, &pri_id->subaddress);
2057         }
2058 #endif  /* defined(HAVE_PRI_SUBADDR) */
2059 }
2060
2061 /*!
2062  * \internal
2063  * \brief Convert libpri redirecting information into asterisk redirecting information.
2064  * \since 1.8
2065  *
2066  * \param ast_redirecting Asterisk redirecting structure to fill.
2067  * \param pri_redirecting libpri redirecting structure containing source information.
2068  * \param ast_guide Asterisk redirecting structure to use as an initialization guide.
2069  * \param pri PRI span control structure.
2070  *
2071  * \note The filled in ast_redirecting structure needs to be destroyed by
2072  * ast_party_redirecting_free() when it is no longer needed.
2073  *
2074  * \return Nothing
2075  */
2076 static void sig_pri_redirecting_convert(struct ast_party_redirecting *ast_redirecting,
2077         const struct pri_party_redirecting *pri_redirecting,
2078         const struct ast_party_redirecting *ast_guide,
2079         struct sig_pri_span *pri)
2080 {
2081         ast_party_redirecting_set_init(ast_redirecting, ast_guide);
2082
2083         sig_pri_party_id_convert(&ast_redirecting->from, &pri_redirecting->from, pri);
2084         sig_pri_party_id_convert(&ast_redirecting->to, &pri_redirecting->to, pri);
2085         ast_redirecting->count = pri_redirecting->count;
2086         ast_redirecting->reason = pri_to_ast_reason(pri_redirecting->reason);
2087 }
2088
2089 /*!
2090  * \internal
2091  * \brief Determine if the given extension matches one of the MSNs in the pattern list.
2092  * \since 1.8
2093  *
2094  * \param msn_patterns Comma separated list of MSN patterns to match.
2095  * \param exten Extension to match in the MSN list.
2096  *
2097  * \retval 1 if matches.
2098  * \retval 0 if no match.
2099  */
2100 static int sig_pri_msn_match(const char *msn_patterns, const char *exten)
2101 {
2102         char *pattern;
2103         char *msn_list;
2104         char *list_tail;
2105
2106         msn_list = ast_strdupa(msn_patterns);
2107
2108         list_tail = NULL;
2109         pattern = strtok_r(msn_list, ",", &list_tail);
2110         while (pattern) {
2111                 pattern = ast_strip(pattern);
2112                 if (!ast_strlen_zero(pattern) && ast_extension_match(pattern, exten)) {
2113                         /* Extension matched the pattern. */
2114                         return 1;
2115                 }
2116                 pattern = strtok_r(NULL, ",", &list_tail);
2117         }
2118         /* Did not match any pattern in the list. */
2119         return 0;
2120 }
2121
2122 #if defined(HAVE_PRI_MCID)
2123 /*!
2124  * \internal
2125  * \brief Append the given party id to the event string.
2126  * \since 1.8
2127  *
2128  * \param msg Event message string being built.
2129  * \param prefix Prefix to add to the party id lines.
2130  * \param party Party information to encode.
2131  *
2132  * \return Nothing
2133  */
2134 static void sig_pri_event_party_id(struct ast_str **msg, const char *prefix, struct ast_party_id *party)
2135 {
2136         int pres;
2137
2138         /* Combined party presentation */
2139         pres = ast_party_id_presentation(party);
2140         ast_str_append(msg, 0, "%sPres: %d (%s)\r\n", prefix, pres,
2141                 ast_describe_caller_presentation(pres));
2142
2143         /* Party number */
2144         ast_str_append(msg, 0, "%sNumValid: %d\r\n", prefix,
2145                 (unsigned) party->number.valid);
2146         ast_str_append(msg, 0, "%sNum: %s\r\n", prefix,
2147                 S_COR(party->number.valid, party->number.str, ""));
2148         ast_str_append(msg, 0, "%ston: %d\r\n", prefix, party->number.plan);
2149         if (party->number.valid) {
2150                 ast_str_append(msg, 0, "%sNumPlan: %d\r\n", prefix, party->number.plan);
2151                 ast_str_append(msg, 0, "%sNumPres: %d (%s)\r\n", prefix,
2152                         party->number.presentation,
2153                         ast_describe_caller_presentation(party->number.presentation));
2154         }
2155
2156         /* Party name */
2157         ast_str_append(msg, 0, "%sNameValid: %d\r\n", prefix,
2158                 (unsigned) party->name.valid);
2159         ast_str_append(msg, 0, "%sName: %s\r\n", prefix,
2160                 S_COR(party->name.valid, party->name.str, ""));
2161         if (party->name.valid) {
2162                 ast_str_append(msg, 0, "%sNameCharSet: %s\r\n", prefix,
2163                         ast_party_name_charset_describe(party->name.char_set));
2164                 ast_str_append(msg, 0, "%sNamePres: %d (%s)\r\n", prefix,
2165                         party->name.presentation,
2166                         ast_describe_caller_presentation(party->name.presentation));
2167         }
2168
2169 #if defined(HAVE_PRI_SUBADDR)
2170         /* Party subaddress */
2171         if (party->subaddress.valid) {
2172                 static const char subaddress[] = "Subaddr";
2173
2174                 ast_str_append(msg, 0, "%s%s: %s\r\n", prefix, subaddress,
2175                         S_OR(party->subaddress.str, ""));
2176                 ast_str_append(msg, 0, "%s%sType: %d\r\n", prefix, subaddress,
2177                         party->subaddress.type);
2178                 ast_str_append(msg, 0, "%s%sOdd: %d\r\n", prefix, subaddress,
2179                         party->subaddress.odd_even_indicator);
2180         }
2181 #endif  /* defined(HAVE_PRI_SUBADDR) */
2182 }
2183 #endif  /* defined(HAVE_PRI_MCID) */
2184
2185 #if defined(HAVE_PRI_MCID)
2186 /*!
2187  * \internal
2188  * \brief Handle the MCID event.
2189  * \since 1.8
2190  *
2191  * \param pri PRI span control structure.
2192  * \param mcid MCID event parameters.
2193  * \param owner Asterisk channel associated with the call.
2194  * NULL if Asterisk no longer has the ast_channel struct.
2195  *
2196  * \note Assumes the pri->lock is already obtained.
2197  * \note Assumes the owner channel lock is already obtained if still present.
2198  *
2199  * \return Nothing
2200  */
2201 static void sig_pri_mcid_event(struct sig_pri_span *pri, const struct pri_subcmd_mcid_req *mcid, struct ast_channel *owner)
2202 {
2203         struct ast_channel *chans[1];
2204         struct ast_str *msg;
2205         struct ast_party_id party;
2206
2207         msg = ast_str_create(4096);
2208         if (!msg) {
2209                 return;
2210         }
2211
2212         if (owner) {
2213                 /*
2214                  * The owner channel is present.
2215                  * Pass the event to the peer as well.
2216                  */
2217                 ast_queue_control(owner, AST_CONTROL_MCID);
2218
2219                 ast_str_append(&msg, 0, "Channel: %s\r\n", ast_channel_name(owner));
2220                 ast_str_append(&msg, 0, "UniqueID: %s\r\n", owner->uniqueid);
2221
2222                 sig_pri_event_party_id(&msg, "CallerID", &owner->connected.id);
2223         } else {
2224                 /*
2225                  * Since we no longer have an owner channel,
2226                  * we have to use the caller information supplied by libpri.
2227                  */
2228                 ast_party_id_init(&party);
2229                 sig_pri_party_id_convert(&party, &mcid->originator, pri);
2230                 sig_pri_event_party_id(&msg, "CallerID", &party);
2231                 ast_party_id_free(&party);
2232         }
2233
2234         /* Always use libpri's called party information. */
2235         ast_party_id_init(&party);
2236         sig_pri_party_id_convert(&party, &mcid->answerer, pri);
2237         sig_pri_event_party_id(&msg, "ConnectedID", &party);
2238         ast_party_id_free(&party);
2239
2240         chans[0] = owner;
2241         ast_manager_event_multichan(EVENT_FLAG_CALL, "MCID", owner ? 1 : 0, chans, "%s",
2242                 ast_str_buffer(msg));
2243         ast_free(msg);
2244 }
2245 #endif  /* defined(HAVE_PRI_MCID) */
2246
2247 #if defined(HAVE_PRI_TRANSFER)
2248 struct xfer_rsp_data {
2249         struct sig_pri_span *pri;
2250         /*! Call to send transfer success/fail response over. */
2251         q931_call *call;
2252         /*! Invocation ID to use when sending a reply to the transfer request. */
2253         int invoke_id;
2254 };
2255 #endif  /* defined(HAVE_PRI_TRANSFER) */
2256
2257 #if defined(HAVE_PRI_TRANSFER)
2258 /*!
2259  * \internal
2260  * \brief Send the transfer success/fail response message.
2261  * \since 1.8
2262  *
2263  * \param data Callback user data pointer
2264  * \param is_successful TRUE if the transfer was successful.
2265  *
2266  * \return Nothing
2267  */
2268 static void sig_pri_transfer_rsp(void *data, int is_successful)
2269 {
2270         struct xfer_rsp_data *rsp = data;
2271
2272         pri_transfer_rsp(rsp->pri->pri, rsp->call, rsp->invoke_id, is_successful);
2273 }
2274 #endif  /* defined(HAVE_PRI_TRANSFER) */
2275
2276 #if defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
2277 /*!
2278  * \brief Protocol callback to indicate if transfer will happen.
2279  * \since 1.8
2280  *
2281  * \param data Callback user data pointer
2282  * \param is_successful TRUE if the transfer will happen.
2283  *
2284  * \return Nothing
2285  */
2286 typedef void (*xfer_rsp_callback)(void *data, int is_successful);
2287 #endif  /* defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER) */
2288
2289 #if defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
2290 /*!
2291  * \internal
2292  * \brief Attempt to transfer the two calls to each other.
2293  * \since 1.8
2294  *
2295  * \param pri PRI span control structure.
2296  * \param call_1_pri First call involved in the transfer. (transferee; usually on hold)
2297  * \param call_1_held TRUE if call_1_pri is on hold.
2298  * \param call_2_pri Second call involved in the transfer. (target; usually active/ringing)
2299  * \param call_2_held TRUE if call_2_pri is on hold.
2300  * \param rsp_callback Protocol callback to indicate if transfer will happen. NULL if not used.
2301  * \param data Callback user data pointer
2302  *
2303  * \note Assumes the pri->lock is already obtained.
2304  *
2305  * \retval 0 on success.
2306  * \retval -1 on error.
2307  */
2308 static int sig_pri_attempt_transfer(struct sig_pri_span *pri, q931_call *call_1_pri, int call_1_held, q931_call *call_2_pri, int call_2_held, xfer_rsp_callback rsp_callback, void *data)
2309 {
2310         struct attempt_xfer_call {
2311                 q931_call *pri;
2312                 struct ast_channel *ast;
2313                 int held;
2314                 int chanpos;
2315         };
2316         int retval;
2317         struct ast_channel *transferee;
2318         struct attempt_xfer_call *call_1;
2319         struct attempt_xfer_call *call_2;
2320         struct attempt_xfer_call *swap_call;
2321         struct attempt_xfer_call c1;
2322         struct attempt_xfer_call c2;
2323
2324         c1.pri = call_1_pri;
2325         c1.held = call_1_held;
2326         call_1 = &c1;
2327
2328         c2.pri = call_2_pri;
2329         c2.held = call_2_held;
2330         call_2 = &c2;
2331
2332         call_1->chanpos = pri_find_principle_by_call(pri, call_1->pri);
2333         call_2->chanpos = pri_find_principle_by_call(pri, call_2->pri);
2334         if (call_1->chanpos < 0 || call_2->chanpos < 0) {
2335                 /* Calls not found in span control. */
2336                 if (rsp_callback) {
2337                         /* Transfer failed. */
2338                         rsp_callback(data, 0);
2339                 }
2340                 return -1;
2341         }
2342
2343         /* Attempt to make transferee and target consistent. */
2344         if (!call_1->held && call_2->held) {
2345                 /*
2346                  * Swap call_1 and call_2 to make call_1 the transferee(held call)
2347                  * and call_2 the target(active call).
2348                  */
2349                 swap_call = call_1;
2350                 call_1 = call_2;
2351                 call_2 = swap_call;
2352         }
2353
2354         /* Deadlock avoidance is attempted. */
2355         sig_pri_lock_private(pri->pvts[call_1->chanpos]);
2356         sig_pri_lock_owner(pri, call_1->chanpos);
2357         sig_pri_lock_private(pri->pvts[call_2->chanpos]);
2358         sig_pri_lock_owner(pri, call_2->chanpos);
2359
2360         call_1->ast = pri->pvts[call_1->chanpos]->owner;
2361         call_2->ast = pri->pvts[call_2->chanpos]->owner;
2362         if (!call_1->ast || !call_2->ast) {
2363                 /* At least one owner is not present. */
2364                 if (call_1->ast) {
2365                         ast_channel_unlock(call_1->ast);
2366                 }
2367                 if (call_2->ast) {
2368                         ast_channel_unlock(call_2->ast);
2369                 }
2370                 sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2371                 sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2372                 if (rsp_callback) {
2373                         /* Transfer failed. */
2374                         rsp_callback(data, 0);
2375                 }
2376                 return -1;
2377         }
2378
2379         for (;;) {
2380                 transferee = ast_bridged_channel(call_1->ast);
2381                 if (transferee) {
2382                         break;
2383                 }
2384
2385                 /* Try masquerading the other way. */
2386                 swap_call = call_1;
2387                 call_1 = call_2;
2388                 call_2 = swap_call;
2389
2390                 transferee = ast_bridged_channel(call_1->ast);
2391                 if (transferee) {
2392                         break;
2393                 }
2394
2395                 /* Could not transfer.  Neither call is bridged. */
2396                 ast_channel_unlock(call_1->ast);
2397                 ast_channel_unlock(call_2->ast);
2398                 sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2399                 sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2400
2401                 if (rsp_callback) {
2402                         /* Transfer failed. */
2403                         rsp_callback(data, 0);
2404                 }
2405                 return -1;
2406         }
2407
2408         ast_verb(3, "TRANSFERRING %s to %s\n", ast_channel_name(call_1->ast), ast_channel_name(call_2->ast));
2409
2410         /*
2411          * Setup transfer masquerade.
2412          *
2413          * Note:  There is an extremely nasty deadlock avoidance issue
2414          * with ast_channel_transfer_masquerade().  Deadlock may be possible if
2415          * the channels involved are proxies (chan_agent channels) and
2416          * it is called with locks.  Unfortunately, there is no simple
2417          * or even merely difficult way to guarantee deadlock avoidance
2418          * and still be able to send an ECT success response without the
2419          * possibility of the bridged channel hanging up on us.
2420          */
2421         ast_mutex_unlock(&pri->lock);
2422         retval = ast_channel_transfer_masquerade(
2423                 call_2->ast,
2424                 &call_2->ast->connected,
2425                 call_2->held,
2426                 transferee,
2427                 &call_1->ast->connected,
2428                 call_1->held);
2429
2430         /* Reacquire the pri->lock to hold off completion of the transfer masquerade. */
2431         ast_mutex_lock(&pri->lock);
2432
2433         ast_channel_unlock(call_1->ast);
2434         ast_channel_unlock(call_2->ast);
2435         sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2436         sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2437
2438         if (rsp_callback) {
2439                 /*
2440                  * Report transfer status.
2441                  *
2442                  * Must do the callback before the masquerade completes to ensure
2443                  * that the protocol message goes out before the call leg is
2444                  * disconnected.
2445                  */
2446                 rsp_callback(data, retval ? 0 : 1);
2447         }
2448         return retval;
2449 }
2450 #endif  /* defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER) */
2451
2452 #if defined(HAVE_PRI_CCSS)
2453 /*!
2454  * \internal
2455  * \brief Compare the CC agent private data by libpri cc_id.
2456  * \since 1.8
2457  *
2458  * \param obj pointer to the (user-defined part) of an object.
2459  * \param arg callback argument from ao2_callback()
2460  * \param flags flags from ao2_callback()
2461  *
2462  * \return values are a combination of enum _cb_results.
2463  */
2464 static int sig_pri_cc_agent_cmp_cc_id(void *obj, void *arg, int flags)
2465 {
2466         struct ast_cc_agent *agent_1 = obj;
2467         struct sig_pri_cc_agent_prv *agent_prv_1 = agent_1->private_data;
2468         struct sig_pri_cc_agent_prv *agent_prv_2 = arg;
2469
2470         return (agent_prv_1 && agent_prv_1->pri == agent_prv_2->pri
2471                 && agent_prv_1->cc_id == agent_prv_2->cc_id) ? CMP_MATCH | CMP_STOP : 0;
2472 }
2473 #endif  /* defined(HAVE_PRI_CCSS) */
2474
2475 #if defined(HAVE_PRI_CCSS)
2476 /*!
2477  * \internal
2478  * \brief Find the CC agent by libpri cc_id.
2479  * \since 1.8
2480  *
2481  * \param pri PRI span control structure.
2482  * \param cc_id CC record ID to find.
2483  *
2484  * \note
2485  * Since agents are refcounted, and this function returns
2486  * a reference to the agent, it is imperative that you decrement
2487  * the refcount of the agent once you have finished using it.
2488  *
2489  * \retval agent on success.
2490  * \retval NULL not found.
2491  */
2492 static struct ast_cc_agent *sig_pri_find_cc_agent_by_cc_id(struct sig_pri_span *pri, long cc_id)
2493 {
2494         struct sig_pri_cc_agent_prv finder = {
2495                 .pri = pri,
2496                 .cc_id = cc_id,
2497         };
2498
2499         return ast_cc_agent_callback(0, sig_pri_cc_agent_cmp_cc_id, &finder,
2500                 sig_pri_cc_type_name);
2501 }
2502 #endif  /* defined(HAVE_PRI_CCSS) */
2503
2504 #if defined(HAVE_PRI_CCSS)
2505 /*!
2506  * \internal
2507  * \brief Compare the CC monitor instance by libpri cc_id.
2508  * \since 1.8
2509  *
2510  * \param obj pointer to the (user-defined part) of an object.
2511  * \param arg callback argument from ao2_callback()
2512  * \param flags flags from ao2_callback()
2513  *
2514  * \return values are a combination of enum _cb_results.
2515  */
2516 static int sig_pri_cc_monitor_cmp_cc_id(void *obj, void *arg, int flags)
2517 {
2518         struct sig_pri_cc_monitor_instance *monitor_1 = obj;
2519         struct sig_pri_cc_monitor_instance *monitor_2 = arg;
2520
2521         return (monitor_1->pri == monitor_2->pri
2522                 && monitor_1->cc_id == monitor_2->cc_id) ? CMP_MATCH | CMP_STOP : 0;
2523 }
2524 #endif  /* defined(HAVE_PRI_CCSS) */
2525
2526 #if defined(HAVE_PRI_CCSS)
2527 /*!
2528  * \internal
2529  * \brief Find the CC monitor instance by libpri cc_id.
2530  * \since 1.8
2531  *
2532  * \param pri PRI span control structure.
2533  * \param cc_id CC record ID to find.
2534  *
2535  * \note
2536  * Since monitor_instances are refcounted, and this function returns
2537  * a reference to the instance, it is imperative that you decrement
2538  * the refcount of the instance once you have finished using it.
2539  *
2540  * \retval monitor_instance on success.
2541  * \retval NULL not found.
2542  */
2543 static struct sig_pri_cc_monitor_instance *sig_pri_find_cc_monitor_by_cc_id(struct sig_pri_span *pri, long cc_id)
2544 {
2545         struct sig_pri_cc_monitor_instance finder = {
2546                 .pri = pri,
2547                 .cc_id = cc_id,
2548         };
2549
2550         return ao2_callback(sig_pri_cc_monitors, 0, sig_pri_cc_monitor_cmp_cc_id, &finder);
2551 }
2552 #endif  /* defined(HAVE_PRI_CCSS) */
2553
2554 #if defined(HAVE_PRI_CCSS)
2555 /*!
2556  * \internal
2557  * \brief Destroy the given monitor instance.
2558  * \since 1.8
2559  *
2560  * \param data Monitor instance to destroy.
2561  *
2562  * \return Nothing
2563  */
2564 static void sig_pri_cc_monitor_instance_destroy(void *data)
2565 {
2566         struct sig_pri_cc_monitor_instance *monitor_instance = data;
2567
2568         if (monitor_instance->cc_id != -1) {
2569                 ast_mutex_lock(&monitor_instance->pri->lock);
2570                 pri_cc_cancel(monitor_instance->pri->pri, monitor_instance->cc_id);
2571                 ast_mutex_unlock(&monitor_instance->pri->lock);
2572         }
2573         monitor_instance->pri->calls->module_unref();
2574 }
2575 #endif  /* defined(HAVE_PRI_CCSS) */
2576
2577 #if defined(HAVE_PRI_CCSS)
2578 /*!
2579  * \internal
2580  * \brief Construct a new monitor instance.
2581  * \since 1.8
2582  *
2583  * \param core_id CC core ID.
2584  * \param pri PRI span control structure.
2585  * \param cc_id CC record ID.
2586  * \param device_name Name of device (Asterisk channel name less sequence number).
2587  *
2588  * \note
2589  * Since monitor_instances are refcounted, and this function returns
2590  * a reference to the instance, it is imperative that you decrement
2591  * the refcount of the instance once you have finished using it.
2592  *
2593  * \retval monitor_instance on success.
2594  * \retval NULL on error.
2595  */
2596 static struct sig_pri_cc_monitor_instance *sig_pri_cc_monitor_instance_init(int core_id, struct sig_pri_span *pri, long cc_id, const char *device_name)
2597 {
2598         struct sig_pri_cc_monitor_instance *monitor_instance;
2599
2600         if (!pri->calls->module_ref || !pri->calls->module_unref) {
2601                 return NULL;
2602         }
2603
2604         monitor_instance = ao2_alloc(sizeof(*monitor_instance) + strlen(device_name),
2605                 sig_pri_cc_monitor_instance_destroy);
2606         if (!monitor_instance) {
2607                 return NULL;
2608         }
2609
2610         monitor_instance->cc_id = cc_id;
2611         monitor_instance->pri = pri;
2612         monitor_instance->core_id = core_id;
2613         strcpy(monitor_instance->name, device_name);
2614
2615         pri->calls->module_ref();
2616
2617         ao2_link(sig_pri_cc_monitors, monitor_instance);
2618         return monitor_instance;
2619 }
2620 #endif  /* defined(HAVE_PRI_CCSS) */
2621
2622 #if defined(HAVE_PRI_CCSS)
2623 /*!
2624  * \internal
2625  * \brief Announce to the CC core that protocol CC monitor is available for this call.
2626  * \since 1.8
2627  *
2628  * \param pri PRI span control structure.
2629  * \param chanpos Channel position in the span.
2630  * \param cc_id CC record ID.
2631  * \param service CCBS/CCNR indication.
2632  *
2633  * \note Assumes the pri->lock is already obtained.
2634  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
2635  * \note Assumes the sig_pri_lock_owner(pri, chanpos) is already obtained.
2636  *
2637  * \retval 0 on success.
2638  * \retval -1 on error.
2639  */
2640 static int sig_pri_cc_available(struct sig_pri_span *pri, int chanpos, long cc_id, enum ast_cc_service_type service)
2641 {
2642         struct sig_pri_chan *pvt;
2643         struct ast_cc_config_params *cc_params;
2644         struct sig_pri_cc_monitor_instance *monitor;
2645         enum ast_cc_monitor_policies monitor_policy;
2646         int core_id;
2647         int res;
2648         char device_name[AST_CHANNEL_NAME];
2649         char dialstring[AST_CHANNEL_NAME];
2650
2651         pvt = pri->pvts[chanpos];
2652
2653         core_id = ast_cc_get_current_core_id(pvt->owner);
2654         if (core_id == -1) {
2655                 return -1;
2656         }
2657
2658         cc_params = ast_channel_get_cc_config_params(pvt->owner);
2659         if (!cc_params) {
2660                 return -1;
2661         }
2662
2663         res = -1;
2664         monitor_policy = ast_get_cc_monitor_policy(cc_params);
2665         switch (monitor_policy) {
2666         case AST_CC_MONITOR_NEVER:
2667                 /* CCSS is not enabled. */
2668                 break;
2669         case AST_CC_MONITOR_NATIVE:
2670         case AST_CC_MONITOR_ALWAYS:
2671                 /*
2672                  * If it is AST_CC_MONITOR_ALWAYS and native fails we will attempt the fallback
2673                  * later in the call to sig_pri_cc_generic_check().
2674                  */
2675                 ast_channel_get_device_name(pvt->owner, device_name, sizeof(device_name));
2676                 sig_pri_make_cc_dialstring(pvt, dialstring, sizeof(dialstring));
2677                 monitor = sig_pri_cc_monitor_instance_init(core_id, pri, cc_id, device_name);
2678                 if (!monitor) {
2679                         break;
2680                 }
2681                 res = ast_queue_cc_frame(pvt->owner, sig_pri_cc_type_name, dialstring, service,
2682                         monitor);
2683                 if (res) {
2684                         monitor->cc_id = -1;
2685                         ao2_unlink(sig_pri_cc_monitors, monitor);
2686                         ao2_ref(monitor, -1);
2687                 }
2688                 break;
2689         case AST_CC_MONITOR_GENERIC:
2690                 ast_queue_cc_frame(pvt->owner, AST_CC_GENERIC_MONITOR_TYPE,
2691                         sig_pri_get_orig_dialstring(pvt), service, NULL);
2692                 /* Say it failed to force caller to cancel native CC. */
2693                 break;
2694         }
2695         return res;
2696 }
2697 #endif  /* defined(HAVE_PRI_CCSS) */
2698
2699 /*!
2700  * \internal
2701  * \brief Check if generic CC monitor is needed and request it.
2702  * \since 1.8
2703  *
2704  * \param pri PRI span control structure.
2705  * \param chanpos Channel position in the span.
2706  * \param service CCBS/CCNR indication.
2707  *
2708  * \note Assumes the pri->lock is already obtained.
2709  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
2710  *
2711  * \return Nothing
2712  */
2713 static void sig_pri_cc_generic_check(struct sig_pri_span *pri, int chanpos, enum ast_cc_service_type service)
2714 {
2715         struct ast_channel *owner;
2716         struct ast_cc_config_params *cc_params;
2717 #if defined(HAVE_PRI_CCSS)
2718         struct ast_cc_monitor *monitor;
2719         char device_name[AST_CHANNEL_NAME];
2720 #endif  /* defined(HAVE_PRI_CCSS) */
2721         enum ast_cc_monitor_policies monitor_policy;
2722         int core_id;
2723
2724         if (!pri->pvts[chanpos]->outgoing) {
2725                 /* This is not an outgoing call so it cannot be CC monitor. */
2726                 return;
2727         }
2728
2729         sig_pri_lock_owner(pri, chanpos);
2730         owner = pri->pvts[chanpos]->owner;
2731         if (!owner) {
2732                 return;
2733         }
2734         core_id = ast_cc_get_current_core_id(owner);
2735         if (core_id == -1) {
2736                 /* No CC core setup */
2737                 goto done;
2738         }
2739
2740         cc_params = ast_channel_get_cc_config_params(owner);
2741         if (!cc_params) {
2742                 /* Could not get CC config parameters. */
2743                 goto done;
2744         }
2745
2746 #if defined(HAVE_PRI_CCSS)
2747         ast_channel_get_device_name(owner, device_name, sizeof(device_name));
2748         monitor = ast_cc_get_monitor_by_recall_core_id(core_id, device_name);
2749         if (monitor) {
2750                 /* CC monitor is already present so no need for generic CC. */
2751                 ao2_ref(monitor, -1);
2752                 goto done;
2753         }
2754 #endif  /* defined(HAVE_PRI_CCSS) */
2755
2756         monitor_policy = ast_get_cc_monitor_policy(cc_params);
2757         switch (monitor_policy) {
2758         case AST_CC_MONITOR_NEVER:
2759                 /* CCSS is not enabled. */
2760                 break;
2761         case AST_CC_MONITOR_NATIVE:
2762                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype == PRI_NETWORK) {
2763                         /* Request generic CC monitor. */
2764                         ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2765                                 sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2766                 }
2767                 break;
2768         case AST_CC_MONITOR_ALWAYS:
2769                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype != PRI_NETWORK) {
2770                         /*
2771                          * Cannot monitor PTMP TE side since this is not defined.
2772                          * We are playing the roll of a phone in this case and
2773                          * a phone cannot monitor a party over the network without
2774                          * protocol help.
2775                          */
2776                         break;
2777                 }
2778                 /*
2779                  * We are either falling back or this is a PTMP NT span.
2780                  * Request generic CC monitor.
2781                  */
2782                 ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2783                         sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2784                 break;
2785         case AST_CC_MONITOR_GENERIC:
2786                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype == PRI_NETWORK) {
2787                         /* Request generic CC monitor. */
2788                         ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2789                                 sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2790                 }
2791                 break;
2792         }
2793
2794 done:
2795         ast_channel_unlock(owner);
2796 }
2797
2798 #if defined(HAVE_PRI_CCSS)
2799 /*!
2800  * \internal
2801  * \brief The CC link canceled the CC instance.
2802  * \since 1.8
2803  *
2804  * \param pri PRI span control structure.
2805  * \param cc_id CC record ID.
2806  * \param is_agent TRUE if the cc_id is for an agent.
2807  *
2808  * \return Nothing
2809  */
2810 static void sig_pri_cc_link_canceled(struct sig_pri_span *pri, long cc_id, int is_agent)
2811 {
2812         if (is_agent) {
2813                 struct ast_cc_agent *agent;
2814
2815                 agent = sig_pri_find_cc_agent_by_cc_id(pri, cc_id);
2816                 if (!agent) {
2817                         return;
2818                 }
2819                 ast_cc_failed(agent->core_id, "%s agent got canceled by link",
2820                         sig_pri_cc_type_name);
2821                 ao2_ref(agent, -1);
2822         } else {
2823                 struct sig_pri_cc_monitor_instance *monitor;
2824
2825                 monitor = sig_pri_find_cc_monitor_by_cc_id(pri, cc_id);
2826                 if (!monitor) {
2827                         return;
2828                 }
2829                 monitor->cc_id = -1;
2830                 ast_cc_monitor_failed(monitor->core_id, monitor->name,
2831                         "%s monitor got canceled by link", sig_pri_cc_type_name);
2832                 ao2_ref(monitor, -1);
2833         }
2834 }
2835 #endif  /* defined(HAVE_PRI_CCSS) */
2836
2837 #if defined(HAVE_PRI_AOC_EVENTS)
2838 /*!
2839  * \internal
2840  * \brief Convert ast_aoc_charged_item to PRI_AOC_CHARGED_ITEM .
2841  * \since 1.8
2842  *
2843  * \param value Value to convert to string.
2844  *
2845  * \return PRI_AOC_CHARGED_ITEM
2846  */
2847 static enum PRI_AOC_CHARGED_ITEM sig_pri_aoc_charged_item_to_pri(enum PRI_AOC_CHARGED_ITEM value)
2848 {
2849         switch (value) {
2850         case AST_AOC_CHARGED_ITEM_NA:
2851                 return PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE;
2852         case AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT:
2853                 return PRI_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
2854         case AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION:
2855                 return PRI_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
2856         case AST_AOC_CHARGED_ITEM_CALL_ATTEMPT:
2857                 return PRI_AOC_CHARGED_ITEM_CALL_ATTEMPT;
2858         case AST_AOC_CHARGED_ITEM_CALL_SETUP:
2859                 return PRI_AOC_CHARGED_ITEM_CALL_SETUP;
2860         case AST_AOC_CHARGED_ITEM_USER_USER_INFO:
2861                 return PRI_AOC_CHARGED_ITEM_USER_USER_INFO;
2862         case AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE:
2863                 return PRI_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
2864         }
2865         return PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE;
2866 }
2867 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2868
2869 #if defined(HAVE_PRI_AOC_EVENTS)
2870 /*!
2871  * \internal
2872  * \brief Convert PRI_AOC_CHARGED_ITEM to ast_aoc_charged_item.
2873  * \since 1.8
2874  *
2875  * \param value Value to convert to string.
2876  *
2877  * \return ast_aoc_charged_item
2878  */
2879 static enum ast_aoc_s_charged_item sig_pri_aoc_charged_item_to_ast(enum PRI_AOC_CHARGED_ITEM value)
2880 {
2881         switch (value) {
2882         case PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE:
2883                 return AST_AOC_CHARGED_ITEM_NA;
2884         case PRI_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT:
2885                 return AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
2886         case PRI_AOC_CHARGED_ITEM_BASIC_COMMUNICATION:
2887                 return AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
2888         case PRI_AOC_CHARGED_ITEM_CALL_ATTEMPT:
2889                 return AST_AOC_CHARGED_ITEM_CALL_ATTEMPT;
2890         case PRI_AOC_CHARGED_ITEM_CALL_SETUP:
2891                 return AST_AOC_CHARGED_ITEM_CALL_SETUP;
2892         case PRI_AOC_CHARGED_ITEM_USER_USER_INFO:
2893                 return AST_AOC_CHARGED_ITEM_USER_USER_INFO;
2894         case PRI_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE:
2895                 return AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
2896         }
2897         return AST_AOC_CHARGED_ITEM_NA;
2898 }
2899 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2900
2901 #if defined(HAVE_PRI_AOC_EVENTS)
2902 /*!
2903  * \internal
2904  * \brief Convert AST_AOC_MULTIPLER to PRI_AOC_MULTIPLIER.
2905  * \since 1.8
2906  *
2907  * \return pri enum equivalent.
2908  */
2909 static int sig_pri_aoc_multiplier_from_ast(enum ast_aoc_currency_multiplier mult)
2910 {
2911         switch (mult) {
2912         case AST_AOC_MULT_ONETHOUSANDTH:
2913                 return PRI_AOC_MULTIPLIER_THOUSANDTH;
2914         case AST_AOC_MULT_ONEHUNDREDTH:
2915                 return PRI_AOC_MULTIPLIER_HUNDREDTH;
2916         case AST_AOC_MULT_ONETENTH:
2917                 return PRI_AOC_MULTIPLIER_TENTH;
2918         case AST_AOC_MULT_ONE:
2919                 return PRI_AOC_MULTIPLIER_ONE;
2920         case AST_AOC_MULT_TEN:
2921                 return PRI_AOC_MULTIPLIER_TEN;
2922         case AST_AOC_MULT_HUNDRED:
2923                 return PRI_AOC_MULTIPLIER_HUNDRED;
2924         case AST_AOC_MULT_THOUSAND:
2925                 return PRI_AOC_MULTIPLIER_THOUSAND;
2926         default:
2927                 return PRI_AOC_MULTIPLIER_ONE;
2928         }
2929 }
2930 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2931
2932 #if defined(HAVE_PRI_AOC_EVENTS)
2933 /*!
2934  * \internal
2935  * \brief Convert PRI_AOC_MULTIPLIER to AST_AOC_MULTIPLIER
2936  * \since 1.8
2937  *
2938  * \return ast enum equivalent.
2939  */
2940 static int sig_pri_aoc_multiplier_from_pri(const int mult)
2941 {
2942         switch (mult) {
2943         case PRI_AOC_MULTIPLIER_THOUSANDTH:
2944                 return AST_AOC_MULT_ONETHOUSANDTH;
2945         case PRI_AOC_MULTIPLIER_HUNDREDTH:
2946                 return AST_AOC_MULT_ONEHUNDREDTH;
2947         case PRI_AOC_MULTIPLIER_TENTH:
2948                 return AST_AOC_MULT_ONETENTH;
2949         case PRI_AOC_MULTIPLIER_ONE:
2950                 return AST_AOC_MULT_ONE;
2951         case PRI_AOC_MULTIPLIER_TEN:
2952                 return AST_AOC_MULT_TEN;
2953         case PRI_AOC_MULTIPLIER_HUNDRED:
2954                 return AST_AOC_MULT_HUNDRED;
2955         case PRI_AOC_MULTIPLIER_THOUSAND:
2956                 return AST_AOC_MULT_THOUSAND;
2957         default:
2958                 return AST_AOC_MULT_ONE;
2959         }
2960 }
2961 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2962
2963 #if defined(HAVE_PRI_AOC_EVENTS)
2964 /*!
2965  * \internal
2966  * \brief Convert ast_aoc_time_scale representation to PRI_AOC_TIME_SCALE
2967  * \since 1.8
2968  *
2969  * \param value Value to convert to ast representation
2970  *
2971  * \return PRI_AOC_TIME_SCALE
2972  */
2973 static enum PRI_AOC_TIME_SCALE sig_pri_aoc_scale_to_pri(enum ast_aoc_time_scale value)
2974 {
2975         switch (value) {
2976         default:
2977         case AST_AOC_TIME_SCALE_HUNDREDTH_SECOND:
2978                 return PRI_AOC_TIME_SCALE_HUNDREDTH_SECOND;
2979         case AST_AOC_TIME_SCALE_TENTH_SECOND:
2980                 return PRI_AOC_TIME_SCALE_TENTH_SECOND;
2981         case AST_AOC_TIME_SCALE_SECOND:
2982                 return PRI_AOC_TIME_SCALE_SECOND;
2983         case AST_AOC_TIME_SCALE_TEN_SECOND:
2984                 return PRI_AOC_TIME_SCALE_TEN_SECOND;
2985         case AST_AOC_TIME_SCALE_MINUTE:
2986                 return PRI_AOC_TIME_SCALE_MINUTE;
2987         case AST_AOC_TIME_SCALE_HOUR:
2988                 return PRI_AOC_TIME_SCALE_HOUR;
2989         case AST_AOC_TIME_SCALE_DAY:
2990                 return PRI_AOC_TIME_SCALE_DAY;
2991         }
2992 }
2993 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2994
2995 #if defined(HAVE_PRI_AOC_EVENTS)
2996 /*!
2997  * \internal
2998  * \brief Convert PRI_AOC_TIME_SCALE to ast aoc representation
2999  * \since 1.8
3000  *
3001  * \param value Value to convert to ast representation
3002  *
3003  * \return ast aoc time scale
3004  */
3005 static enum ast_aoc_time_scale sig_pri_aoc_scale_to_ast(enum PRI_AOC_TIME_SCALE value)
3006 {
3007         switch (value) {
3008         default:
3009         case PRI_AOC_TIME_SCALE_HUNDREDTH_SECOND:
3010                 return AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
3011         case PRI_AOC_TIME_SCALE_TENTH_SECOND:
3012                 return AST_AOC_TIME_SCALE_TENTH_SECOND;
3013         case PRI_AOC_TIME_SCALE_SECOND:
3014                 return AST_AOC_TIME_SCALE_SECOND;
3015         case PRI_AOC_TIME_SCALE_TEN_SECOND:
3016                 return AST_AOC_TIME_SCALE_TEN_SECOND;
3017         case PRI_AOC_TIME_SCALE_MINUTE:
3018                 return AST_AOC_TIME_SCALE_MINUTE;
3019         case PRI_AOC_TIME_SCALE_HOUR:
3020                 return AST_AOC_TIME_SCALE_HOUR;
3021         case PRI_AOC_TIME_SCALE_DAY:
3022                 return AST_AOC_TIME_SCALE_DAY;
3023         }
3024         return AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
3025 }
3026 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3027
3028 #if defined(HAVE_PRI_AOC_EVENTS)
3029 /*!
3030  * \internal
3031  * \brief Handle AOC-S control frame
3032  * \since 1.8
3033  *
3034  * \param aoc_s AOC-S event parameters.
3035  * \param owner Asterisk channel associated with the call.
3036  * \param passthrough indicating if this message should be queued on the ast channel
3037  *
3038  * \note Assumes the pri->lock is already obtained.
3039  * \note Assumes the sig_pri private is locked
3040  * \note Assumes the owner channel lock is already obtained.
3041  *
3042  * \return Nothing
3043  */
3044 static void sig_pri_aoc_s_from_pri(const struct pri_subcmd_aoc_s *aoc_s, struct ast_channel *owner, int passthrough)
3045 {
3046         struct ast_aoc_decoded *decoded = NULL;
3047         struct ast_aoc_encoded *encoded = NULL;
3048         size_t encoded_size = 0;
3049         int idx;
3050
3051         if (!owner || !aoc_s) {
3052                 return;
3053         }
3054
3055         if (!(decoded = ast_aoc_create(AST_AOC_S, 0, 0))) {
3056                 return;
3057         }
3058
3059         for (idx = 0; idx < aoc_s->num_items; ++idx) {
3060                 enum ast_aoc_s_charged_item charged_item;
3061
3062                 charged_item = sig_pri_aoc_charged_item_to_ast(aoc_s->item[idx].chargeable);
3063                 if (charged_item == AST_AOC_CHARGED_ITEM_NA) {
3064                         /* Delete the unknown charged item from the list. */
3065                         continue;
3066                 }
3067                 switch (aoc_s->item[idx].rate_type) {
3068                 case PRI_AOC_RATE_TYPE_DURATION:
3069                         ast_aoc_s_add_rate_duration(decoded,
3070                                 charged_item,
3071                                 aoc_s->item[idx].rate.duration.amount.cost,
3072                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.duration.amount.multiplier),
3073                                 aoc_s->item[idx].rate.duration.currency,
3074                                 aoc_s->item[idx].rate.duration.time.length,
3075                                 sig_pri_aoc_scale_to_ast(aoc_s->item[idx].rate.duration.time.scale),
3076                                 aoc_s->item[idx].rate.duration.granularity.length,
3077                                 sig_pri_aoc_scale_to_ast(aoc_s->item[idx].rate.duration.granularity.scale),
3078                                 aoc_s->item[idx].rate.duration.charging_type);
3079                         break;
3080                 case PRI_AOC_RATE_TYPE_FLAT:
3081                         ast_aoc_s_add_rate_flat(decoded,
3082                                 charged_item,
3083                                 aoc_s->item[idx].rate.flat.amount.cost,
3084                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.flat.amount.multiplier),
3085                                 aoc_s->item[idx].rate.flat.currency);
3086                         break;
3087                 case PRI_AOC_RATE_TYPE_VOLUME:
3088                         ast_aoc_s_add_rate_volume(decoded,
3089                                 charged_item,
3090                                 aoc_s->item[idx].rate.volume.unit,
3091                                 aoc_s->item[idx].rate.volume.amount.cost,
3092                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.volume.amount.multiplier),
3093                                 aoc_s->item[idx].rate.volume.currency);
3094                         break;
3095                 case PRI_AOC_RATE_TYPE_SPECIAL_CODE:
3096                         ast_aoc_s_add_rate_special_charge_code(decoded,
3097                                 charged_item,
3098                                 aoc_s->item[idx].rate.special);
3099                         break;
3100                 case PRI_AOC_RATE_TYPE_FREE:
3101                         ast_aoc_s_add_rate_free(decoded, charged_item, 0);
3102                         break;
3103                 case PRI_AOC_RATE_TYPE_FREE_FROM_BEGINNING:
3104                         ast_aoc_s_add_rate_free(decoded, charged_item, 1);
3105                         break;
3106                 default:
3107                         ast_aoc_s_add_rate_na(decoded, charged_item);
3108                         break;
3109                 }
3110         }
3111
3112         if (passthrough && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
3113                 ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
3114         }
3115
3116         ast_aoc_manager_event(decoded, owner);
3117
3118         ast_aoc_destroy_decoded(decoded);
3119         ast_aoc_destroy_encoded(encoded);
3120 }
3121 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3122
3123 #if defined(HAVE_PRI_AOC_EVENTS)
3124 /*!
3125  * \internal
3126  * \brief Generate AOC Request Response
3127  * \since 1.8
3128  *
3129  * \param aoc_request
3130  *
3131  * \note Assumes the pri->lock is already obtained.
3132  * \note Assumes the sig_pri private is locked
3133  * \note Assumes the owner channel lock is already obtained.
3134  *
3135  * \return Nothing
3136  */
3137 static void sig_pri_aoc_request_from_pri(const struct pri_subcmd_aoc_request *aoc_request, struct sig_pri_chan *pvt, q931_call *call)
3138 {
3139         int request;
3140
3141         if (!aoc_request) {
3142                 return;
3143         }
3144
3145         request = aoc_request->charging_request;
3146
3147         if (request & PRI_AOC_REQUEST_S) {
3148                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_S) {
3149                         /* An AOC-S response must come from the other side, so save off this invoke_id
3150                          * and see if an AOC-S message comes in before the call is answered. */
3151                         pvt->aoc_s_request_invoke_id = aoc_request->invoke_id;
3152                         pvt->aoc_s_request_invoke_id_valid = 1;
3153
3154                 } else {
3155                         pri_aoc_s_request_response_send(pvt->pri->pri,
3156                                 call,
3157                                 aoc_request->invoke_id,
3158                                 NULL);
3159                 }
3160         }
3161
3162         if (request & PRI_AOC_REQUEST_D) {
3163                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_D) {
3164                         pri_aoc_de_request_response_send(pvt->pri->pri,
3165                                 call,
3166                                 PRI_AOC_REQ_RSP_CHARGING_INFO_FOLLOWS,
3167                                 aoc_request->invoke_id);
3168                 } else {
3169                         pri_aoc_de_request_response_send(pvt->pri->pri,
3170                                 call,
3171                                 PRI_AOC_REQ_RSP_ERROR_NOT_AVAILABLE,
3172                                 aoc_request->invoke_id);
3173                 }
3174         }
3175
3176         if (request & PRI_AOC_REQUEST_E) {
3177                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_E) {
3178                         pri_aoc_de_request_response_send(pvt->pri->pri,
3179                                 call,
3180                                 PRI_AOC_REQ_RSP_CHARGING_INFO_FOLLOWS,
3181                                 aoc_request->invoke_id);
3182                 } else {
3183                         pri_aoc_de_request_response_send(pvt->pri->pri,
3184                                 call,
3185                                 PRI_AOC_REQ_RSP_ERROR_NOT_AVAILABLE,
3186                                 aoc_request->invoke_id);
3187                 }
3188         }
3189 }
3190 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3191
3192 #if defined(HAVE_PRI_AOC_EVENTS)
3193 /*!
3194  * \internal
3195  * \brief Generate AOC-D AST_CONTROL_AOC frame
3196  * \since 1.8
3197  *
3198  * \param aoc_e AOC-D event parameters.
3199  * \param owner Asterisk channel associated with the call.
3200  * \param passthrough indicating if this message should be queued on the ast channel
3201  *
3202  * \note Assumes the pri->lock is already obtained.
3203  * \note Assumes the sig_pri private is locked
3204  * \note Assumes the owner channel lock is already obtained.
3205  *
3206  * \return Nothing
3207  */
3208 static void sig_pri_aoc_d_from_pri(const struct pri_subcmd_aoc_d *aoc_d, struct ast_channel *owner, int passthrough)
3209 {
3210         struct ast_aoc_decoded *decoded = NULL;
3211         struct ast_aoc_encoded *encoded = NULL;
3212         size_t encoded_size = 0;
3213         enum ast_aoc_charge_type type;
3214
3215         if (!owner || !aoc_d) {
3216                 return;
3217         }
3218
3219         switch (aoc_d->charge) {
3220         case PRI_AOC_DE_CHARGE_CURRENCY:
3221                 type = AST_AOC_CHARGE_CURRENCY;
3222                 break;
3223         case PRI_AOC_DE_CHARGE_UNITS:
3224                 type = AST_AOC_CHARGE_UNIT;
3225                 break;
3226         case PRI_AOC_DE_CHARGE_FREE:
3227                 type = AST_AOC_CHARGE_FREE;
3228                 break;
3229         default:
3230                 type = AST_AOC_CHARGE_NA;
3231                 break;
3232         }
3233
3234         if (!(decoded = ast_aoc_create(AST_AOC_D, type, 0))) {
3235                 return;
3236         }
3237
3238         switch (aoc_d->billing_accumulation) {
3239         default:
3240                 ast_debug(1, "AOC-D billing accumulation has unknown value: %d\n",
3241                         aoc_d->billing_accumulation);
3242                 /* Fall through */
3243         case 0:/* subTotal */
3244                 ast_aoc_set_total_type(decoded, AST_AOC_SUBTOTAL);
3245                 break;
3246         case 1:/* total */
3247                 ast_aoc_set_total_type(decoded, AST_AOC_TOTAL);
3248                 break;
3249         }
3250
3251         switch (aoc_d->billing_id) {
3252         case PRI_AOC_D_BILLING_ID_NORMAL:
3253                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NORMAL);
3254                 break;
3255         case PRI_AOC_D_BILLING_ID_REVERSE:
3256                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_REVERSE_CHARGE);
3257                 break;
3258         case PRI_AOC_D_BILLING_ID_CREDIT_CARD:
3259                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CREDIT_CARD);
3260                 break;
3261         case PRI_AOC_D_BILLING_ID_NOT_AVAILABLE:
3262         default:
3263                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NA);
3264                 break;
3265         }
3266
3267         switch (aoc_d->charge) {
3268         case PRI_AOC_DE_CHARGE_CURRENCY:
3269                 ast_aoc_set_currency_info(decoded,
3270                         aoc_d->recorded.money.amount.cost,
3271                         sig_pri_aoc_multiplier_from_pri(aoc_d->recorded.money.amount.multiplier),
3272                         aoc_d->recorded.money.currency);
3273                 break;
3274         case PRI_AOC_DE_CHARGE_UNITS:
3275                 {
3276                         int i;
3277                         for (i = 0; i < aoc_d->recorded.unit.num_items; ++i) {
3278                                 /* if type or number are negative, then they are not present */
3279                                 ast_aoc_add_unit_entry(decoded,
3280                                         (aoc_d->recorded.unit.item[i].number >= 0 ? 1 : 0),
3281                                         aoc_d->recorded.unit.item[i].number,
3282                                         (aoc_d->recorded.unit.item[i].type >= 0 ? 1 : 0),
3283                                         aoc_d->recorded.unit.item[i].type);
3284                         }
3285                 }
3286                 break;
3287         }
3288
3289         if (passthrough && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
3290                 ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
3291         }
3292
3293         ast_aoc_manager_event(decoded, owner);
3294
3295         ast_aoc_destroy_decoded(decoded);
3296         ast_aoc_destroy_encoded(encoded);
3297 }
3298 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3299
3300 #if defined(HAVE_PRI_AOC_EVENTS)
3301 /*!
3302  * \internal
3303  * \brief Generate AOC-E AST_CONTROL_AOC frame
3304  * \since 1.8
3305  *
3306  * \param aoc_e AOC-E event parameters.
3307  * \param owner Asterisk channel associated with the call.
3308  * \param passthrough indicating if this message should be queued on the ast channel
3309  *
3310  * \note Assumes the pri->lock is already obtained.
3311  * \note Assumes the sig_pri private is locked
3312  * \note Assumes the owner channel lock is already obtained.
3313  * \note owner channel may be NULL. In that case, generate event only
3314  *
3315  * \return Nothing
3316  */
3317 static void sig_pri_aoc_e_from_pri(const struct pri_subcmd_aoc_e *aoc_e, struct ast_channel *owner, int passthrough)
3318 {
3319         struct ast_aoc_decoded *decoded = NULL;
3320         struct ast_aoc_encoded *encoded = NULL;
3321         size_t encoded_size = 0;
3322         enum ast_aoc_charge_type type;
3323
3324         if (!aoc_e) {
3325                 return;
3326         }
3327
3328         switch (aoc_e->charge) {
3329         case PRI_AOC_DE_CHARGE_CURRENCY:
3330                 type = AST_AOC_CHARGE_CURRENCY;
3331                 break;
3332         case PRI_AOC_DE_CHARGE_UNITS:
3333                 type = AST_AOC_CHARGE_UNIT;
3334                 break;
3335         case PRI_AOC_DE_CHARGE_FREE:
3336                 type = AST_AOC_CHARGE_FREE;
3337                 break;
3338         default:
3339                 type = AST_AOC_CHARGE_NA;
3340                 break;
3341         }
3342
3343         if (!(decoded = ast_aoc_create(AST_AOC_E, type, 0))) {
3344                 return;
3345         }
3346
3347         switch (aoc_e->associated.charging_type) {
3348         case PRI_AOC_E_CHARGING_ASSOCIATION_NUMBER:
3349                 if (!aoc_e->associated.charge.number.valid) {
3350                         break;
3351                 }
3352                 ast_aoc_set_association_number(decoded, aoc_e->associated.charge.number.str, aoc_e->associated.charge.number.plan);
3353                 break;
3354         case PRI_AOC_E_CHARGING_ASSOCIATION_ID:
3355                 ast_aoc_set_association_id(decoded, aoc_e->associated.charge.id);
3356                 break;
3357         default:
3358                 break;
3359         }
3360
3361         switch (aoc_e->billing_id) {
3362         case PRI_AOC_E_BILLING_ID_NORMAL:
3363                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NORMAL);
3364                 break;
3365         case PRI_AOC_E_BILLING_ID_REVERSE:
3366                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_REVERSE_CHARGE);
3367                 break;
3368         case PRI_AOC_E_BILLING_ID_CREDIT_CARD:
3369                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CREDIT_CARD);
3370                 break;
3371         case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_UNCONDITIONAL: