Change D-channel warning to be less confusing on non-NFAS setups.
[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 inline int pri_grab(struct sig_pri_chan *p, struct sig_pri_span *pri)
335 {
336         int res;
337         /* Grab the lock first */
338         do {
339                 res = ast_mutex_trylock(&pri->lock);
340                 if (res) {
341                         sig_pri_deadlock_avoidance_private(p);
342                 }
343         } while (res);
344         /* Then break the poll */
345         pthread_kill(pri->master, SIGURG);
346         return 0;
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 ? old_chan->owner->name : "",
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 ? old_chan->owner->name : "",
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", chan->name);
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", chan->name, 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", chan->name, 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", chan->name);
1831                                 break;
1832                         case AST_CONTROL_CONGESTION:
1833                                 ast_verb(4, "Idle channel '%s' congested, waiting...\n", chan->name);
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", chan->name);
1865                 ast_hangup(chan);
1866                 return NULL;
1867         }
1868
1869         ast_verb(3, "Starting simple switch on '%s'\n", chan->name);
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                                 if (!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                                 } else {
1946                                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
1947                                 }
1948                         }
1949                         sig_pri_unlock_private(p);
1950                 }
1951 #endif  /* defined(ISSUE_16789) */
1952
1953                 sig_pri_set_echocanceller(p, 1);
1954                 ast_setstate(chan, AST_STATE_RING);
1955                 res = ast_pbx_run(chan);
1956                 if (res) {
1957                         ast_log(LOG_WARNING, "PBX exited non-zero!\n");
1958                 }
1959         } else {
1960                 ast_debug(1, "No such possible extension '%s' in context '%s'\n", exten, chan->context);
1961                 chan->hangupcause = AST_CAUSE_UNALLOCATED;
1962                 ast_hangup(chan);
1963                 p->exten[0] = '\0';
1964                 /* Since we send release complete here, we won't get one */
1965                 p->call = NULL;
1966                 ast_mutex_lock(&p->pri->lock);
1967                 sig_pri_span_devstate_changed(p->pri);
1968                 ast_mutex_unlock(&p->pri->lock);
1969         }
1970         return NULL;
1971 }
1972
1973 void pri_event_alarm(struct sig_pri_span *pri, int index, int before_start_pri)
1974 {
1975         pri->dchanavail[index] &= ~(DCHAN_NOTINALARM | DCHAN_UP);
1976         if (!before_start_pri) {
1977                 pri_find_dchan(pri);
1978         }
1979 }
1980
1981 void pri_event_noalarm(struct sig_pri_span *pri, int index, int before_start_pri)
1982 {
1983         pri->dchanavail[index] |= DCHAN_NOTINALARM;
1984         if (!before_start_pri)
1985                 pri_restart(pri->dchans[index]);
1986 }
1987
1988 /*!
1989  * \internal
1990  * \brief Convert libpri party name into asterisk party name.
1991  * \since 1.8
1992  *
1993  * \param ast_name Asterisk party name structure to fill.  Must already be set initialized.
1994  * \param pri_name libpri party name structure containing source information.
1995  *
1996  * \note The filled in ast_name structure needs to be destroyed by
1997  * ast_party_name_free() when it is no longer needed.
1998  *
1999  * \return Nothing
2000  */
2001 static void sig_pri_party_name_convert(struct ast_party_name *ast_name, const struct pri_party_name *pri_name)
2002 {
2003         ast_name->str = ast_strdup(pri_name->str);
2004         ast_name->char_set = pri_to_ast_char_set(pri_name->char_set);
2005         ast_name->presentation = pri_to_ast_presentation(pri_name->presentation);
2006         ast_name->valid = 1;
2007 }
2008
2009 /*!
2010  * \internal
2011  * \brief Convert libpri party number into asterisk party number.
2012  * \since 1.8
2013  *
2014  * \param ast_number Asterisk party number structure to fill.  Must already be set initialized.
2015  * \param pri_number libpri party number structure containing source information.
2016  * \param pri PRI span control structure.
2017  *
2018  * \note The filled in ast_number structure needs to be destroyed by
2019  * ast_party_number_free() when it is no longer needed.
2020  *
2021  * \return Nothing
2022  */
2023 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)
2024 {
2025         char number[AST_MAX_EXTENSION];
2026
2027         apply_plan_to_existing_number(number, sizeof(number), pri, pri_number->str,
2028                 pri_number->plan);
2029         ast_number->str = ast_strdup(number);
2030         ast_number->plan = pri_number->plan;
2031         ast_number->presentation = pri_to_ast_presentation(pri_number->presentation);
2032         ast_number->valid = 1;
2033 }
2034
2035 /*!
2036  * \internal
2037  * \brief Convert libpri party id into asterisk party id.
2038  * \since 1.8
2039  *
2040  * \param ast_id Asterisk party id structure to fill.  Must already be set initialized.
2041  * \param pri_id libpri party id structure containing source information.
2042  * \param pri PRI span control structure.
2043  *
2044  * \note The filled in ast_id structure needs to be destroyed by
2045  * ast_party_id_free() when it is no longer needed.
2046  *
2047  * \return Nothing
2048  */
2049 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)
2050 {
2051         if (pri_id->name.valid) {
2052                 sig_pri_party_name_convert(&ast_id->name, &pri_id->name);
2053         }
2054         if (pri_id->number.valid) {
2055                 sig_pri_party_number_convert(&ast_id->number, &pri_id->number, pri);
2056         }
2057 #if defined(HAVE_PRI_SUBADDR)
2058         if (pri_id->subaddress.valid) {
2059                 sig_pri_set_subaddress(&ast_id->subaddress, &pri_id->subaddress);
2060         }
2061 #endif  /* defined(HAVE_PRI_SUBADDR) */
2062 }
2063
2064 /*!
2065  * \internal
2066  * \brief Convert libpri redirecting information into asterisk redirecting information.
2067  * \since 1.8
2068  *
2069  * \param ast_redirecting Asterisk redirecting structure to fill.
2070  * \param pri_redirecting libpri redirecting structure containing source information.
2071  * \param ast_guide Asterisk redirecting structure to use as an initialization guide.
2072  * \param pri PRI span control structure.
2073  *
2074  * \note The filled in ast_redirecting structure needs to be destroyed by
2075  * ast_party_redirecting_free() when it is no longer needed.
2076  *
2077  * \return Nothing
2078  */
2079 static void sig_pri_redirecting_convert(struct ast_party_redirecting *ast_redirecting,
2080         const struct pri_party_redirecting *pri_redirecting,
2081         const struct ast_party_redirecting *ast_guide,
2082         struct sig_pri_span *pri)
2083 {
2084         ast_party_redirecting_set_init(ast_redirecting, ast_guide);
2085
2086         sig_pri_party_id_convert(&ast_redirecting->from, &pri_redirecting->from, pri);
2087         sig_pri_party_id_convert(&ast_redirecting->to, &pri_redirecting->to, pri);
2088         ast_redirecting->count = pri_redirecting->count;
2089         ast_redirecting->reason = pri_to_ast_reason(pri_redirecting->reason);
2090 }
2091
2092 /*!
2093  * \internal
2094  * \brief Determine if the given extension matches one of the MSNs in the pattern list.
2095  * \since 1.8
2096  *
2097  * \param msn_patterns Comma separated list of MSN patterns to match.
2098  * \param exten Extension to match in the MSN list.
2099  *
2100  * \retval 1 if matches.
2101  * \retval 0 if no match.
2102  */
2103 static int sig_pri_msn_match(const char *msn_patterns, const char *exten)
2104 {
2105         char *pattern;
2106         char *msn_list;
2107         char *list_tail;
2108
2109         msn_list = ast_strdupa(msn_patterns);
2110
2111         list_tail = NULL;
2112         pattern = strtok_r(msn_list, ",", &list_tail);
2113         while (pattern) {
2114                 pattern = ast_strip(pattern);
2115                 if (!ast_strlen_zero(pattern) && ast_extension_match(pattern, exten)) {
2116                         /* Extension matched the pattern. */
2117                         return 1;
2118                 }
2119                 pattern = strtok_r(NULL, ",", &list_tail);
2120         }
2121         /* Did not match any pattern in the list. */
2122         return 0;
2123 }
2124
2125 #if defined(HAVE_PRI_MCID)
2126 /*!
2127  * \internal
2128  * \brief Append the given party id to the event string.
2129  * \since 1.8
2130  *
2131  * \param msg Event message string being built.
2132  * \param prefix Prefix to add to the party id lines.
2133  * \param party Party information to encode.
2134  *
2135  * \return Nothing
2136  */
2137 static void sig_pri_event_party_id(struct ast_str **msg, const char *prefix, struct ast_party_id *party)
2138 {
2139         int pres;
2140
2141         /* Combined party presentation */
2142         pres = ast_party_id_presentation(party);
2143         ast_str_append(msg, 0, "%sPres: %d (%s)\r\n", prefix, pres,
2144                 ast_describe_caller_presentation(pres));
2145
2146         /* Party number */
2147         ast_str_append(msg, 0, "%sNumValid: %d\r\n", prefix,
2148                 (unsigned) party->number.valid);
2149         ast_str_append(msg, 0, "%sNum: %s\r\n", prefix,
2150                 S_COR(party->number.valid, party->number.str, ""));
2151         ast_str_append(msg, 0, "%ston: %d\r\n", prefix, party->number.plan);
2152         if (party->number.valid) {
2153                 ast_str_append(msg, 0, "%sNumPlan: %d\r\n", prefix, party->number.plan);
2154                 ast_str_append(msg, 0, "%sNumPres: %d (%s)\r\n", prefix,
2155                         party->number.presentation,
2156                         ast_describe_caller_presentation(party->number.presentation));
2157         }
2158
2159         /* Party name */
2160         ast_str_append(msg, 0, "%sNameValid: %d\r\n", prefix,
2161                 (unsigned) party->name.valid);
2162         ast_str_append(msg, 0, "%sName: %s\r\n", prefix,
2163                 S_COR(party->name.valid, party->name.str, ""));
2164         if (party->name.valid) {
2165                 ast_str_append(msg, 0, "%sNameCharSet: %s\r\n", prefix,
2166                         ast_party_name_charset_describe(party->name.char_set));
2167                 ast_str_append(msg, 0, "%sNamePres: %d (%s)\r\n", prefix,
2168                         party->name.presentation,
2169                         ast_describe_caller_presentation(party->name.presentation));
2170         }
2171
2172 #if defined(HAVE_PRI_SUBADDR)
2173         /* Party subaddress */
2174         if (party->subaddress.valid) {
2175                 static const char subaddress[] = "Subaddr";
2176
2177                 ast_str_append(msg, 0, "%s%s: %s\r\n", prefix, subaddress,
2178                         S_OR(party->subaddress.str, ""));
2179                 ast_str_append(msg, 0, "%s%sType: %d\r\n", prefix, subaddress,
2180                         party->subaddress.type);
2181                 ast_str_append(msg, 0, "%s%sOdd: %d\r\n", prefix, subaddress,
2182                         party->subaddress.odd_even_indicator);
2183         }
2184 #endif  /* defined(HAVE_PRI_SUBADDR) */
2185 }
2186 #endif  /* defined(HAVE_PRI_MCID) */
2187
2188 #if defined(HAVE_PRI_MCID)
2189 /*!
2190  * \internal
2191  * \brief Handle the MCID event.
2192  * \since 1.8
2193  *
2194  * \param pri PRI span control structure.
2195  * \param mcid MCID event parameters.
2196  * \param owner Asterisk channel associated with the call.
2197  * NULL if Asterisk no longer has the ast_channel struct.
2198  *
2199  * \note Assumes the pri->lock is already obtained.
2200  * \note Assumes the owner channel lock is already obtained if still present.
2201  *
2202  * \return Nothing
2203  */
2204 static void sig_pri_mcid_event(struct sig_pri_span *pri, const struct pri_subcmd_mcid_req *mcid, struct ast_channel *owner)
2205 {
2206         struct ast_channel *chans[1];
2207         struct ast_str *msg;
2208         struct ast_party_id party;
2209
2210         msg = ast_str_create(4096);
2211         if (!msg) {
2212                 return;
2213         }
2214
2215         if (owner) {
2216                 /*
2217                  * The owner channel is present.
2218                  * Pass the event to the peer as well.
2219                  */
2220                 ast_queue_control(owner, AST_CONTROL_MCID);
2221
2222                 ast_str_append(&msg, 0, "Channel: %s\r\n", owner->name);
2223                 ast_str_append(&msg, 0, "UniqueID: %s\r\n", owner->uniqueid);
2224
2225                 sig_pri_event_party_id(&msg, "CallerID", &owner->connected.id);
2226         } else {
2227                 /*
2228                  * Since we no longer have an owner channel,
2229                  * we have to use the caller information supplied by libpri.
2230                  */
2231                 ast_party_id_init(&party);
2232                 sig_pri_party_id_convert(&party, &mcid->originator, pri);
2233                 sig_pri_event_party_id(&msg, "CallerID", &party);
2234                 ast_party_id_free(&party);
2235         }
2236
2237         /* Always use libpri's called party information. */
2238         ast_party_id_init(&party);
2239         sig_pri_party_id_convert(&party, &mcid->answerer, pri);
2240         sig_pri_event_party_id(&msg, "ConnectedID", &party);
2241         ast_party_id_free(&party);
2242
2243         chans[0] = owner;
2244         ast_manager_event_multichan(EVENT_FLAG_CALL, "MCID", owner ? 1 : 0, chans, "%s",
2245                 ast_str_buffer(msg));
2246         ast_free(msg);
2247 }
2248 #endif  /* defined(HAVE_PRI_MCID) */
2249
2250 #if defined(HAVE_PRI_TRANSFER)
2251 struct xfer_rsp_data {
2252         struct sig_pri_span *pri;
2253         /*! Call to send transfer success/fail response over. */
2254         q931_call *call;
2255         /*! Invocation ID to use when sending a reply to the transfer request. */
2256         int invoke_id;
2257 };
2258 #endif  /* defined(HAVE_PRI_TRANSFER) */
2259
2260 #if defined(HAVE_PRI_TRANSFER)
2261 /*!
2262  * \internal
2263  * \brief Send the transfer success/fail response message.
2264  * \since 1.8
2265  *
2266  * \param data Callback user data pointer
2267  * \param is_successful TRUE if the transfer was successful.
2268  *
2269  * \return Nothing
2270  */
2271 static void sig_pri_transfer_rsp(void *data, int is_successful)
2272 {
2273         struct xfer_rsp_data *rsp = data;
2274
2275         pri_transfer_rsp(rsp->pri->pri, rsp->call, rsp->invoke_id, is_successful);
2276 }
2277 #endif  /* defined(HAVE_PRI_TRANSFER) */
2278
2279 #if defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
2280 /*!
2281  * \brief Protocol callback to indicate if transfer will happen.
2282  * \since 1.8
2283  *
2284  * \param data Callback user data pointer
2285  * \param is_successful TRUE if the transfer will happen.
2286  *
2287  * \return Nothing
2288  */
2289 typedef void (*xfer_rsp_callback)(void *data, int is_successful);
2290 #endif  /* defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER) */
2291
2292 #if defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
2293 /*!
2294  * \internal
2295  * \brief Attempt to transfer the two calls to each other.
2296  * \since 1.8
2297  *
2298  * \param pri PRI span control structure.
2299  * \param call_1_pri First call involved in the transfer. (transferee; usually on hold)
2300  * \param call_1_held TRUE if call_1_pri is on hold.
2301  * \param call_2_pri Second call involved in the transfer. (target; usually active/ringing)
2302  * \param call_2_held TRUE if call_2_pri is on hold.
2303  * \param rsp_callback Protocol callback to indicate if transfer will happen. NULL if not used.
2304  * \param data Callback user data pointer
2305  *
2306  * \note Assumes the pri->lock is already obtained.
2307  *
2308  * \retval 0 on success.
2309  * \retval -1 on error.
2310  */
2311 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)
2312 {
2313         struct attempt_xfer_call {
2314                 q931_call *pri;
2315                 struct ast_channel *ast;
2316                 int held;
2317                 int chanpos;
2318         };
2319         int retval;
2320         struct ast_channel *transferee;
2321         struct attempt_xfer_call *call_1;
2322         struct attempt_xfer_call *call_2;
2323         struct attempt_xfer_call *swap_call;
2324         struct attempt_xfer_call c1;
2325         struct attempt_xfer_call c2;
2326
2327         c1.pri = call_1_pri;
2328         c1.held = call_1_held;
2329         call_1 = &c1;
2330
2331         c2.pri = call_2_pri;
2332         c2.held = call_2_held;
2333         call_2 = &c2;
2334
2335         call_1->chanpos = pri_find_principle_by_call(pri, call_1->pri);
2336         call_2->chanpos = pri_find_principle_by_call(pri, call_2->pri);
2337         if (call_1->chanpos < 0 || call_2->chanpos < 0) {
2338                 /* Calls not found in span control. */
2339                 if (rsp_callback) {
2340                         /* Transfer failed. */
2341                         rsp_callback(data, 0);
2342                 }
2343                 return -1;
2344         }
2345
2346         /* Attempt to make transferee and target consistent. */
2347         if (!call_1->held && call_2->held) {
2348                 /*
2349                  * Swap call_1 and call_2 to make call_1 the transferee(held call)
2350                  * and call_2 the target(active call).
2351                  */
2352                 swap_call = call_1;
2353                 call_1 = call_2;
2354                 call_2 = swap_call;
2355         }
2356
2357         /* Deadlock avoidance is attempted. */
2358         sig_pri_lock_private(pri->pvts[call_1->chanpos]);
2359         sig_pri_lock_owner(pri, call_1->chanpos);
2360         sig_pri_lock_private(pri->pvts[call_2->chanpos]);
2361         sig_pri_lock_owner(pri, call_2->chanpos);
2362
2363         call_1->ast = pri->pvts[call_1->chanpos]->owner;
2364         call_2->ast = pri->pvts[call_2->chanpos]->owner;
2365         if (!call_1->ast || !call_2->ast) {
2366                 /* At least one owner is not present. */
2367                 if (call_1->ast) {
2368                         ast_channel_unlock(call_1->ast);
2369                 }
2370                 if (call_2->ast) {
2371                         ast_channel_unlock(call_2->ast);
2372                 }
2373                 sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2374                 sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2375                 if (rsp_callback) {
2376                         /* Transfer failed. */
2377                         rsp_callback(data, 0);
2378                 }
2379                 return -1;
2380         }
2381
2382         for (;;) {
2383                 transferee = ast_bridged_channel(call_1->ast);
2384                 if (transferee) {
2385                         break;
2386                 }
2387
2388                 /* Try masquerading the other way. */
2389                 swap_call = call_1;
2390                 call_1 = call_2;
2391                 call_2 = swap_call;
2392
2393                 transferee = ast_bridged_channel(call_1->ast);
2394                 if (transferee) {
2395                         break;
2396                 }
2397
2398                 /* Could not transfer.  Neither call is bridged. */
2399                 ast_channel_unlock(call_1->ast);
2400                 ast_channel_unlock(call_2->ast);
2401                 sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2402                 sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2403
2404                 if (rsp_callback) {
2405                         /* Transfer failed. */
2406                         rsp_callback(data, 0);
2407                 }
2408                 return -1;
2409         }
2410
2411         ast_verb(3, "TRANSFERRING %s to %s\n", call_1->ast->name, call_2->ast->name);
2412
2413         /*
2414          * Setup transfer masquerade.
2415          *
2416          * Note:  There is an extremely nasty deadlock avoidance issue
2417          * with ast_channel_transfer_masquerade().  Deadlock may be possible if
2418          * the channels involved are proxies (chan_agent channels) and
2419          * it is called with locks.  Unfortunately, there is no simple
2420          * or even merely difficult way to guarantee deadlock avoidance
2421          * and still be able to send an ECT success response without the
2422          * possibility of the bridged channel hanging up on us.
2423          */
2424         ast_mutex_unlock(&pri->lock);
2425         retval = ast_channel_transfer_masquerade(
2426                 call_2->ast,
2427                 &call_2->ast->connected,
2428                 call_2->held,
2429                 transferee,
2430                 &call_1->ast->connected,
2431                 call_1->held);
2432
2433         /* Reacquire the pri->lock to hold off completion of the transfer masquerade. */
2434         ast_mutex_lock(&pri->lock);
2435
2436         ast_channel_unlock(call_1->ast);
2437         ast_channel_unlock(call_2->ast);
2438         sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2439         sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2440
2441         if (rsp_callback) {
2442                 /*
2443                  * Report transfer status.
2444                  *
2445                  * Must do the callback before the masquerade completes to ensure
2446                  * that the protocol message goes out before the call leg is
2447                  * disconnected.
2448                  */
2449                 rsp_callback(data, retval ? 0 : 1);
2450         }
2451         return retval;
2452 }
2453 #endif  /* defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER) */
2454
2455 #if defined(HAVE_PRI_CCSS)
2456 /*!
2457  * \internal
2458  * \brief Compare the CC agent private data by libpri cc_id.
2459  * \since 1.8
2460  *
2461  * \param obj pointer to the (user-defined part) of an object.
2462  * \param arg callback argument from ao2_callback()
2463  * \param flags flags from ao2_callback()
2464  *
2465  * \return values are a combination of enum _cb_results.
2466  */
2467 static int sig_pri_cc_agent_cmp_cc_id(void *obj, void *arg, int flags)
2468 {
2469         struct ast_cc_agent *agent_1 = obj;
2470         struct sig_pri_cc_agent_prv *agent_prv_1 = agent_1->private_data;
2471         struct sig_pri_cc_agent_prv *agent_prv_2 = arg;
2472
2473         return (agent_prv_1 && agent_prv_1->pri == agent_prv_2->pri
2474                 && agent_prv_1->cc_id == agent_prv_2->cc_id) ? CMP_MATCH | CMP_STOP : 0;
2475 }
2476 #endif  /* defined(HAVE_PRI_CCSS) */
2477
2478 #if defined(HAVE_PRI_CCSS)
2479 /*!
2480  * \internal
2481  * \brief Find the CC agent by libpri cc_id.
2482  * \since 1.8
2483  *
2484  * \param pri PRI span control structure.
2485  * \param cc_id CC record ID to find.
2486  *
2487  * \note
2488  * Since agents are refcounted, and this function returns
2489  * a reference to the agent, it is imperative that you decrement
2490  * the refcount of the agent once you have finished using it.
2491  *
2492  * \retval agent on success.
2493  * \retval NULL not found.
2494  */
2495 static struct ast_cc_agent *sig_pri_find_cc_agent_by_cc_id(struct sig_pri_span *pri, long cc_id)
2496 {
2497         struct sig_pri_cc_agent_prv finder = {
2498                 .pri = pri,
2499                 .cc_id = cc_id,
2500         };
2501
2502         return ast_cc_agent_callback(0, sig_pri_cc_agent_cmp_cc_id, &finder,
2503                 sig_pri_cc_type_name);
2504 }
2505 #endif  /* defined(HAVE_PRI_CCSS) */
2506
2507 #if defined(HAVE_PRI_CCSS)
2508 /*!
2509  * \internal
2510  * \brief Compare the CC monitor instance by libpri cc_id.
2511  * \since 1.8
2512  *
2513  * \param obj pointer to the (user-defined part) of an object.
2514  * \param arg callback argument from ao2_callback()
2515  * \param flags flags from ao2_callback()
2516  *
2517  * \return values are a combination of enum _cb_results.
2518  */
2519 static int sig_pri_cc_monitor_cmp_cc_id(void *obj, void *arg, int flags)
2520 {
2521         struct sig_pri_cc_monitor_instance *monitor_1 = obj;
2522         struct sig_pri_cc_monitor_instance *monitor_2 = arg;
2523
2524         return (monitor_1->pri == monitor_2->pri
2525                 && monitor_1->cc_id == monitor_2->cc_id) ? CMP_MATCH | CMP_STOP : 0;
2526 }
2527 #endif  /* defined(HAVE_PRI_CCSS) */
2528
2529 #if defined(HAVE_PRI_CCSS)
2530 /*!
2531  * \internal
2532  * \brief Find the CC monitor instance by libpri cc_id.
2533  * \since 1.8
2534  *
2535  * \param pri PRI span control structure.
2536  * \param cc_id CC record ID to find.
2537  *
2538  * \note
2539  * Since monitor_instances are refcounted, and this function returns
2540  * a reference to the instance, it is imperative that you decrement
2541  * the refcount of the instance once you have finished using it.
2542  *
2543  * \retval monitor_instance on success.
2544  * \retval NULL not found.
2545  */
2546 static struct sig_pri_cc_monitor_instance *sig_pri_find_cc_monitor_by_cc_id(struct sig_pri_span *pri, long cc_id)
2547 {
2548         struct sig_pri_cc_monitor_instance finder = {
2549                 .pri = pri,
2550                 .cc_id = cc_id,
2551         };
2552
2553         return ao2_callback(sig_pri_cc_monitors, 0, sig_pri_cc_monitor_cmp_cc_id, &finder);
2554 }
2555 #endif  /* defined(HAVE_PRI_CCSS) */
2556
2557 #if defined(HAVE_PRI_CCSS)
2558 /*!
2559  * \internal
2560  * \brief Destroy the given monitor instance.
2561  * \since 1.8
2562  *
2563  * \param data Monitor instance to destroy.
2564  *
2565  * \return Nothing
2566  */
2567 static void sig_pri_cc_monitor_instance_destroy(void *data)
2568 {
2569         struct sig_pri_cc_monitor_instance *monitor_instance = data;
2570
2571         if (monitor_instance->cc_id != -1) {
2572                 ast_mutex_lock(&monitor_instance->pri->lock);
2573                 pri_cc_cancel(monitor_instance->pri->pri, monitor_instance->cc_id);
2574                 ast_mutex_unlock(&monitor_instance->pri->lock);
2575         }
2576         monitor_instance->pri->calls->module_unref();
2577 }
2578 #endif  /* defined(HAVE_PRI_CCSS) */
2579
2580 #if defined(HAVE_PRI_CCSS)
2581 /*!
2582  * \internal
2583  * \brief Construct a new monitor instance.
2584  * \since 1.8
2585  *
2586  * \param core_id CC core ID.
2587  * \param pri PRI span control structure.
2588  * \param cc_id CC record ID.
2589  * \param device_name Name of device (Asterisk channel name less sequence number).
2590  *
2591  * \note
2592  * Since monitor_instances are refcounted, and this function returns
2593  * a reference to the instance, it is imperative that you decrement
2594  * the refcount of the instance once you have finished using it.
2595  *
2596  * \retval monitor_instance on success.
2597  * \retval NULL on error.
2598  */
2599 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)
2600 {
2601         struct sig_pri_cc_monitor_instance *monitor_instance;
2602
2603         if (!pri->calls->module_ref || !pri->calls->module_unref) {
2604                 return NULL;
2605         }
2606
2607         monitor_instance = ao2_alloc(sizeof(*monitor_instance) + strlen(device_name),
2608                 sig_pri_cc_monitor_instance_destroy);
2609         if (!monitor_instance) {
2610                 return NULL;
2611         }
2612
2613         monitor_instance->cc_id = cc_id;
2614         monitor_instance->pri = pri;
2615         monitor_instance->core_id = core_id;
2616         strcpy(monitor_instance->name, device_name);
2617
2618         pri->calls->module_ref();
2619
2620         ao2_link(sig_pri_cc_monitors, monitor_instance);
2621         return monitor_instance;
2622 }
2623 #endif  /* defined(HAVE_PRI_CCSS) */
2624
2625 #if defined(HAVE_PRI_CCSS)
2626 /*!
2627  * \internal
2628  * \brief Announce to the CC core that protocol CC monitor is available for this call.
2629  * \since 1.8
2630  *
2631  * \param pri PRI span control structure.
2632  * \param chanpos Channel position in the span.
2633  * \param cc_id CC record ID.
2634  * \param service CCBS/CCNR indication.
2635  *
2636  * \note Assumes the pri->lock is already obtained.
2637  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
2638  * \note Assumes the sig_pri_lock_owner(pri, chanpos) is already obtained.
2639  *
2640  * \retval 0 on success.
2641  * \retval -1 on error.
2642  */
2643 static int sig_pri_cc_available(struct sig_pri_span *pri, int chanpos, long cc_id, enum ast_cc_service_type service)
2644 {
2645         struct sig_pri_chan *pvt;
2646         struct ast_cc_config_params *cc_params;
2647         struct sig_pri_cc_monitor_instance *monitor;
2648         enum ast_cc_monitor_policies monitor_policy;
2649         int core_id;
2650         int res;
2651         char device_name[AST_CHANNEL_NAME];
2652         char dialstring[AST_CHANNEL_NAME];
2653
2654         pvt = pri->pvts[chanpos];
2655
2656         core_id = ast_cc_get_current_core_id(pvt->owner);
2657         if (core_id == -1) {
2658                 return -1;
2659         }
2660
2661         cc_params = ast_channel_get_cc_config_params(pvt->owner);
2662         if (!cc_params) {
2663                 return -1;
2664         }
2665
2666         res = -1;
2667         monitor_policy = ast_get_cc_monitor_policy(cc_params);
2668         switch (monitor_policy) {
2669         case AST_CC_MONITOR_NEVER:
2670                 /* CCSS is not enabled. */
2671                 break;
2672         case AST_CC_MONITOR_NATIVE:
2673         case AST_CC_MONITOR_ALWAYS:
2674                 /*
2675                  * If it is AST_CC_MONITOR_ALWAYS and native fails we will attempt the fallback
2676                  * later in the call to sig_pri_cc_generic_check().
2677                  */
2678                 ast_channel_get_device_name(pvt->owner, device_name, sizeof(device_name));
2679                 sig_pri_make_cc_dialstring(pvt, dialstring, sizeof(dialstring));
2680                 monitor = sig_pri_cc_monitor_instance_init(core_id, pri, cc_id, device_name);
2681                 if (!monitor) {
2682                         break;
2683                 }
2684                 res = ast_queue_cc_frame(pvt->owner, sig_pri_cc_type_name, dialstring, service,
2685                         monitor);
2686                 if (res) {
2687                         monitor->cc_id = -1;
2688                         ao2_unlink(sig_pri_cc_monitors, monitor);
2689                         ao2_ref(monitor, -1);
2690                 }
2691                 break;
2692         case AST_CC_MONITOR_GENERIC:
2693                 ast_queue_cc_frame(pvt->owner, AST_CC_GENERIC_MONITOR_TYPE,
2694                         sig_pri_get_orig_dialstring(pvt), service, NULL);
2695                 /* Say it failed to force caller to cancel native CC. */
2696                 break;
2697         }
2698         return res;
2699 }
2700 #endif  /* defined(HAVE_PRI_CCSS) */
2701
2702 /*!
2703  * \internal
2704  * \brief Check if generic CC monitor is needed and request it.
2705  * \since 1.8
2706  *
2707  * \param pri PRI span control structure.
2708  * \param chanpos Channel position in the span.
2709  * \param service CCBS/CCNR indication.
2710  *
2711  * \note Assumes the pri->lock is already obtained.
2712  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
2713  *
2714  * \return Nothing
2715  */
2716 static void sig_pri_cc_generic_check(struct sig_pri_span *pri, int chanpos, enum ast_cc_service_type service)
2717 {
2718         struct ast_channel *owner;
2719         struct ast_cc_config_params *cc_params;
2720 #if defined(HAVE_PRI_CCSS)
2721         struct ast_cc_monitor *monitor;
2722         char device_name[AST_CHANNEL_NAME];
2723 #endif  /* defined(HAVE_PRI_CCSS) */
2724         enum ast_cc_monitor_policies monitor_policy;
2725         int core_id;
2726
2727         if (!pri->pvts[chanpos]->outgoing) {
2728                 /* This is not an outgoing call so it cannot be CC monitor. */
2729                 return;
2730         }
2731
2732         sig_pri_lock_owner(pri, chanpos);
2733         owner = pri->pvts[chanpos]->owner;
2734         if (!owner) {
2735                 return;
2736         }
2737         core_id = ast_cc_get_current_core_id(owner);
2738         if (core_id == -1) {
2739                 /* No CC core setup */
2740                 goto done;
2741         }
2742
2743         cc_params = ast_channel_get_cc_config_params(owner);
2744         if (!cc_params) {
2745                 /* Could not get CC config parameters. */
2746                 goto done;
2747         }
2748
2749 #if defined(HAVE_PRI_CCSS)
2750         ast_channel_get_device_name(owner, device_name, sizeof(device_name));
2751         monitor = ast_cc_get_monitor_by_recall_core_id(core_id, device_name);
2752         if (monitor) {
2753                 /* CC monitor is already present so no need for generic CC. */
2754                 ao2_ref(monitor, -1);
2755                 goto done;
2756         }
2757 #endif  /* defined(HAVE_PRI_CCSS) */
2758
2759         monitor_policy = ast_get_cc_monitor_policy(cc_params);
2760         switch (monitor_policy) {
2761         case AST_CC_MONITOR_NEVER:
2762                 /* CCSS is not enabled. */
2763                 break;
2764         case AST_CC_MONITOR_NATIVE:
2765                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype == PRI_NETWORK) {
2766                         /* Request generic CC monitor. */
2767                         ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2768                                 sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2769                 }
2770                 break;
2771         case AST_CC_MONITOR_ALWAYS:
2772                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype != PRI_NETWORK) {
2773                         /*
2774                          * Cannot monitor PTMP TE side since this is not defined.
2775                          * We are playing the roll of a phone in this case and
2776                          * a phone cannot monitor a party over the network without
2777                          * protocol help.
2778                          */
2779                         break;
2780                 }
2781                 /*
2782                  * We are either falling back or this is a PTMP NT span.
2783                  * Request generic CC monitor.
2784                  */
2785                 ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2786                         sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2787                 break;
2788         case AST_CC_MONITOR_GENERIC:
2789                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype == PRI_NETWORK) {
2790                         /* Request generic CC monitor. */
2791                         ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2792                                 sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2793                 }
2794                 break;
2795         }
2796
2797 done:
2798         ast_channel_unlock(owner);
2799 }
2800
2801 #if defined(HAVE_PRI_CCSS)
2802 /*!
2803  * \internal
2804  * \brief The CC link canceled the CC instance.
2805  * \since 1.8
2806  *
2807  * \param pri PRI span control structure.
2808  * \param cc_id CC record ID.
2809  * \param is_agent TRUE if the cc_id is for an agent.
2810  *
2811  * \return Nothing
2812  */
2813 static void sig_pri_cc_link_canceled(struct sig_pri_span *pri, long cc_id, int is_agent)
2814 {
2815         if (is_agent) {
2816                 struct ast_cc_agent *agent;
2817
2818                 agent = sig_pri_find_cc_agent_by_cc_id(pri, cc_id);
2819                 if (!agent) {
2820                         return;
2821                 }
2822                 ast_cc_failed(agent->core_id, "%s agent got canceled by link",
2823                         sig_pri_cc_type_name);
2824                 ao2_ref(agent, -1);
2825         } else {
2826                 struct sig_pri_cc_monitor_instance *monitor;
2827
2828                 monitor = sig_pri_find_cc_monitor_by_cc_id(pri, cc_id);
2829                 if (!monitor) {
2830                         return;
2831                 }
2832                 monitor->cc_id = -1;
2833                 ast_cc_monitor_failed(monitor->core_id, monitor->name,
2834                         "%s monitor got canceled by link", sig_pri_cc_type_name);
2835                 ao2_ref(monitor, -1);
2836         }
2837 }
2838 #endif  /* defined(HAVE_PRI_CCSS) */
2839
2840 #if defined(HAVE_PRI_AOC_EVENTS)
2841 /*!
2842  * \internal
2843  * \brief Convert ast_aoc_charged_item to PRI_AOC_CHARGED_ITEM .
2844  * \since 1.8
2845  *
2846  * \param value Value to convert to string.
2847  *
2848  * \return PRI_AOC_CHARGED_ITEM
2849  */
2850 static enum PRI_AOC_CHARGED_ITEM sig_pri_aoc_charged_item_to_pri(enum PRI_AOC_CHARGED_ITEM value)
2851 {
2852         switch (value) {
2853         case AST_AOC_CHARGED_ITEM_NA:
2854                 return PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE;
2855         case AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT:
2856                 return PRI_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
2857         case AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION:
2858                 return PRI_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
2859         case AST_AOC_CHARGED_ITEM_CALL_ATTEMPT:
2860                 return PRI_AOC_CHARGED_ITEM_CALL_ATTEMPT;
2861         case AST_AOC_CHARGED_ITEM_CALL_SETUP:
2862                 return PRI_AOC_CHARGED_ITEM_CALL_SETUP;
2863         case AST_AOC_CHARGED_ITEM_USER_USER_INFO:
2864                 return PRI_AOC_CHARGED_ITEM_USER_USER_INFO;
2865         case AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE:
2866                 return PRI_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
2867         }
2868         return PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE;
2869 }
2870 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2871
2872 #if defined(HAVE_PRI_AOC_EVENTS)
2873 /*!
2874  * \internal
2875  * \brief Convert PRI_AOC_CHARGED_ITEM to ast_aoc_charged_item.
2876  * \since 1.8
2877  *
2878  * \param value Value to convert to string.
2879  *
2880  * \return ast_aoc_charged_item
2881  */
2882 static enum ast_aoc_s_charged_item sig_pri_aoc_charged_item_to_ast(enum PRI_AOC_CHARGED_ITEM value)
2883 {
2884         switch (value) {
2885         case PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE:
2886                 return AST_AOC_CHARGED_ITEM_NA;
2887         case PRI_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT:
2888                 return AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
2889         case PRI_AOC_CHARGED_ITEM_BASIC_COMMUNICATION:
2890                 return AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
2891         case PRI_AOC_CHARGED_ITEM_CALL_ATTEMPT:
2892                 return AST_AOC_CHARGED_ITEM_CALL_ATTEMPT;
2893         case PRI_AOC_CHARGED_ITEM_CALL_SETUP:
2894                 return AST_AOC_CHARGED_ITEM_CALL_SETUP;
2895         case PRI_AOC_CHARGED_ITEM_USER_USER_INFO:
2896                 return AST_AOC_CHARGED_ITEM_USER_USER_INFO;
2897         case PRI_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE:
2898                 return AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
2899         }
2900         return AST_AOC_CHARGED_ITEM_NA;
2901 }
2902 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2903
2904 #if defined(HAVE_PRI_AOC_EVENTS)
2905 /*!
2906  * \internal
2907  * \brief Convert AST_AOC_MULTIPLER to PRI_AOC_MULTIPLIER.
2908  * \since 1.8
2909  *
2910  * \return pri enum equivalent.
2911  */
2912 static int sig_pri_aoc_multiplier_from_ast(enum ast_aoc_currency_multiplier mult)
2913 {
2914         switch (mult) {
2915         case AST_AOC_MULT_ONETHOUSANDTH:
2916                 return PRI_AOC_MULTIPLIER_THOUSANDTH;
2917         case AST_AOC_MULT_ONEHUNDREDTH:
2918                 return PRI_AOC_MULTIPLIER_HUNDREDTH;
2919         case AST_AOC_MULT_ONETENTH:
2920                 return PRI_AOC_MULTIPLIER_TENTH;
2921         case AST_AOC_MULT_ONE:
2922                 return PRI_AOC_MULTIPLIER_ONE;
2923         case AST_AOC_MULT_TEN:
2924                 return PRI_AOC_MULTIPLIER_TEN;
2925         case AST_AOC_MULT_HUNDRED:
2926                 return PRI_AOC_MULTIPLIER_HUNDRED;
2927         case AST_AOC_MULT_THOUSAND:
2928                 return PRI_AOC_MULTIPLIER_THOUSAND;
2929         default:
2930                 return PRI_AOC_MULTIPLIER_ONE;
2931         }
2932 }
2933 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2934
2935 #if defined(HAVE_PRI_AOC_EVENTS)
2936 /*!
2937  * \internal
2938  * \brief Convert PRI_AOC_MULTIPLIER to AST_AOC_MULTIPLIER
2939  * \since 1.8
2940  *
2941  * \return ast enum equivalent.
2942  */
2943 static int sig_pri_aoc_multiplier_from_pri(const int mult)
2944 {
2945         switch (mult) {
2946         case PRI_AOC_MULTIPLIER_THOUSANDTH:
2947                 return AST_AOC_MULT_ONETHOUSANDTH;
2948         case PRI_AOC_MULTIPLIER_HUNDREDTH:
2949                 return AST_AOC_MULT_ONEHUNDREDTH;
2950         case PRI_AOC_MULTIPLIER_TENTH:
2951                 return AST_AOC_MULT_ONETENTH;
2952         case PRI_AOC_MULTIPLIER_ONE:
2953                 return AST_AOC_MULT_ONE;
2954         case PRI_AOC_MULTIPLIER_TEN:
2955                 return AST_AOC_MULT_TEN;
2956         case PRI_AOC_MULTIPLIER_HUNDRED:
2957                 return AST_AOC_MULT_HUNDRED;
2958         case PRI_AOC_MULTIPLIER_THOUSAND:
2959                 return AST_AOC_MULT_THOUSAND;
2960         default:
2961                 return AST_AOC_MULT_ONE;
2962         }
2963 }
2964 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2965
2966 #if defined(HAVE_PRI_AOC_EVENTS)
2967 /*!
2968  * \internal
2969  * \brief Convert ast_aoc_time_scale representation to PRI_AOC_TIME_SCALE
2970  * \since 1.8
2971  *
2972  * \param value Value to convert to ast representation
2973  *
2974  * \return PRI_AOC_TIME_SCALE
2975  */
2976 static enum PRI_AOC_TIME_SCALE sig_pri_aoc_scale_to_pri(enum ast_aoc_time_scale value)
2977 {
2978         switch (value) {
2979         default:
2980         case AST_AOC_TIME_SCALE_HUNDREDTH_SECOND:
2981                 return PRI_AOC_TIME_SCALE_HUNDREDTH_SECOND;
2982         case AST_AOC_TIME_SCALE_TENTH_SECOND:
2983                 return PRI_AOC_TIME_SCALE_TENTH_SECOND;
2984         case AST_AOC_TIME_SCALE_SECOND:
2985                 return PRI_AOC_TIME_SCALE_SECOND;
2986         case AST_AOC_TIME_SCALE_TEN_SECOND:
2987                 return PRI_AOC_TIME_SCALE_TEN_SECOND;
2988         case AST_AOC_TIME_SCALE_MINUTE:
2989                 return PRI_AOC_TIME_SCALE_MINUTE;
2990         case AST_AOC_TIME_SCALE_HOUR:
2991                 return PRI_AOC_TIME_SCALE_HOUR;
2992         case AST_AOC_TIME_SCALE_DAY:
2993                 return PRI_AOC_TIME_SCALE_DAY;
2994         }
2995 }
2996 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2997
2998 #if defined(HAVE_PRI_AOC_EVENTS)
2999 /*!
3000  * \internal
3001  * \brief Convert PRI_AOC_TIME_SCALE to ast aoc representation
3002  * \since 1.8
3003  *
3004  * \param value Value to convert to ast representation
3005  *
3006  * \return ast aoc time scale
3007  */
3008 static enum ast_aoc_time_scale sig_pri_aoc_scale_to_ast(enum PRI_AOC_TIME_SCALE value)
3009 {
3010         switch (value) {
3011         default:
3012         case PRI_AOC_TIME_SCALE_HUNDREDTH_SECOND:
3013                 return AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
3014         case PRI_AOC_TIME_SCALE_TENTH_SECOND:
3015                 return AST_AOC_TIME_SCALE_TENTH_SECOND;
3016         case PRI_AOC_TIME_SCALE_SECOND:
3017                 return AST_AOC_TIME_SCALE_SECOND;
3018         case PRI_AOC_TIME_SCALE_TEN_SECOND:
3019                 return AST_AOC_TIME_SCALE_TEN_SECOND;
3020         case PRI_AOC_TIME_SCALE_MINUTE:
3021                 return AST_AOC_TIME_SCALE_MINUTE;
3022         case PRI_AOC_TIME_SCALE_HOUR:
3023                 return AST_AOC_TIME_SCALE_HOUR;
3024         case PRI_AOC_TIME_SCALE_DAY:
3025                 return AST_AOC_TIME_SCALE_DAY;
3026         }
3027         return AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
3028 }
3029 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3030
3031 #if defined(HAVE_PRI_AOC_EVENTS)
3032 /*!
3033  * \internal
3034  * \brief Handle AOC-S control frame
3035  * \since 1.8
3036  *
3037  * \param aoc_s AOC-S event parameters.
3038  * \param owner Asterisk channel associated with the call.
3039  * \param passthrough indicating if this message should be queued on the ast channel
3040  *
3041  * \note Assumes the pri->lock is already obtained.
3042  * \note Assumes the sig_pri private is locked
3043  * \note Assumes the owner channel lock is already obtained.
3044  *
3045  * \return Nothing
3046  */
3047 static void sig_pri_aoc_s_from_pri(const struct pri_subcmd_aoc_s *aoc_s, struct ast_channel *owner, int passthrough)
3048 {
3049         struct ast_aoc_decoded *decoded = NULL;
3050         struct ast_aoc_encoded *encoded = NULL;
3051         size_t encoded_size = 0;
3052         int idx;
3053
3054         if (!owner || !aoc_s) {
3055                 return;
3056         }
3057
3058         if (!(decoded = ast_aoc_create(AST_AOC_S, 0, 0))) {
3059                 return;
3060         }
3061
3062         for (idx = 0; idx < aoc_s->num_items; ++idx) {
3063                 enum ast_aoc_s_charged_item charged_item;
3064
3065                 charged_item = sig_pri_aoc_charged_item_to_ast(aoc_s->item[idx].chargeable);
3066                 if (charged_item == AST_AOC_CHARGED_ITEM_NA) {
3067                         /* Delete the unknown charged item from the list. */
3068                         continue;
3069                 }
3070                 switch (aoc_s->item[idx].rate_type) {
3071                 case PRI_AOC_RATE_TYPE_DURATION:
3072                         ast_aoc_s_add_rate_duration(decoded,
3073                                 charged_item,
3074                                 aoc_s->item[idx].rate.duration.amount.cost,
3075                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.duration.amount.multiplier),
3076                                 aoc_s->item[idx].rate.duration.currency,
3077                                 aoc_s->item[idx].rate.duration.time.length,
3078                                 sig_pri_aoc_scale_to_ast(aoc_s->item[idx].rate.duration.time.scale),
3079                                 aoc_s->item[idx].rate.duration.granularity.length,
3080                                 sig_pri_aoc_scale_to_ast(aoc_s->item[idx].rate.duration.granularity.scale),
3081                                 aoc_s->item[idx].rate.duration.charging_type);
3082                         break;
3083                 case PRI_AOC_RATE_TYPE_FLAT:
3084                         ast_aoc_s_add_rate_flat(decoded,
3085                                 charged_item,
3086                                 aoc_s->item[idx].rate.flat.amount.cost,
3087                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.flat.amount.multiplier),
3088                                 aoc_s->item[idx].rate.flat.currency);
3089                         break;
3090                 case PRI_AOC_RATE_TYPE_VOLUME:
3091                         ast_aoc_s_add_rate_volume(decoded,
3092                                 charged_item,
3093                                 aoc_s->item[idx].rate.volume.unit,
3094                                 aoc_s->item[idx].rate.volume.amount.cost,
3095                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.volume.amount.multiplier),
3096                                 aoc_s->item[idx].rate.volume.currency);
3097                         break;
3098                 case PRI_AOC_RATE_TYPE_SPECIAL_CODE:
3099                         ast_aoc_s_add_rate_special_charge_code(decoded,
3100                                 charged_item,
3101                                 aoc_s->item[idx].rate.special);
3102                         break;
3103                 case PRI_AOC_RATE_TYPE_FREE:
3104                         ast_aoc_s_add_rate_free(decoded, charged_item, 0);
3105                         break;
3106                 case PRI_AOC_RATE_TYPE_FREE_FROM_BEGINNING:
3107                         ast_aoc_s_add_rate_free(decoded, charged_item, 1);
3108                         break;
3109                 default:
3110                         ast_aoc_s_add_rate_na(decoded, charged_item);
3111                         break;
3112                 }
3113         }
3114
3115         if (passthrough && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
3116                 ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
3117         }
3118
3119         ast_aoc_manager_event(decoded, owner);
3120
3121         ast_aoc_destroy_decoded(decoded);
3122         ast_aoc_destroy_encoded(encoded);
3123 }
3124 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3125
3126 #if defined(HAVE_PRI_AOC_EVENTS)
3127 /*!
3128  * \internal
3129  * \brief Generate AOC Request Response
3130  * \since 1.8
3131  *
3132  * \param aoc_request
3133  *
3134  * \note Assumes the pri->lock is already obtained.
3135  * \note Assumes the sig_pri private is locked
3136  * \note Assumes the owner channel lock is already obtained.
3137  *
3138  * \return Nothing
3139  */
3140 static void sig_pri_aoc_request_from_pri(const struct pri_subcmd_aoc_request *aoc_request, struct sig_pri_chan *pvt, q931_call *call)
3141 {
3142         int request;
3143
3144         if (!aoc_request) {
3145                 return;
3146         }
3147
3148         request = aoc_request->charging_request;
3149
3150         if (request & PRI_AOC_REQUEST_S) {
3151                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_S) {
3152                         /* An AOC-S response must come from the other side, so save off this invoke_id
3153                          * and see if an AOC-S message comes in before the call is answered. */
3154                         pvt->aoc_s_request_invoke_id = aoc_request->invoke_id;
3155                         pvt->aoc_s_request_invoke_id_valid = 1;
3156
3157                 } else {
3158                         pri_aoc_s_request_response_send(pvt->pri->pri,
3159                                 call,
3160                                 aoc_request->invoke_id,
3161                                 NULL);
3162                 }
3163         }
3164
3165         if (request & PRI_AOC_REQUEST_D) {
3166                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_D) {
3167                         pri_aoc_de_request_response_send(pvt->pri->pri,
3168                                 call,
3169                                 PRI_AOC_REQ_RSP_CHARGING_INFO_FOLLOWS,
3170                                 aoc_request->invoke_id);
3171                 } else {
3172                         pri_aoc_de_request_response_send(pvt->pri->pri,
3173                                 call,
3174                                 PRI_AOC_REQ_RSP_ERROR_NOT_AVAILABLE,
3175                                 aoc_request->invoke_id);
3176                 }
3177         }
3178
3179         if (request & PRI_AOC_REQUEST_E) {
3180                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_E) {
3181                         pri_aoc_de_request_response_send(pvt->pri->pri,
3182                                 call,
3183                                 PRI_AOC_REQ_RSP_CHARGING_INFO_FOLLOWS,
3184                                 aoc_request->invoke_id);
3185                 } else {
3186                         pri_aoc_de_request_response_send(pvt->pri->pri,
3187                                 call,
3188                                 PRI_AOC_REQ_RSP_ERROR_NOT_AVAILABLE,
3189                                 aoc_request->invoke_id);
3190                 }
3191         }
3192 }
3193 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3194
3195 #if defined(HAVE_PRI_AOC_EVENTS)
3196 /*!
3197  * \internal
3198  * \brief Generate AOC-D AST_CONTROL_AOC frame
3199  * \since 1.8
3200  *
3201  * \param aoc_e AOC-D event parameters.
3202  * \param owner Asterisk channel associated with the call.
3203  * \param passthrough indicating if this message should be queued on the ast channel
3204  *
3205  * \note Assumes the pri->lock is already obtained.
3206  * \note Assumes the sig_pri private is locked
3207  * \note Assumes the owner channel lock is already obtained.
3208  *
3209  * \return Nothing
3210  */
3211 static void sig_pri_aoc_d_from_pri(const struct pri_subcmd_aoc_d *aoc_d, struct ast_channel *owner, int passthrough)
3212 {
3213         struct ast_aoc_decoded *decoded = NULL;
3214         struct ast_aoc_encoded *encoded = NULL;
3215         size_t encoded_size = 0;
3216         enum ast_aoc_charge_type type;
3217
3218         if (!owner || !aoc_d) {
3219                 return;
3220         }
3221
3222         switch (aoc_d->charge) {
3223         case PRI_AOC_DE_CHARGE_CURRENCY:
3224                 type = AST_AOC_CHARGE_CURRENCY;
3225                 break;
3226         case PRI_AOC_DE_CHARGE_UNITS:
3227                 type = AST_AOC_CHARGE_UNIT;
3228                 break;
3229         case PRI_AOC_DE_CHARGE_FREE:
3230                 type = AST_AOC_CHARGE_FREE;
3231                 break;
3232         default:
3233                 type = AST_AOC_CHARGE_NA;
3234                 break;
3235         }
3236
3237         if (!(decoded = ast_aoc_create(AST_AOC_D, type, 0))) {
3238                 return;
3239         }
3240
3241         switch (aoc_d->billing_accumulation) {
3242         default:
3243                 ast_debug(1, "AOC-D billing accumulation has unknown value: %d\n",
3244                         aoc_d->billing_accumulation);
3245                 /* Fall through */
3246         case 0:/* subTotal */
3247                 ast_aoc_set_total_type(decoded, AST_AOC_SUBTOTAL);
3248                 break;
3249         case 1:/* total */
3250                 ast_aoc_set_total_type(decoded, AST_AOC_TOTAL);
3251                 break;
3252         }
3253
3254         switch (aoc_d->billing_id) {
3255         case PRI_AOC_D_BILLING_ID_NORMAL:
3256                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NORMAL);
3257                 break;
3258         case PRI_AOC_D_BILLING_ID_REVERSE:
3259                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_REVERSE_CHARGE);
3260                 break;
3261         case PRI_AOC_D_BILLING_ID_CREDIT_CARD:
3262                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CREDIT_CARD);
3263                 break;
3264         case PRI_AOC_D_BILLING_ID_NOT_AVAILABLE:
3265         default:
3266                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NA);
3267                 break;
3268         }
3269
3270         switch (aoc_d->charge) {
3271         case PRI_AOC_DE_CHARGE_CURRENCY:
3272                 ast_aoc_set_currency_info(decoded,
3273                         aoc_d->recorded.money.amount.cost,
3274                         sig_pri_aoc_multiplier_from_pri(aoc_d->recorded.money.amount.multiplier),
3275                         aoc_d->recorded.money.currency);
3276                 break;
3277         case PRI_AOC_DE_CHARGE_UNITS:
3278                 {
3279                         int i;
3280                         for (i = 0; i < aoc_d->recorded.unit.num_items; ++i) {
3281                                 /* if type or number are negative, then they are not present */
3282                                 ast_aoc_add_unit_entry(decoded,
3283                                         (aoc_d->recorded.unit.item[i].number >= 0 ? 1 : 0),
3284                                         aoc_d->recorded.unit.item[i].number,
3285                                         (aoc_d->recorded.unit.item[i].type >= 0 ? 1 : 0),
3286                                         aoc_d->recorded.unit.item[i].type);
3287                         }
3288                 }
3289                 break;
3290         }
3291
3292         if (passthrough && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
3293                 ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
3294         }
3295
3296         ast_aoc_manager_event(decoded, owner);
3297
3298         ast_aoc_destroy_decoded(decoded);
3299         ast_aoc_destroy_encoded(encoded);
3300 }
3301 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3302
3303 #if defined(HAVE_PRI_AOC_EVENTS)
3304 /*!
3305  * \internal
3306  * \brief Generate AOC-E AST_CONTROL_AOC frame
3307  * \since 1.8
3308  *
3309  * \param aoc_e AOC-E event parameters.
3310  * \param owner Asterisk channel associated with the call.
3311  * \param passthrough indicating if this message should be queued on the ast channel
3312  *
3313  * \note Assumes the pri->lock is already obtained.
3314  * \note Assumes the sig_pri private is locked
3315  * \note Assumes the owner channel lock is already obtained.
3316  * \note owner channel may be NULL. In that case, generate event only
3317  *
3318  * \return Nothing
3319  */
3320 static void sig_pri_aoc_e_from_pri(const struct pri_subcmd_aoc_e *aoc_e, struct ast_channel *owner, int passthrough)
3321 {
3322         struct ast_aoc_decoded *decoded = NULL;
3323         struct ast_aoc_encoded *encoded = NULL;
3324         size_t encoded_size = 0;
3325         enum ast_aoc_charge_type type;
3326
3327         if (!aoc_e) {
3328                 return;
3329         }
3330
3331         switch (aoc_e->charge) {
3332         case PRI_AOC_DE_CHARGE_CURRENCY:
3333                 type = AST_AOC_CHARGE_CURRENCY;
3334                 break;
3335         case PRI_AOC_DE_CHARGE_UNITS:
3336                 type = AST_AOC_CHARGE_UNIT;
3337                 break;
3338         case PRI_AOC_DE_CHARGE_FREE:
3339                 type = AST_AOC_CHARGE_FREE;
3340                 break;
3341         default:
3342                 type = AST_AOC_CHARGE_NA;
3343                 break;
3344         }
3345
3346         if (!(decoded = ast_aoc_create(AST_AOC_E, type, 0))) {
3347                 return;
3348         }
3349
3350         switch (aoc_e->associated.charging_type) {
3351         case PRI_AOC_E_CHARGING_ASSOCIATION_NUMBER:
3352                 if (!aoc_e->associated.charge.number.valid) {
3353                         break;
3354                 }
3355                 ast_aoc_set_association_number(decoded, aoc_e->associated.charge.number.str, aoc_e->associated.charge.number.plan);
3356                 break;
3357         case PRI_AOC_E_CHARGING_ASSOCIATION_ID:
3358                 ast_aoc_set_association_id(decoded, aoc_e->associated.charge.id);
3359                 break;
3360         default:
3361                 break;
3362         }
3363
3364         switch (aoc_e->billing_id) {
3365         case PRI_AOC_E_BILLING_ID_NORMAL:
3366                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NORMAL);
3367                 break;
3368         case PRI_AOC_E_BILLING_ID_REVERSE:
3369                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_REVERSE_CHARGE);
3370                 break;
3371         case PRI_AOC_E_BILLING_ID_CREDIT_CARD:
3372                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CREDIT_CARD);
3373                 break;
3374         case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_UNCONDITIONAL:
3375                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_UNCONDITIONAL);
3376                 break;
3377         case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_BUSY:
3378                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_BUSY);
3379                 break;
3380         case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_NO_REPLY:
3381                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_NO_REPLY);
3382                 break;
3383         case PRI_AOC_E_BILLING_ID_CALL_DEFLECTION:
3384                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_DEFLECTION);
3385                 break;
3386         case PRI_AOC_E_BILLING_ID_CALL_TRANSFER:
3387                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_TRANSFER);
3388                 break;
3389         case PRI_AOC_E_BILLING_ID_NOT_AVAILABLE:
3390         default:
3391                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NA);
3392                 break;
3393         }
3394
3395         switch (aoc_e->charge) {
3396         case PRI_AOC_DE_CHARGE_CURRENCY:
3397                 ast_aoc_set_currency_info(decoded,
3398                         aoc_e->recorded.money.amount.cost,
3399                         sig_pri_aoc_multiplier_from_pri(aoc_e->recorded.money.amount.multiplier),
3400                         aoc_e->recorded.money.currency);
3401                 break;
3402         case PRI_AOC_DE_CHARGE_UNITS:
3403                 {
3404                         int i;
3405                         for (i = 0; i < aoc_e->recorded.unit.num_items; ++i) {
3406                                 /* if type or number are negative, then they are not present */
3407                                 ast_aoc_add_unit_entry(decoded,
3408                                         (aoc_e->recorded.unit.item[i].number >= 0 ? 1 : 0),
3409                                         aoc_e->recorded.unit.item[i].number,
3410                                         (aoc_e->recorded.unit.item[i].type >= 0 ? 1 : 0),
3411                                         aoc_e->recorded.unit.item[i].type);
3412                         }
3413                 }
3414         }
3415
3416         if (passthrough && owner && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
3417                 ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
3418         }
3419
3420         ast_aoc_manager_event(decoded, owner);
3421
3422         ast_aoc_destroy_decoded(decoded);
3423         ast_aoc_destroy_encoded(encoded);
3424 }
3425 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3426
3427 #if defined(HAVE_PRI_AOC_EVENTS)
3428 /*!
3429  * \internal
3430  * \brief send an AOC-S message on the current call
3431  *
3432  * \param pvt sig_pri private channel structure.
3433  * \param generic decoded ast AOC message
3434  *
3435  * \return Nothing
3436  *
3437  * \note Assumes that the PRI lock is already obtained.
3438  */
3439 static void sig_pri_aoc_s_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
3440 {
3441         struct pri_subcmd_aoc_s aoc_s = { 0, };
3442         const struct ast_aoc_s_entry *entry;
3443         int idx;
3444
3445         for (idx = 0; idx < ast_aoc_s_get_count(decoded); idx++) {
3446                 if (!(entry = ast_aoc_s_get_rate_info(decoded, idx))) {
3447                         break;
3448                 }
3449
3450                 aoc_s.item[idx].chargeable = sig_pri_aoc_charged_item_to_pri(entry->charged_item);
3451
3452                 switch (entry->rate_type) {
3453                 case AST_AOC_RATE_TYPE_DURATION:
3454                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_DURATION;
3455                         aoc_s.item[idx].rate.duration.amount.cost = entry->rate.duration.amount;
3456                         aoc_s.item[idx].rate.duration.amount.multiplier =
3457                                 sig_pri_aoc_multiplier_from_ast(entry->rate.duration.multiplier);
3458                         aoc_s.item[idx].rate.duration.time.length = entry->rate.duration.time;
3459                         aoc_s.item[idx].rate.duration.time.scale =
3460                                 sig_pri_aoc_scale_to_pri(entry->rate.duration.time_scale);
3461                         aoc_s.item[idx].rate.duration.granularity.length = entry->rate.duration.granularity_time;
3462                         aoc_s.item[idx].rate.duration.granularity.scale =
3463                                 sig_pri_aoc_scale_to_pri(entry->rate.duration.granularity_time_scale);
3464                         aoc_s.item[idx].rate.duration.charging_type = entry->rate.duration.charging_type;
3465
3466                         if (!ast_strlen_zero(entry->rate.duration.currency_name)) {
3467                                 ast_copy_string(aoc_s.item[idx].rate.duration.currency,
3468                                         entry->rate.duration.currency_name,
3469                                         sizeof(aoc_s.item[idx].rate.duration.currency));
3470                         }
3471                         break;
3472                 case AST_AOC_RATE_TYPE_FLAT:
3473                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FLAT;
3474                         aoc_s.item[idx].rate.flat.amount.cost = entry->rate.flat.amount;
3475                         aoc_s.item[idx].rate.flat.amount.multiplier =
3476                                 sig_pri_aoc_multiplier_from_ast(entry->rate.flat.multiplier);
3477
3478                         if (!ast_strlen_zero(entry->rate.flat.currency_name)) {
3479                                 ast_copy_string(aoc_s.item[idx].rate.flat.currency,
3480                                         entry->rate.flat.currency_name,
3481                                         sizeof(aoc_s.item[idx].rate.flat.currency));
3482                         }
3483                         break;
3484                 case AST_AOC_RATE_TYPE_VOLUME:
3485                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_VOLUME;
3486                         aoc_s.item[idx].rate.volume.unit = entry->rate.volume.volume_unit;
3487                         aoc_s.item[idx].rate.volume.amount.cost = entry->rate.volume.amount;
3488                         aoc_s.item[idx].rate.volume.amount.multiplier =
3489                                 sig_pri_aoc_multiplier_from_ast(entry->rate.volume.multiplier);
3490
3491                         if (!ast_strlen_zero(entry->rate.volume.currency_name)) {
3492                                 ast_copy_string(aoc_s.item[idx].rate.volume.currency,
3493                                         entry->rate.volume.currency_name,
3494                                         sizeof(aoc_s.item[idx].rate.volume.currency));
3495                         }
3496                         break;
3497                 case AST_AOC_RATE_TYPE_SPECIAL_CODE:
3498                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_SPECIAL_CODE;
3499                         aoc_s.item[idx].rate.special = entry->rate.special_code;
3500                         break;
3501                 case AST_AOC_RATE_TYPE_FREE:
3502                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FREE;
3503                         break;
3504                 case AST_AOC_RATE_TYPE_FREE_FROM_BEGINNING:
3505                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FREE_FROM_BEGINNING;
3506                         break;
3507                 default:
3508                 case AST_AOC_RATE_TYPE_NA:
3509                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_NOT_AVAILABLE;
3510                         break;
3511                 }
3512         }
3513         aoc_s.num_items = idx;
3514
3515         /* if this rate should be sent as a response to an AOC-S request we will
3516          * have an aoc_s_request_invoke_id associated with this pvt */
3517         if (pvt->aoc_s_request_invoke_id_valid) {
3518                 pri_aoc_s_request_response_send(pvt->pri->pri, pvt->call, pvt->aoc_s_request_invoke_id, &aoc_s);
3519                 pvt->aoc_s_request_invoke_id_valid = 0;
3520         } else {
3521                 pri_aoc_s_send(pvt->pri->pri, pvt->call, &aoc_s);
3522         }
3523 }
3524 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3525
3526 #if defined(HAVE_PRI_AOC_EVENTS)
3527 /*!
3528  * \internal
3529  * \brief send an AOC-D message on the current call
3530  *
3531  * \param pvt sig_pri private channel structure.
3532  * \param generic decoded ast AOC message
3533  *
3534  * \return Nothing
3535  *
3536  * \note Assumes that the PRI lock is already obtained.
3537  */
3538 static void sig_pri_aoc_d_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
3539 {
3540         struct pri_subcmd_aoc_d aoc_d = { 0, };
3541
3542         aoc_d.billing_accumulation = (ast_aoc_get_total_type(decoded) == AST_AOC_TOTAL) ? 1 : 0;
3543
3544         switch (ast_aoc_get_billing_id(decoded)) {
3545         case AST_AOC_BILLING_NORMAL:
3546                 aoc_d.billing_id = PRI_AOC_D_BILLING_ID_NORMAL;
3547                 break;
3548         case AST_AOC_BILLING_REVERSE_CHARGE:
3549                 aoc_d.billing_id = PRI_AOC_D_BILLING_ID_REVERSE;
3550                 break;
3551         case AST_AOC_BILLING_CREDIT_CARD:
3552                 aoc_d.billing_id = PRI_AOC_D_BILLING_ID_CREDIT_CARD;
3553                 break;
3554         case AST_AOC_BILLING_NA:
3555         default:
3556                 aoc_d.billing_id = PRI_AOC_D_BILLING_ID_NOT_AVAILABLE;
3557                 break;
3558         }
3559
3560         switch (ast_aoc_get_charge_type(decoded)) {
3561         case AST_AOC_CHARGE_FREE:
3562                 aoc_d.charge = PRI_AOC_DE_CHARGE_FREE;
3563                 break;
3564         case AST_AOC_CHARGE_CURRENCY:
3565                 {
3566                         const char *currency_name = ast_aoc_get_currency_name(decoded);
3567                         aoc_d.charge = PRI_AOC_DE_CHARGE_CURRENCY;
3568                         aoc_d.recorded.money.amount.cost = ast_aoc_get_currency_amount(decoded);
3569                         aoc_d.recorded.money.amount.multiplier = sig_pri_aoc_multiplier_from_ast(ast_aoc_get_currency_multiplier(decoded));
3570                         if (!ast_strlen_zero(currency_name)) {
3571                                 ast_copy_string(aoc_d.recorded.money.currency, currency_name, sizeof(aoc_d.recorded.money.currency));
3572                         }
3573                 }
3574                 break;
3575         case AST_AOC_CHARGE_UNIT:
3576                 {
3577                         const struct ast_aoc_unit_entry *entry;
3578                         int i;
3579                         aoc_d.charge = PRI_AOC_DE_CHARGE_UNITS;
3580                         for (i = 0; i < ast_aoc_get_unit_count(decoded); i++) {
3581                                 if ((entry = ast_aoc_get_unit_info(decoded, i)) && i < ARRAY_LEN(aoc_d.recorded.unit.item)) {
3582                                         if (entry->valid_amount) {
3583                                                 aoc_d.recorded.unit.item[i].number = entry->amount;
3584                                         } else {
3585                                                 aoc_d.recorded.unit.item[i].number = -1;
3586                                         }
3587                                         if (entry->valid_type) {
3588                                                 aoc_d.recorded.unit.item[i].type = entry->type;
3589                                         } else {
3590                                                 aoc_d.recorded.unit.item[i].type = -1;
3591                                         }
3592                                         aoc_d.recorded.unit.num_items++;
3593                                 } else {
3594                                         break;
3595                                 }
3596                         }
3597                 }
3598                 break;
3599         case AST_AOC_CHARGE_NA:
3600         default:
3601                 aoc_d.charge = PRI_AOC_DE_CHARGE_NOT_AVAILABLE;
3602                 break;
3603         }
3604
3605         pri_aoc_d_send(pvt->pri->pri, pvt->call, &aoc_d);
3606 }
3607 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3608
3609 #if defined(HAVE_PRI_AOC_EVENTS)
3610 /*!
3611  * \internal
3612  * \brief send an AOC-E message on the current call
3613  *
3614  * \param pvt sig_pri private channel structure.
3615  * \param generic decoded ast AOC message
3616  *
3617  * \return Nothing
3618  *
3619  * \note Assumes that the PRI lock is already obtained.
3620  */
3621 static void sig_pri_aoc_e_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
3622 {
3623         struct pri_subcmd_aoc_e *aoc_e = &pvt->aoc_e;
3624         const struct ast_aoc_charging_association *ca = ast_aoc_get_association_info(decoded);
3625
3626         memset(aoc_e, 0, sizeof(*aoc_e));
3627         pvt->holding_aoce = 1;
3628
3629         switch (ca->charging_type) {
3630         case AST_AOC_CHARGING_ASSOCIATION_NUMBER:
3631                 aoc_e->associated.charge.number.valid = 1;
3632                 ast_copy_string(aoc_e->associated.charge.number.str,
3633                         ca->charge.number.number,
3634                         sizeof(aoc_e->associated.charge.number.str));
3635                 aoc_e->associated.charge.number.plan = ca->charge.number.plan;
3636                 aoc_e->associated.charging_type = PRI_AOC_E_CHARGING_ASSOCIATION_NUMBER;
3637                 break;
3638         case AST_AOC_CHARGING_ASSOCIATION_ID:
3639                 aoc_e->associated.charge.id = ca->charge.id;
3640                 aoc_e->associated.charging_type = PRI_AOC_E_CHARGING_ASSOCIATION_ID;
3641                 break;
3642         case AST_AOC_CHARGING_ASSOCIATION_NA:
3643         default:
3644                 break;
3645         }
3646
3647         switch (ast_aoc_get_billing_id(decoded)) {
3648         case AST_AOC_BILLING_NORMAL:
3649                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_NORMAL;
3650                 break;
3651         case AST_AOC_BILLING_REVERSE_CHARGE:
3652                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_REVERSE;
3653                 break;
3654         case AST_AOC_BILLING_CREDIT_CARD:
3655                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CREDIT_CARD;
3656                 break;
3657         case AST_AOC_BILLING_CALL_FWD_UNCONDITIONAL:
3658                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_UNCONDITIONAL;
3659                 break;
3660         case AST_AOC_BILLING_CALL_FWD_BUSY:
3661                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_BUSY;
3662                 break;
3663         case AST_AOC_BILLING_CALL_FWD_NO_REPLY:
3664                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_NO_REPLY;
3665                 break;
3666         case AST_AOC_BILLING_CALL_DEFLECTION:
3667                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_DEFLECTION;
3668                 break;
3669         case AST_AOC_BILLING_CALL_TRANSFER:
3670                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_TRANSFER;
3671                 break;
3672         case AST_AOC_BILLING_NA:
3673         default:
3674                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_NOT_AVAILABLE;
3675                 break;
3676         }
3677
3678         switch (ast_aoc_get_charge_type(decoded)) {
3679         case AST_AOC_CHARGE_FREE:
3680                 aoc_e->charge = PRI_AOC_DE_CHARGE_FREE;
3681                 break;
3682         case AST_AOC_CHARGE_CURRENCY:
3683                 {
3684                         const char *currency_name = ast_aoc_get_currency_name(decoded);
3685                         aoc_e->charge = PRI_AOC_DE_CHARGE_CURRENCY;
3686                         aoc_e->recorded.money.amount.cost = ast_aoc_get_currency_amount(decoded);
3687                         aoc_e->recorded.money.amount.multiplier = sig_pri_aoc_multiplier_from_ast(ast_aoc_get_currency_multiplier(decoded));
3688                         if (!ast_strlen_zero(currency_name)) {
3689                                 ast_copy_string(aoc_e->recorded.money.currency, currency_name, sizeof(aoc_e->recorded.money.currency));
3690                         }
3691                 }
3692                 break;
3693         case AST_AOC_CHARGE_UNIT:
3694                 {
3695                         const struct ast_aoc_unit_entry *entry;
3696                         int i;
3697                         aoc_e->charge = PRI_AOC_DE_CHARGE_UNITS;
3698                         for (i = 0; i < ast_aoc_get_unit_count(decoded); i++) {
3699                                 if ((entry = ast_aoc_get_unit_info(decoded, i)) && i < ARRAY_LEN(aoc_e->recorded.unit.item)) {
3700                                         if (entry->valid_amount) {
3701                                                 aoc_e->recorded.unit.item[i].number = entry->amount;
3702                                         } else {
3703                                                 aoc_e->recorded.unit.item[i].number = -1;
3704                                         }
3705                                         if (entry->valid_type) {
3706                                                 aoc_e->recorded.unit.item[i].type = entry->type;
3707                                         } else {
3708                                                 aoc_e->recorded.unit.item[i].type = -1;
3709                                         }
3710                                         aoc_e->recorded.unit.num_items++;
3711                                 }
3712                         }
3713                 }
3714                 break;
3715         case AST_AOC_CHARGE_NA:
3716         default:
3717                 aoc_e->charge = PRI_AOC_DE_CHARGE_NOT_AVAILABLE;
3718                 break;
3719         }
3720 }
3721 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3722
3723 #if defined(HAVE_PRI_AOC_EVENTS)
3724 /*!
3725  * \internal
3726  * \brief send an AOC-E termination request on ast_channel and set
3727  * hangup delay.
3728  *
3729  * \param pri PRI span control structure.
3730  * \param chanpos Channel position in the span.
3731  * \param ms to delay hangup
3732  *
3733  * \note Assumes the pri->lock is already obtained.
3734  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
3735  *
3736  * \return Nothing
3737  */
3738 static void sig_pri_send_aoce_termination_request(struct sig_pri_span *pri, int chanpos, unsigned int ms)
3739 {
3740         struct sig_pri_chan *pvt;
3741         struct ast_aoc_decoded *decoded = NULL;
3742         struct ast_aoc_encoded *encoded = NULL;
3743         size_t encoded_size;
3744         struct timeval whentohangup = { 0, };
3745
3746         sig_pri_lock_owner(pri, chanpos);
3747         pvt = pri->pvts[chanpos];
3748         if (!pvt->owner) {
3749                 return;
3750         }
3751
3752         if (!(decoded = ast_aoc_create(AST_AOC_REQUEST, 0, AST_AOC_REQUEST_E))) {
3753                 ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
3754                 goto cleanup_termination_request;
3755         }
3756
3757         ast_aoc_set_termination_request(decoded);
3758
3759         if (!(encoded = ast_aoc_encode(decoded, &encoded_size, pvt->owner))) {
3760                 ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
3761                 goto cleanup_termination_request;
3762         }
3763
3764         /* convert ms to timeval */
3765         whentohangup.tv_usec = (ms % 1000) * 1000;
3766         whentohangup.tv_sec = ms / 1000;
3767
3768         if (ast_queue_control_data(pvt->owner, AST_CONTROL_AOC, encoded, encoded_size)) {
3769                 ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
3770                 goto cleanup_termination_request;
3771         }
3772
3773         pvt->waiting_for_aoce = 1;
3774         ast_channel_setwhentohangup_tv(pvt->owner, whentohangup);
3775         ast_debug(1, "Delaying hangup on %s for aoc-e msg\n", pvt->owner->name);
3776
3777 cleanup_termination_request:
3778         ast_channel_unlock(pvt->owner);
3779         ast_aoc_destroy_decoded(decoded);
3780         ast_aoc_destroy_encoded(encoded);
3781 }
3782 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3783
3784 /*!
3785  * \internal
3786  * \brief TRUE if PRI event came in on a CIS call.
3787  * \since 1.8
3788  *
3789  * \param channel PRI encoded span/channel
3790  *
3791  * \retval non-zero if CIS call.
3792  */
3793 static int sig_pri_is_cis_call(int channel)
3794 {
3795         return channel != -1 && (channel & PRI_CIS_CALL);
3796 }
3797
3798 /*!
3799  * \internal
3800  * \brief Handle the CIS associated PRI subcommand events.
3801  * \since 1.8
3802  *
3803  * \param pri PRI span control structure.
3804  * \param event_id PRI event id
3805  * \param subcmds Subcommands to process if any. (Could be NULL).
3806  * \param call_rsp libpri opaque call structure to send any responses toward.
3807  * Could be NULL either because it is not available or the call is for the
3808  * dummy call reference.  However, this should not be NULL in the cases that
3809  * need to use the pointer to send a response message back.
3810  *
3811  * \note Assumes the pri->lock is already obtained.
3812  *
3813  * \return Nothing
3814  */
3815 static void sig_pri_handle_cis_subcmds(struct sig_pri_span *pri, int event_id,
3816         const struct pri_subcommands *subcmds, q931_call *call_rsp)
3817 {
3818         int index;
3819 #if defined(HAVE_PRI_CCSS)
3820         struct ast_cc_agent *agent;
3821         struct sig_pri_cc_agent_prv *agent_prv;
3822         struct sig_pri_cc_monitor_instance *monitor;
3823 #endif  /* defined(HAVE_PRI_CCSS) */
3824
3825         if (!subcmds) {
3826                 return;
3827         }
3828         for (index = 0; index < subcmds->counter_subcmd; ++index) {
3829                 const struct pri_subcommand *subcmd = &subcmds->subcmd[index];
3830
3831                 switch (subcmd->cmd) {
3832 #if defined(STATUS_REQUEST_PLACE_HOLDER)
3833                 case PRI_SUBCMD_STATUS_REQ:
3834                 case PRI_SUBCMD_STATUS_REQ_RSP:
3835                         /* Ignore for now. */
3836                         break;
3837 #endif  /* defined(STATUS_REQUEST_PLACE_HOLDER) */
3838 #if defined(HAVE_PRI_CCSS)
3839                 case PRI_SUBCMD_CC_REQ:
3840                         agent = sig_pri_find_cc_agent_by_cc_id(pri, subcmd->u.cc_request.cc_id);
3841                         if (!agent) {
3842                                 pri_cc_cancel(pri->pri, subcmd->u.cc_request.cc_id);
3843                                 break;
3844                         }
3845                         if (!ast_cc_request_is_within_limits()) {
3846                                 if (pri_cc_req_rsp(pri->pri, subcmd->u.cc_request.cc_id,
3847                                         5/* queue_full */)) {
3848                                         pri_cc_cancel(pri->pri, subcmd->u.cc_request.cc_id);
3849                                 }
3850                                 ast_cc_failed(agent->core_id, "%s agent system CC queue full",
3851                                         sig_pri_cc_type_name);
3852