28ff16ff79ee7a306fe22e7f672f1745f390f970
[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 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 int pri_find_dchan(struct sig_pri_span *pri)
1046 {
1047         int oldslot = -1;
1048         struct pri *old;
1049         int newslot = -1;
1050         int x;
1051         old = pri->pri;
1052         for (x = 0; x < SIG_PRI_NUM_DCHANS; x++) {
1053                 if ((pri->dchanavail[x] == DCHAN_AVAILABLE) && (newslot < 0))
1054                         newslot = x;
1055                 if (pri->dchans[x] == old) {
1056                         oldslot = x;
1057                 }
1058         }
1059         if (newslot < 0) {
1060                 newslot = 0;
1061                 /* This is annoying to see on non persistent layer 2 connections.  Let's not complain in that case */
1062                 if (pri->sig != SIG_BRI_PTMP && !pri->no_d_channels) {
1063                         pri->no_d_channels = 1;
1064                         ast_log(LOG_WARNING,
1065                                 "Span %d: No D-channels available!  Using Primary channel as D-channel anyway!\n",
1066                                 pri->span);
1067                 }
1068         } else {
1069                 pri->no_d_channels = 0;
1070         }
1071         if (old && (oldslot != newslot))
1072                 ast_log(LOG_NOTICE, "Switching from d-channel fd %d to fd %d!\n",
1073                         pri->fds[oldslot], pri->fds[newslot]);
1074         pri->pri = pri->dchans[newslot];
1075         return 0;
1076 }
1077
1078 /*!
1079  * \internal
1080  * \brief Determine if a private channel structure is in use.
1081  * \since 1.8
1082  *
1083  * \param pvt Channel to determine if in use.
1084  *
1085  * \return TRUE if the channel is in use.
1086  */
1087 static int sig_pri_is_chan_in_use(struct sig_pri_chan *pvt)
1088 {
1089         return pvt->owner || pvt->call || pvt->allocated || pvt->resetting || pvt->inalarm;
1090 }
1091
1092 /*!
1093  * \brief Determine if a private channel structure is available.
1094  * \since 1.8
1095  *
1096  * \param pvt Channel to determine if available.
1097  *
1098  * \return TRUE if the channel is available.
1099  */
1100 int sig_pri_is_chan_available(struct sig_pri_chan *pvt)
1101 {
1102         return !sig_pri_is_chan_in_use(pvt)
1103 #if defined(HAVE_PRI_SERVICE_MESSAGES)
1104                 /* And not out-of-service */
1105                 && !pvt->service_status
1106 #endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
1107                 ;
1108 }
1109
1110 /*!
1111  * \internal
1112  * \brief Obtain the sig_pri owner channel lock if the owner exists.
1113  * \since 1.8
1114  *
1115  * \param pri PRI span control structure.
1116  * \param chanpos Channel position in the span.
1117  *
1118  * \note Assumes the pri->lock is already obtained.
1119  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
1120  *
1121  * \return Nothing
1122  */
1123 static void sig_pri_lock_owner(struct sig_pri_span *pri, int chanpos)
1124 {
1125         for (;;) {
1126                 if (!pri->pvts[chanpos]->owner) {
1127                         /* There is no owner lock to get. */
1128                         break;
1129                 }
1130                 if (!ast_channel_trylock(pri->pvts[chanpos]->owner)) {
1131                         /* We got the lock */
1132                         break;
1133                 }
1134                 /* We must unlock the PRI to avoid the possibility of a deadlock */
1135                 ast_mutex_unlock(&pri->lock);
1136                 sig_pri_deadlock_avoidance_private(pri->pvts[chanpos]);
1137                 ast_mutex_lock(&pri->lock);
1138         }
1139 }
1140
1141 /*!
1142  * \internal
1143  * \brief Queue the given frame onto the owner channel.
1144  * \since 1.8
1145  *
1146  * \param pri PRI span control structure.
1147  * \param chanpos Channel position in the span.
1148  * \param frame Frame to queue onto the owner channel.
1149  *
1150  * \note Assumes the pri->lock is already obtained.
1151  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
1152  *
1153  * \return Nothing
1154  */
1155 static void pri_queue_frame(struct sig_pri_span *pri, int chanpos, struct ast_frame *frame)
1156 {
1157         sig_pri_lock_owner(pri, chanpos);
1158         if (pri->pvts[chanpos]->owner) {
1159                 ast_queue_frame(pri->pvts[chanpos]->owner, frame);
1160                 ast_channel_unlock(pri->pvts[chanpos]->owner);
1161         }
1162 }
1163
1164 /*!
1165  * \internal
1166  * \brief Queue a control frame of the specified subclass onto the owner channel.
1167  * \since 1.8
1168  *
1169  * \param pri PRI span control structure.
1170  * \param chanpos Channel position in the span.
1171  * \param subclass Control frame subclass to queue onto the owner channel.
1172  *
1173  * \note Assumes the pri->lock is already obtained.
1174  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
1175  *
1176  * \return Nothing
1177  */
1178 static void pri_queue_control(struct sig_pri_span *pri, int chanpos, int subclass)
1179 {
1180         struct ast_frame f = {AST_FRAME_CONTROL, };
1181         struct sig_pri_chan *p = pri->pvts[chanpos];
1182
1183         if (p->calls->queue_control) {
1184                 p->calls->queue_control(p->chan_pvt, subclass);
1185         }
1186
1187         f.subclass.integer = subclass;
1188         pri_queue_frame(pri, chanpos, &f);
1189 }
1190
1191 /*!
1192  * \internal
1193  * \brief Find the channel associated with the libpri call.
1194  * \since 10.0
1195  *
1196  * \param pri PRI span control structure.
1197  * \param call LibPRI opaque call pointer to find.
1198  *
1199  * \note Assumes the pri->lock is already obtained.
1200  *
1201  * \retval array-index into private pointer array on success.
1202  * \retval -1 on error.
1203  */
1204 static int pri_find_principle_by_call(struct sig_pri_span *pri, q931_call *call)
1205 {
1206         int idx;
1207
1208         if (!call) {
1209                 /* Cannot find a call without a call. */
1210                 return -1;
1211         }
1212         for (idx = 0; idx < pri->numchans; ++idx) {
1213                 if (pri->pvts[idx] && pri->pvts[idx]->call == call) {
1214                         /* Found the principle */
1215                         return idx;
1216                 }
1217         }
1218         return -1;
1219 }
1220
1221 /*!
1222  * \internal
1223  * \brief Kill the call.
1224  * \since 10.0
1225  *
1226  * \param pri PRI span control structure.
1227  * \param call LibPRI opaque call pointer to find.
1228  * \param cause Reason call was killed.
1229  *
1230  * \note Assumes the pvt->pri->lock is already obtained.
1231  *
1232  * \return Nothing
1233  */
1234 static void sig_pri_kill_call(struct sig_pri_span *pri, q931_call *call, int cause)
1235 {
1236         int chanpos;
1237
1238         chanpos = pri_find_principle_by_call(pri, call);
1239         if (chanpos < 0) {
1240                 pri_hangup(pri->pri, call, cause);
1241                 return;
1242         }
1243         sig_pri_lock_private(pri->pvts[chanpos]);
1244         if (!pri->pvts[chanpos]->owner) {
1245                 pri_hangup(pri->pri, call, cause);
1246                 pri->pvts[chanpos]->call = NULL;
1247                 sig_pri_unlock_private(pri->pvts[chanpos]);
1248                 sig_pri_span_devstate_changed(pri);
1249                 return;
1250         }
1251         pri->pvts[chanpos]->owner->hangupcause = cause;
1252         pri_queue_control(pri, chanpos, AST_CONTROL_HANGUP);
1253         sig_pri_unlock_private(pri->pvts[chanpos]);
1254 }
1255
1256 /*!
1257  * \internal
1258  * \brief Find the private structure for the libpri call.
1259  *
1260  * \param pri PRI span control structure.
1261  * \param channel LibPRI encoded channel ID.
1262  * \param call LibPRI opaque call pointer.
1263  *
1264  * \note Assumes the pri->lock is already obtained.
1265  *
1266  * \retval array-index into private pointer array on success.
1267  * \retval -1 on error.
1268  */
1269 static int pri_find_principle(struct sig_pri_span *pri, int channel, q931_call *call)
1270 {
1271         int x;
1272         int span;
1273         int principle;
1274         int prioffset;
1275
1276         if (channel < 0) {
1277                 /* Channel is not picked yet. */
1278                 return -1;
1279         }
1280
1281         prioffset = PRI_CHANNEL(channel);
1282         if (!prioffset || (channel & PRI_HELD_CALL)) {
1283                 /* Find the call waiting call or held call. */
1284                 return pri_find_principle_by_call(pri, call);
1285         }
1286
1287         span = PRI_SPAN(channel);
1288         if (!(channel & PRI_EXPLICIT)) {
1289                 int index;
1290
1291                 index = pri_active_dchan_index(pri);
1292                 if (index == -1) {
1293                         return -1;
1294                 }
1295                 span = pri->dchan_logical_span[index];
1296         }
1297
1298         principle = -1;
1299         for (x = 0; x < pri->numchans; x++) {
1300                 if (pri->pvts[x]
1301                         && pri->pvts[x]->prioffset == prioffset
1302                         && pri->pvts[x]->logicalspan == span
1303                         && !pri->pvts[x]->no_b_channel) {
1304                         principle = x;
1305                         break;
1306                 }
1307         }
1308
1309         return principle;
1310 }
1311
1312 /*!
1313  * \internal
1314  * \brief Fixup the private structure associated with the libpri call.
1315  *
1316  * \param pri PRI span control structure.
1317  * \param principle Array-index into private array to move call to if not already there.
1318  * \param call LibPRI opaque call pointer to find if need to move call.
1319  *
1320  * \note Assumes the pri->lock is already obtained.
1321  *
1322  * \retval principle on success.
1323  * \retval -1 on error.
1324  */
1325 static int pri_fixup_principle(struct sig_pri_span *pri, int principle, q931_call *call)
1326 {
1327         int x;
1328
1329         if (principle < 0 || pri->numchans <= principle) {
1330                 /* Out of rannge */
1331                 return -1;
1332         }
1333         if (!call) {
1334                 /* No call */
1335                 return principle;
1336         }
1337         if (pri->pvts[principle] && pri->pvts[principle]->call == call) {
1338                 /* Call is already on the specified principle. */
1339                 return principle;
1340         }
1341
1342         /* Find the old principle location. */
1343         for (x = 0; x < pri->numchans; x++) {
1344                 struct sig_pri_chan *new_chan;
1345                 struct sig_pri_chan *old_chan;
1346
1347                 if (!pri->pvts[x] || pri->pvts[x]->call != call) {
1348                         continue;
1349                 }
1350
1351                 /* Found our call */
1352                 new_chan = pri->pvts[principle];
1353                 old_chan = pri->pvts[x];
1354
1355                 /* Get locks to safely move to the new private structure. */
1356                 sig_pri_lock_private(old_chan);
1357                 sig_pri_lock_owner(pri, x);
1358                 sig_pri_lock_private(new_chan);
1359
1360                 ast_verb(3, "Moving call (%s) from channel %d to %d.\n",
1361                         old_chan->owner ? old_chan->owner->name : "",
1362                         old_chan->channel, new_chan->channel);
1363                 if (!sig_pri_is_chan_available(new_chan)) {
1364                         ast_log(LOG_WARNING,
1365                                 "Can't move call (%s) from channel %d to %d.  It is already in use.\n",
1366                                 old_chan->owner ? old_chan->owner->name : "",
1367                                 old_chan->channel, new_chan->channel);
1368                         sig_pri_unlock_private(new_chan);
1369                         if (old_chan->owner) {
1370                                 ast_channel_unlock(old_chan->owner);
1371                         }
1372                         sig_pri_unlock_private(old_chan);
1373                         return -1;
1374                 }
1375
1376                 sig_pri_fixup_chans(old_chan, new_chan);
1377
1378                 /* Fix it all up now */
1379                 new_chan->owner = old_chan->owner;
1380                 old_chan->owner = NULL;
1381
1382                 new_chan->call = old_chan->call;
1383                 old_chan->call = NULL;
1384
1385                 /* Transfer flags from the old channel. */
1386 #if defined(HAVE_PRI_AOC_EVENTS)
1387                 new_chan->aoc_s_request_invoke_id_valid = old_chan->aoc_s_request_invoke_id_valid;
1388                 new_chan->waiting_for_aoce = old_chan->waiting_for_aoce;
1389                 new_chan->holding_aoce = old_chan->holding_aoce;
1390 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
1391                 new_chan->alreadyhungup = old_chan->alreadyhungup;
1392                 new_chan->isidlecall = old_chan->isidlecall;
1393                 new_chan->progress = old_chan->progress;
1394                 new_chan->allocated = old_chan->allocated;
1395                 new_chan->outgoing = old_chan->outgoing;
1396                 new_chan->digital = old_chan->digital;
1397 #if defined(HAVE_PRI_CALL_WAITING)
1398                 new_chan->is_call_waiting = old_chan->is_call_waiting;
1399 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
1400
1401 #if defined(HAVE_PRI_AOC_EVENTS)
1402                 old_chan->aoc_s_request_invoke_id_valid = 0;
1403                 old_chan->waiting_for_aoce = 0;
1404                 old_chan->holding_aoce = 0;
1405 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
1406                 old_chan->alreadyhungup = 0;
1407                 old_chan->isidlecall = 0;
1408                 old_chan->progress = 0;
1409                 old_chan->allocated = 0;
1410                 old_chan->outgoing = 0;
1411                 old_chan->digital = 0;
1412 #if defined(HAVE_PRI_CALL_WAITING)
1413                 old_chan->is_call_waiting = 0;
1414 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
1415
1416                 /* More stuff to transfer to the new channel. */
1417                 new_chan->call_level = old_chan->call_level;
1418                 old_chan->call_level = SIG_PRI_CALL_LEVEL_IDLE;
1419 #if defined(HAVE_PRI_REVERSE_CHARGE)
1420                 new_chan->reverse_charging_indication = old_chan->reverse_charging_indication;
1421 #endif  /* defined(HAVE_PRI_REVERSE_CHARGE) */
1422 #if defined(HAVE_PRI_SETUP_KEYPAD)
1423                 strcpy(new_chan->keypad_digits, old_chan->keypad_digits);
1424 #endif  /* defined(HAVE_PRI_SETUP_KEYPAD) */
1425                 strcpy(new_chan->moh_suggested, old_chan->moh_suggested);
1426                 new_chan->moh_state = old_chan->moh_state;
1427                 old_chan->moh_state = SIG_PRI_MOH_STATE_IDLE;
1428
1429 #if defined(HAVE_PRI_AOC_EVENTS)
1430                 new_chan->aoc_s_request_invoke_id = old_chan->aoc_s_request_invoke_id;
1431                 new_chan->aoc_e = old_chan->aoc_e;
1432 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
1433                 strcpy(new_chan->user_tag, old_chan->user_tag);
1434
1435                 if (new_chan->no_b_channel) {
1436                         /* Copy the real channel configuration to the no B channel interface. */
1437                         new_chan->hidecallerid = old_chan->hidecallerid;
1438                         new_chan->hidecalleridname = old_chan->hidecalleridname;
1439                         new_chan->immediate = old_chan->immediate;
1440                         new_chan->priexclusive = old_chan->priexclusive;
1441                         new_chan->priindication_oob = old_chan->priindication_oob;
1442                         new_chan->use_callerid = old_chan->use_callerid;
1443                         new_chan->use_callingpres = old_chan->use_callingpres;
1444                         new_chan->stripmsd = old_chan->stripmsd;
1445                         strcpy(new_chan->context, old_chan->context);
1446                         strcpy(new_chan->mohinterpret, old_chan->mohinterpret);
1447
1448                         /* Become a member of the old channel span/trunk-group. */
1449                         new_chan->logicalspan = old_chan->logicalspan;
1450                         new_chan->mastertrunkgroup = old_chan->mastertrunkgroup;
1451                 } else if (old_chan->no_b_channel) {
1452                         /*
1453                          * We are transitioning from a held/call-waiting channel to a
1454                          * real channel so we need to make sure that the media path is
1455                          * open.  (Needed especially if the channel is natively
1456                          * bridged.)
1457                          */
1458                         sig_pri_open_media(new_chan);
1459                 }
1460
1461                 if (new_chan->owner) {
1462                         sig_pri_ami_channel_event(new_chan);
1463                 }
1464
1465                 sig_pri_unlock_private(old_chan);
1466                 if (new_chan->owner) {
1467                         ast_channel_unlock(new_chan->owner);
1468                 }
1469                 sig_pri_unlock_private(new_chan);
1470
1471                 return principle;
1472         }
1473         ast_verb(3, "Call specified, but not found.\n");
1474         return -1;
1475 }
1476
1477 /*!
1478  * \internal
1479  * \brief Find and fixup the private structure associated with the libpri call.
1480  *
1481  * \param pri PRI span control structure.
1482  * \param channel LibPRI encoded channel ID.
1483  * \param call LibPRI opaque call pointer.
1484  *
1485  * \details
1486  * This is a combination of pri_find_principle() and pri_fixup_principle()
1487  * to reduce code redundancy and to make handling several PRI_EVENT_xxx's
1488  * consistent for the current architecture.
1489  *
1490  * \note Assumes the pri->lock is already obtained.
1491  *
1492  * \retval array-index into private pointer array on success.
1493  * \retval -1 on error.
1494  */
1495 static int pri_find_fixup_principle(struct sig_pri_span *pri, int channel, q931_call *call)
1496 {
1497         int chanpos;
1498
1499         chanpos = pri_find_principle(pri, channel, call);
1500         if (chanpos < 0) {
1501                 ast_log(LOG_WARNING, "Span %d: PRI requested channel %d/%d is unconfigured.\n",
1502                         pri->span, PRI_SPAN(channel), PRI_CHANNEL(channel));
1503                 sig_pri_kill_call(pri, call, PRI_CAUSE_IDENTIFIED_CHANNEL_NOTEXIST);
1504                 return -1;
1505         }
1506         chanpos = pri_fixup_principle(pri, chanpos, call);
1507         if (chanpos < 0) {
1508                 ast_log(LOG_WARNING, "Span %d: PRI requested channel %d/%d is not available.\n",
1509                         pri->span, PRI_SPAN(channel), PRI_CHANNEL(channel));
1510                 /*
1511                  * Using Q.931 section 5.2.3.1 b) as the reason for picking
1512                  * PRI_CAUSE_CHANNEL_UNACCEPTABLE.  Receiving a
1513                  * PRI_CAUSE_REQUESTED_CHAN_UNAVAIL would cause us to restart
1514                  * that channel (which is not specified by Q.931) and kill some
1515                  * other call which would be bad.
1516                  */
1517                 sig_pri_kill_call(pri, call, PRI_CAUSE_CHANNEL_UNACCEPTABLE);
1518                 return -1;
1519         }
1520         return chanpos;
1521 }
1522
1523 static char * redirectingreason2str(int redirectingreason)
1524 {
1525         switch (redirectingreason) {
1526         case 0:
1527                 return "UNKNOWN";
1528         case 1:
1529                 return "BUSY";
1530         case 2:
1531                 return "NO_REPLY";
1532         case 0xF:
1533                 return "UNCONDITIONAL";
1534         default:
1535                 return "NOREDIRECT";
1536         }
1537 }
1538
1539 static char *dialplan2str(int dialplan)
1540 {
1541         if (dialplan == -1) {
1542                 return("Dynamically set dialplan in ISDN");
1543         }
1544         return (pri_plan2str(dialplan));
1545 }
1546
1547 static void apply_plan_to_number(char *buf, size_t size, const struct sig_pri_span *pri, const char *number, const int plan)
1548 {
1549         switch (plan) {
1550         case PRI_INTERNATIONAL_ISDN:            /* Q.931 dialplan == 0x11 international dialplan => prepend international prefix digits */
1551                 snprintf(buf, size, "%s%s", pri->internationalprefix, number);
1552                 break;
1553         case PRI_NATIONAL_ISDN:                 /* Q.931 dialplan == 0x21 national dialplan => prepend national prefix digits */
1554                 snprintf(buf, size, "%s%s", pri->nationalprefix, number);
1555                 break;
1556         case PRI_LOCAL_ISDN:                    /* Q.931 dialplan == 0x41 local dialplan => prepend local prefix digits */
1557                 snprintf(buf, size, "%s%s", pri->localprefix, number);
1558                 break;
1559         case PRI_PRIVATE:                       /* Q.931 dialplan == 0x49 private dialplan => prepend private prefix digits */
1560                 snprintf(buf, size, "%s%s", pri->privateprefix, number);
1561                 break;
1562         case PRI_UNKNOWN:                       /* Q.931 dialplan == 0x00 unknown dialplan => prepend unknown prefix digits */
1563                 snprintf(buf, size, "%s%s", pri->unknownprefix, number);
1564                 break;
1565         default:                                /* other Q.931 dialplan => don't twiddle with callingnum */
1566                 snprintf(buf, size, "%s", number);
1567                 break;
1568         }
1569 }
1570
1571 /*!
1572  * \internal
1573  * \brief Restart the next channel we think is idle on the span.
1574  *
1575  * \param pri PRI span control structure.
1576  *
1577  * \note Assumes the pri->lock is already obtained.
1578  *
1579  * \return Nothing
1580  */
1581 static void pri_check_restart(struct sig_pri_span *pri)
1582 {
1583 #if defined(HAVE_PRI_SERVICE_MESSAGES)
1584         unsigned why;
1585 #endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
1586
1587         for (++pri->resetpos; pri->resetpos < pri->numchans; ++pri->resetpos) {
1588                 if (!pri->pvts[pri->resetpos]
1589                         || pri->pvts[pri->resetpos]->no_b_channel
1590                         || sig_pri_is_chan_in_use(pri->pvts[pri->resetpos])) {
1591                         continue;
1592                 }
1593 #if defined(HAVE_PRI_SERVICE_MESSAGES)
1594                 why = pri->pvts[pri->resetpos]->service_status;
1595                 if (why) {
1596                         ast_log(LOG_NOTICE,
1597                                 "Span %d: channel %d out-of-service (reason: %s), not sending RESTART\n",
1598                                 pri->span, pri->pvts[pri->resetpos]->channel,
1599                                 (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end");
1600                         continue;
1601                 }
1602 #endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
1603                 break;
1604         }
1605         if (pri->resetpos < pri->numchans) {
1606                 /* Mark the channel as resetting and restart it */
1607                 pri->pvts[pri->resetpos]->resetting = 1;
1608                 pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[pri->resetpos]));
1609         } else {
1610                 pri->resetting = 0;
1611                 time(&pri->lastreset);
1612                 sig_pri_span_devstate_changed(pri);
1613         }
1614 }
1615
1616 #if defined(HAVE_PRI_CALL_WAITING)
1617 /*!
1618  * \internal
1619  * \brief Init the private channel configuration using the span controller.
1620  * \since 1.8
1621  *
1622  * \param pvt Channel to init the configuration.
1623  * \param pri PRI span control structure.
1624  *
1625  * \note Assumes the pri->lock is already obtained.
1626  *
1627  * \return Nothing
1628  */
1629 static void sig_pri_init_config(struct sig_pri_chan *pvt, struct sig_pri_span *pri)
1630 {
1631         pvt->stripmsd = pri->ch_cfg.stripmsd;
1632         pvt->hidecallerid = pri->ch_cfg.hidecallerid;
1633         pvt->hidecalleridname = pri->ch_cfg.hidecalleridname;
1634         pvt->immediate = pri->ch_cfg.immediate;
1635         pvt->priexclusive = pri->ch_cfg.priexclusive;
1636         pvt->priindication_oob = pri->ch_cfg.priindication_oob;
1637         pvt->use_callerid = pri->ch_cfg.use_callerid;
1638         pvt->use_callingpres = pri->ch_cfg.use_callingpres;
1639         ast_copy_string(pvt->context, pri->ch_cfg.context, sizeof(pvt->context));
1640         ast_copy_string(pvt->mohinterpret, pri->ch_cfg.mohinterpret, sizeof(pvt->mohinterpret));
1641
1642         if (pri->calls->init_config) {
1643                 pri->calls->init_config(pvt->chan_pvt, pri);
1644         }
1645 }
1646 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
1647
1648 /*!
1649  * \internal
1650  * \brief Find an empty B-channel interface to use.
1651  *
1652  * \param pri PRI span control structure.
1653  * \param backwards TRUE if the search starts from higher channels.
1654  *
1655  * \note Assumes the pri->lock is already obtained.
1656  *
1657  * \retval array-index into private pointer array on success.
1658  * \retval -1 on error.
1659  */
1660 static int pri_find_empty_chan(struct sig_pri_span *pri, int backwards)
1661 {
1662         int x;
1663         if (backwards)
1664                 x = pri->numchans;
1665         else
1666                 x = 0;
1667         for (;;) {
1668                 if (backwards && (x < 0))
1669                         break;
1670                 if (!backwards && (x >= pri->numchans))
1671                         break;
1672                 if (pri->pvts[x]
1673                         && !pri->pvts[x]->no_b_channel
1674                         && sig_pri_is_chan_available(pri->pvts[x])) {
1675                         ast_debug(1, "Found empty available channel %d/%d\n",
1676                                 pri->pvts[x]->logicalspan, pri->pvts[x]->prioffset);
1677                         return x;
1678                 }
1679                 if (backwards)
1680                         x--;
1681                 else
1682                         x++;
1683         }
1684         return -1;
1685 }
1686
1687 #if defined(HAVE_PRI_CALL_HOLD)
1688 /*!
1689  * \internal
1690  * \brief Find or create an empty no-B-channel interface to use.
1691  * \since 1.8
1692  *
1693  * \param pri PRI span control structure.
1694  *
1695  * \note Assumes the pri->lock is already obtained.
1696  *
1697  * \retval array-index into private pointer array on success.
1698  * \retval -1 on error.
1699  */
1700 static int pri_find_empty_nobch(struct sig_pri_span *pri)
1701 {
1702         int idx;
1703
1704         for (idx = 0; idx < pri->numchans; ++idx) {
1705                 if (pri->pvts[idx]
1706                         && pri->pvts[idx]->no_b_channel
1707                         && sig_pri_is_chan_available(pri->pvts[idx])) {
1708                         ast_debug(1, "Found empty available no B channel interface\n");
1709                         return idx;
1710                 }
1711         }
1712
1713         /* Need to create a new interface. */
1714         if (pri->calls->new_nobch_intf) {
1715                 idx = pri->calls->new_nobch_intf(pri);
1716         } else {
1717                 idx = -1;
1718         }
1719         return idx;
1720 }
1721 #endif  /* defined(HAVE_PRI_CALL_HOLD) */
1722
1723 static void *do_idle_thread(void *v_pvt)
1724 {
1725         struct sig_pri_chan *pvt = v_pvt;
1726         struct ast_channel *chan = pvt->owner;
1727         struct ast_frame *f;
1728         char ex[80];
1729         /* Wait up to 30 seconds for an answer */
1730         int newms, ms = 30000;
1731
1732         ast_verb(3, "Initiating idle call on channel %s\n", chan->name);
1733         snprintf(ex, sizeof(ex), "%d/%s", pvt->channel, pvt->pri->idledial);
1734         if (ast_call(chan, ex, 0)) {
1735                 ast_log(LOG_WARNING, "Idle dial failed on '%s' to '%s'\n", chan->name, ex);
1736                 ast_hangup(chan);
1737                 return NULL;
1738         }
1739         while ((newms = ast_waitfor(chan, ms)) > 0) {
1740                 f = ast_read(chan);
1741                 if (!f) {
1742                         /* Got hangup */
1743                         break;
1744                 }
1745                 if (f->frametype == AST_FRAME_CONTROL) {
1746                         switch (f->subclass.integer) {
1747                         case AST_CONTROL_ANSWER:
1748                                 /* Launch the PBX */
1749                                 ast_copy_string(chan->exten, pvt->pri->idleext, sizeof(chan->exten));
1750                                 ast_copy_string(chan->context, pvt->pri->idlecontext, sizeof(chan->context));
1751                                 chan->priority = 1;
1752                                 ast_verb(4, "Idle channel '%s' answered, sending to %s@%s\n", chan->name, chan->exten, chan->context);
1753                                 ast_pbx_run(chan);
1754                                 /* It's already hungup, return immediately */
1755                                 return NULL;
1756                         case AST_CONTROL_BUSY:
1757                                 ast_verb(4, "Idle channel '%s' busy, waiting...\n", chan->name);
1758                                 break;
1759                         case AST_CONTROL_CONGESTION:
1760                                 ast_verb(4, "Idle channel '%s' congested, waiting...\n", chan->name);
1761                                 break;
1762                         };
1763                 }
1764                 ast_frfree(f);
1765                 ms = newms;
1766         }
1767         /* Hangup the channel since nothing happend */
1768         ast_hangup(chan);
1769         return NULL;
1770 }
1771
1772 static void *pri_ss_thread(void *data)
1773 {
1774         struct sig_pri_chan *p = data;
1775         struct ast_channel *chan = p->owner;
1776         char exten[AST_MAX_EXTENSION];
1777         int res;
1778         int len;
1779         int timeout;
1780
1781         if (!chan) {
1782                 /* We lost the owner before we could get started. */
1783                 return NULL;
1784         }
1785
1786         /*
1787          * In the bizarre case where the channel has become a zombie before we
1788          * even get started here, abort safely.
1789          */
1790         if (!chan->tech_pvt) {
1791                 ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", chan->name);
1792                 ast_hangup(chan);
1793                 return NULL;
1794         }
1795
1796         ast_verb(3, "Starting simple switch on '%s'\n", chan->name);
1797
1798         sig_pri_dsp_reset_and_flush_digits(p);
1799
1800         /* Now loop looking for an extension */
1801         ast_copy_string(exten, p->exten, sizeof(exten));
1802         len = strlen(exten);
1803         res = 0;
1804         while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
1805                 if (len && !ast_ignore_pattern(chan->context, exten))
1806                         sig_pri_play_tone(p, -1);
1807                 else
1808                         sig_pri_play_tone(p, SIG_PRI_TONE_DIALTONE);
1809                 if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num))
1810                         timeout = pri_matchdigittimeout;
1811                 else
1812                         timeout = pri_gendigittimeout;
1813                 res = ast_waitfordigit(chan, timeout);
1814                 if (res < 0) {
1815                         ast_debug(1, "waitfordigit returned < 0...\n");
1816                         ast_hangup(chan);
1817                         return NULL;
1818                 } else if (res) {
1819                         exten[len++] = res;
1820                         exten[len] = '\0';
1821                 } else
1822                         break;
1823         }
1824         /* if no extension was received ('unspecified') on overlap call, use the 's' extension */
1825         if (ast_strlen_zero(exten)) {
1826                 ast_verb(3, "Going to extension s|1 because of empty extension received on overlap call\n");
1827                 exten[0] = 's';
1828                 exten[1] = '\0';
1829         } else {
1830                 ast_free(chan->dialed.number.str);
1831                 chan->dialed.number.str = ast_strdup(exten);
1832
1833                 if (p->pri->append_msn_to_user_tag && p->pri->nodetype != PRI_NETWORK) {
1834                         /*
1835                          * Update the user tag for party id's from this device for this call
1836                          * now that we have a complete MSN from the network.
1837                          */
1838                         snprintf(p->user_tag, sizeof(p->user_tag), "%s_%s", p->pri->initial_user_tag,
1839                                 exten);
1840                         ast_free(chan->caller.id.tag);
1841                         chan->caller.id.tag = ast_strdup(p->user_tag);
1842                 }
1843         }
1844         sig_pri_play_tone(p, -1);
1845         if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) {
1846                 /* Start the real PBX */
1847                 ast_copy_string(chan->exten, exten, sizeof(chan->exten));
1848                 sig_pri_dsp_reset_and_flush_digits(p);
1849 #if defined(ISSUE_16789)
1850                 /*
1851                  * Conditionaled out this code to effectively revert the Mantis
1852                  * issue 16789 change.  It breaks overlap dialing through
1853                  * Asterisk.  There is not enough information available at this
1854                  * point to know if dialing is complete.  The
1855                  * ast_exists_extension(), ast_matchmore_extension(), and
1856                  * ast_canmatch_extension() calls are not adequate to detect a
1857                  * dial through extension pattern of "_9!".
1858                  *
1859                  * Workaround is to use the dialplan Proceeding() application
1860                  * early on non-dial through extensions.
1861                  */
1862                 if ((p->pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)
1863                         && !ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
1864                         sig_pri_lock_private(p);
1865                         if (p->pri->pri) {
1866                                 if (!pri_grab(p, p->pri)) {
1867                                         if (p->call_level < SIG_PRI_CALL_LEVEL_PROCEEDING) {
1868                                                 p->call_level = SIG_PRI_CALL_LEVEL_PROCEEDING;
1869                                         }
1870                                         pri_proceeding(p->pri->pri, p->call, PVT_TO_CHANNEL(p), 0);
1871                                         pri_rel(p->pri);
1872                                 } else {
1873                                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
1874                                 }
1875                         }
1876                         sig_pri_unlock_private(p);
1877                 }
1878 #endif  /* defined(ISSUE_16789) */
1879
1880                 sig_pri_set_echocanceller(p, 1);
1881                 ast_setstate(chan, AST_STATE_RING);
1882                 res = ast_pbx_run(chan);
1883                 if (res) {
1884                         ast_log(LOG_WARNING, "PBX exited non-zero!\n");
1885                 }
1886         } else {
1887                 ast_debug(1, "No such possible extension '%s' in context '%s'\n", exten, chan->context);
1888                 chan->hangupcause = AST_CAUSE_UNALLOCATED;
1889                 ast_hangup(chan);
1890                 p->exten[0] = '\0';
1891                 /* Since we send release complete here, we won't get one */
1892                 p->call = NULL;
1893                 ast_mutex_lock(&p->pri->lock);
1894                 sig_pri_span_devstate_changed(p->pri);
1895                 ast_mutex_unlock(&p->pri->lock);
1896         }
1897         return NULL;
1898 }
1899
1900 void pri_event_alarm(struct sig_pri_span *pri, int index, int before_start_pri)
1901 {
1902         pri->dchanavail[index] &= ~(DCHAN_NOTINALARM | DCHAN_UP);
1903         if (!before_start_pri)
1904                 pri_find_dchan(pri);
1905 }
1906
1907 void pri_event_noalarm(struct sig_pri_span *pri, int index, int before_start_pri)
1908 {
1909         pri->dchanavail[index] |= DCHAN_NOTINALARM;
1910         if (!before_start_pri)
1911                 pri_restart(pri->dchans[index]);
1912 }
1913
1914 /*!
1915  * \internal
1916  * \brief Convert libpri party name into asterisk party name.
1917  * \since 1.8
1918  *
1919  * \param ast_name Asterisk party name structure to fill.  Must already be set initialized.
1920  * \param pri_name libpri party name structure containing source information.
1921  *
1922  * \note The filled in ast_name structure needs to be destroyed by
1923  * ast_party_name_free() when it is no longer needed.
1924  *
1925  * \return Nothing
1926  */
1927 static void sig_pri_party_name_convert(struct ast_party_name *ast_name, const struct pri_party_name *pri_name)
1928 {
1929         ast_name->str = ast_strdup(pri_name->str);
1930         ast_name->char_set = pri_to_ast_char_set(pri_name->char_set);
1931         ast_name->presentation = pri_to_ast_presentation(pri_name->presentation);
1932         ast_name->valid = 1;
1933 }
1934
1935 /*!
1936  * \internal
1937  * \brief Convert libpri party number into asterisk party number.
1938  * \since 1.8
1939  *
1940  * \param ast_number Asterisk party number structure to fill.  Must already be set initialized.
1941  * \param pri_number libpri party number structure containing source information.
1942  * \param pri PRI span control structure.
1943  *
1944  * \note The filled in ast_number structure needs to be destroyed by
1945  * ast_party_number_free() when it is no longer needed.
1946  *
1947  * \return Nothing
1948  */
1949 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)
1950 {
1951         char number[AST_MAX_EXTENSION];
1952
1953         apply_plan_to_number(number, sizeof(number), pri, pri_number->str, pri_number->plan);
1954         ast_number->str = ast_strdup(number);
1955         ast_number->plan = pri_number->plan;
1956         ast_number->presentation = pri_to_ast_presentation(pri_number->presentation);
1957         ast_number->valid = 1;
1958 }
1959
1960 /*!
1961  * \internal
1962  * \brief Convert libpri party id into asterisk party id.
1963  * \since 1.8
1964  *
1965  * \param ast_id Asterisk party id structure to fill.  Must already be set initialized.
1966  * \param pri_id libpri party id structure containing source information.
1967  * \param pri PRI span control structure.
1968  *
1969  * \note The filled in ast_id structure needs to be destroyed by
1970  * ast_party_id_free() when it is no longer needed.
1971  *
1972  * \return Nothing
1973  */
1974 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)
1975 {
1976         if (pri_id->name.valid) {
1977                 sig_pri_party_name_convert(&ast_id->name, &pri_id->name);
1978         }
1979         if (pri_id->number.valid) {
1980                 sig_pri_party_number_convert(&ast_id->number, &pri_id->number, pri);
1981         }
1982 #if defined(HAVE_PRI_SUBADDR)
1983         if (pri_id->subaddress.valid) {
1984                 sig_pri_set_subaddress(&ast_id->subaddress, &pri_id->subaddress);
1985         }
1986 #endif  /* defined(HAVE_PRI_SUBADDR) */
1987 }
1988
1989 /*!
1990  * \internal
1991  * \brief Convert libpri redirecting information into asterisk redirecting information.
1992  * \since 1.8
1993  *
1994  * \param ast_redirecting Asterisk redirecting structure to fill.
1995  * \param pri_redirecting libpri redirecting structure containing source information.
1996  * \param ast_guide Asterisk redirecting structure to use as an initialization guide.
1997  * \param pri PRI span control structure.
1998  *
1999  * \note The filled in ast_redirecting structure needs to be destroyed by
2000  * ast_party_redirecting_free() when it is no longer needed.
2001  *
2002  * \return Nothing
2003  */
2004 static void sig_pri_redirecting_convert(struct ast_party_redirecting *ast_redirecting,
2005         const struct pri_party_redirecting *pri_redirecting,
2006         const struct ast_party_redirecting *ast_guide,
2007         struct sig_pri_span *pri)
2008 {
2009         ast_party_redirecting_set_init(ast_redirecting, ast_guide);
2010
2011         sig_pri_party_id_convert(&ast_redirecting->from, &pri_redirecting->from, pri);
2012         sig_pri_party_id_convert(&ast_redirecting->to, &pri_redirecting->to, pri);
2013         ast_redirecting->count = pri_redirecting->count;
2014         ast_redirecting->reason = pri_to_ast_reason(pri_redirecting->reason);
2015 }
2016
2017 /*!
2018  * \internal
2019  * \brief Determine if the given extension matches one of the MSNs in the pattern list.
2020  * \since 1.8
2021  *
2022  * \param msn_patterns Comma separated list of MSN patterns to match.
2023  * \param exten Extension to match in the MSN list.
2024  *
2025  * \retval 1 if matches.
2026  * \retval 0 if no match.
2027  */
2028 static int sig_pri_msn_match(const char *msn_patterns, const char *exten)
2029 {
2030         char *pattern;
2031         char *msn_list;
2032         char *list_tail;
2033
2034         msn_list = ast_strdupa(msn_patterns);
2035
2036         list_tail = NULL;
2037         pattern = strtok_r(msn_list, ",", &list_tail);
2038         while (pattern) {
2039                 pattern = ast_strip(pattern);
2040                 if (!ast_strlen_zero(pattern) && ast_extension_match(pattern, exten)) {
2041                         /* Extension matched the pattern. */
2042                         return 1;
2043                 }
2044                 pattern = strtok_r(NULL, ",", &list_tail);
2045         }
2046         /* Did not match any pattern in the list. */
2047         return 0;
2048 }
2049
2050 #if defined(HAVE_PRI_MCID)
2051 /*!
2052  * \internal
2053  * \brief Append the given party id to the event string.
2054  * \since 1.8
2055  *
2056  * \param msg Event message string being built.
2057  * \param prefix Prefix to add to the party id lines.
2058  * \param party Party information to encode.
2059  *
2060  * \return Nothing
2061  */
2062 static void sig_pri_event_party_id(struct ast_str **msg, const char *prefix, struct ast_party_id *party)
2063 {
2064         int pres;
2065
2066         /* Combined party presentation */
2067         pres = ast_party_id_presentation(party);
2068         ast_str_append(msg, 0, "%sPres: %d (%s)\r\n", prefix, pres,
2069                 ast_describe_caller_presentation(pres));
2070
2071         /* Party number */
2072         ast_str_append(msg, 0, "%sNumValid: %d\r\n", prefix,
2073                 (unsigned) party->number.valid);
2074         ast_str_append(msg, 0, "%sNum: %s\r\n", prefix,
2075                 S_COR(party->number.valid, party->number.str, ""));
2076         ast_str_append(msg, 0, "%ston: %d\r\n", prefix, party->number.plan);
2077         if (party->number.valid) {
2078                 ast_str_append(msg, 0, "%sNumPlan: %d\r\n", prefix, party->number.plan);
2079                 ast_str_append(msg, 0, "%sNumPres: %d (%s)\r\n", prefix,
2080                         party->number.presentation,
2081                         ast_describe_caller_presentation(party->number.presentation));
2082         }
2083
2084         /* Party name */
2085         ast_str_append(msg, 0, "%sNameValid: %d\r\n", prefix,
2086                 (unsigned) party->name.valid);
2087         ast_str_append(msg, 0, "%sName: %s\r\n", prefix,
2088                 S_COR(party->name.valid, party->name.str, ""));
2089         if (party->name.valid) {
2090                 ast_str_append(msg, 0, "%sNameCharSet: %s\r\n", prefix,
2091                         ast_party_name_charset_describe(party->name.char_set));
2092                 ast_str_append(msg, 0, "%sNamePres: %d (%s)\r\n", prefix,
2093                         party->name.presentation,
2094                         ast_describe_caller_presentation(party->name.presentation));
2095         }
2096
2097 #if defined(HAVE_PRI_SUBADDR)
2098         /* Party subaddress */
2099         if (party->subaddress.valid) {
2100                 static const char subaddress[] = "Subaddr";
2101
2102                 ast_str_append(msg, 0, "%s%s: %s\r\n", prefix, subaddress,
2103                         S_OR(party->subaddress.str, ""));
2104                 ast_str_append(msg, 0, "%s%sType: %d\r\n", prefix, subaddress,
2105                         party->subaddress.type);
2106                 ast_str_append(msg, 0, "%s%sOdd: %d\r\n", prefix, subaddress,
2107                         party->subaddress.odd_even_indicator);
2108         }
2109 #endif  /* defined(HAVE_PRI_SUBADDR) */
2110 }
2111 #endif  /* defined(HAVE_PRI_MCID) */
2112
2113 #if defined(HAVE_PRI_MCID)
2114 /*!
2115  * \internal
2116  * \brief Handle the MCID event.
2117  * \since 1.8
2118  *
2119  * \param pri PRI span control structure.
2120  * \param mcid MCID event parameters.
2121  * \param owner Asterisk channel associated with the call.
2122  * NULL if Asterisk no longer has the ast_channel struct.
2123  *
2124  * \note Assumes the pri->lock is already obtained.
2125  * \note Assumes the owner channel lock is already obtained if still present.
2126  *
2127  * \return Nothing
2128  */
2129 static void sig_pri_mcid_event(struct sig_pri_span *pri, const struct pri_subcmd_mcid_req *mcid, struct ast_channel *owner)
2130 {
2131         struct ast_channel *chans[1];
2132         struct ast_str *msg;
2133         struct ast_party_id party;
2134
2135         msg = ast_str_create(4096);
2136         if (!msg) {
2137                 return;
2138         }
2139
2140         if (owner) {
2141                 /*
2142                  * The owner channel is present.
2143                  * Pass the event to the peer as well.
2144                  */
2145                 ast_queue_control(owner, AST_CONTROL_MCID);
2146
2147                 ast_str_append(&msg, 0, "Channel: %s\r\n", owner->name);
2148                 ast_str_append(&msg, 0, "UniqueID: %s\r\n", owner->uniqueid);
2149
2150                 sig_pri_event_party_id(&msg, "CallerID", &owner->connected.id);
2151         } else {
2152                 /*
2153                  * Since we no longer have an owner channel,
2154                  * we have to use the caller information supplied by libpri.
2155                  */
2156                 ast_party_id_init(&party);
2157                 sig_pri_party_id_convert(&party, &mcid->originator, pri);
2158                 sig_pri_event_party_id(&msg, "CallerID", &party);
2159                 ast_party_id_free(&party);
2160         }
2161
2162         /* Always use libpri's called party information. */
2163         ast_party_id_init(&party);
2164         sig_pri_party_id_convert(&party, &mcid->answerer, pri);
2165         sig_pri_event_party_id(&msg, "ConnectedID", &party);
2166         ast_party_id_free(&party);
2167
2168         chans[0] = owner;
2169         ast_manager_event_multichan(EVENT_FLAG_CALL, "MCID", owner ? 1 : 0, chans, "%s",
2170                 ast_str_buffer(msg));
2171         ast_free(msg);
2172 }
2173 #endif  /* defined(HAVE_PRI_MCID) */
2174
2175 #if defined(HAVE_PRI_TRANSFER)
2176 struct xfer_rsp_data {
2177         struct sig_pri_span *pri;
2178         /*! Call to send transfer success/fail response over. */
2179         q931_call *call;
2180         /*! Invocation ID to use when sending a reply to the transfer request. */
2181         int invoke_id;
2182 };
2183 #endif  /* defined(HAVE_PRI_TRANSFER) */
2184
2185 #if defined(HAVE_PRI_TRANSFER)
2186 /*!
2187  * \internal
2188  * \brief Send the transfer success/fail response message.
2189  * \since 1.8
2190  *
2191  * \param data Callback user data pointer
2192  * \param is_successful TRUE if the transfer was successful.
2193  *
2194  * \return Nothing
2195  */
2196 static void sig_pri_transfer_rsp(void *data, int is_successful)
2197 {
2198         struct xfer_rsp_data *rsp = data;
2199
2200         pri_transfer_rsp(rsp->pri->pri, rsp->call, rsp->invoke_id, is_successful);
2201 }
2202 #endif  /* defined(HAVE_PRI_TRANSFER) */
2203
2204 #if defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
2205 /*!
2206  * \brief Protocol callback to indicate if transfer will happen.
2207  * \since 1.8
2208  *
2209  * \param data Callback user data pointer
2210  * \param is_successful TRUE if the transfer will happen.
2211  *
2212  * \return Nothing
2213  */
2214 typedef void (*xfer_rsp_callback)(void *data, int is_successful);
2215 #endif  /* defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER) */
2216
2217 #if defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
2218 /*!
2219  * \internal
2220  * \brief Attempt to transfer the two calls to each other.
2221  * \since 1.8
2222  *
2223  * \param pri PRI span control structure.
2224  * \param call_1_pri First call involved in the transfer. (transferee; usually on hold)
2225  * \param call_1_held TRUE if call_1_pri is on hold.
2226  * \param call_2_pri Second call involved in the transfer. (target; usually active/ringing)
2227  * \param call_2_held TRUE if call_2_pri is on hold.
2228  * \param rsp_callback Protocol callback to indicate if transfer will happen. NULL if not used.
2229  * \param data Callback user data pointer
2230  *
2231  * \note Assumes the pri->lock is already obtained.
2232  *
2233  * \retval 0 on success.
2234  * \retval -1 on error.
2235  */
2236 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)
2237 {
2238         struct attempt_xfer_call {
2239                 q931_call *pri;
2240                 struct ast_channel *ast;
2241                 int held;
2242                 int chanpos;
2243         };
2244         int retval;
2245         struct ast_channel *transferee;
2246         struct attempt_xfer_call *call_1;
2247         struct attempt_xfer_call *call_2;
2248         struct attempt_xfer_call *swap_call;
2249         struct attempt_xfer_call c1;
2250         struct attempt_xfer_call c2;
2251
2252         c1.pri = call_1_pri;
2253         c1.held = call_1_held;
2254         call_1 = &c1;
2255
2256         c2.pri = call_2_pri;
2257         c2.held = call_2_held;
2258         call_2 = &c2;
2259
2260         call_1->chanpos = pri_find_principle_by_call(pri, call_1->pri);
2261         call_2->chanpos = pri_find_principle_by_call(pri, call_2->pri);
2262         if (call_1->chanpos < 0 || call_2->chanpos < 0) {
2263                 /* Calls not found in span control. */
2264                 if (rsp_callback) {
2265                         /* Transfer failed. */
2266                         rsp_callback(data, 0);
2267                 }
2268                 return -1;
2269         }
2270
2271         /* Attempt to make transferee and target consistent. */
2272         if (!call_1->held && call_2->held) {
2273                 /*
2274                  * Swap call_1 and call_2 to make call_1 the transferee(held call)
2275                  * and call_2 the target(active call).
2276                  */
2277                 swap_call = call_1;
2278                 call_1 = call_2;
2279                 call_2 = swap_call;
2280         }
2281
2282         /* Deadlock avoidance is attempted. */
2283         sig_pri_lock_private(pri->pvts[call_1->chanpos]);
2284         sig_pri_lock_owner(pri, call_1->chanpos);
2285         sig_pri_lock_private(pri->pvts[call_2->chanpos]);
2286         sig_pri_lock_owner(pri, call_2->chanpos);
2287
2288         call_1->ast = pri->pvts[call_1->chanpos]->owner;
2289         call_2->ast = pri->pvts[call_2->chanpos]->owner;
2290         if (!call_1->ast || !call_2->ast) {
2291                 /* At least one owner is not present. */
2292                 if (call_1->ast) {
2293                         ast_channel_unlock(call_1->ast);
2294                 }
2295                 if (call_2->ast) {
2296                         ast_channel_unlock(call_2->ast);
2297                 }
2298                 sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2299                 sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2300                 if (rsp_callback) {
2301                         /* Transfer failed. */
2302                         rsp_callback(data, 0);
2303                 }
2304                 return -1;
2305         }
2306
2307         for (;;) {
2308                 transferee = ast_bridged_channel(call_1->ast);
2309                 if (transferee) {
2310                         break;
2311                 }
2312
2313                 /* Try masquerading the other way. */
2314                 swap_call = call_1;
2315                 call_1 = call_2;
2316                 call_2 = swap_call;
2317
2318                 transferee = ast_bridged_channel(call_1->ast);
2319                 if (transferee) {
2320                         break;
2321                 }
2322
2323                 /* Could not transfer.  Neither call is bridged. */
2324                 ast_channel_unlock(call_1->ast);
2325                 ast_channel_unlock(call_2->ast);
2326                 sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2327                 sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2328
2329                 if (rsp_callback) {
2330                         /* Transfer failed. */
2331                         rsp_callback(data, 0);
2332                 }
2333                 return -1;
2334         }
2335
2336         ast_verb(3, "TRANSFERRING %s to %s\n", call_1->ast->name, call_2->ast->name);
2337
2338         /*
2339          * Setup transfer masquerade.
2340          *
2341          * Note:  There is an extremely nasty deadlock avoidance issue
2342          * with ast_channel_transfer_masquerade().  Deadlock may be possible if
2343          * the channels involved are proxies (chan_agent channels) and
2344          * it is called with locks.  Unfortunately, there is no simple
2345          * or even merely difficult way to guarantee deadlock avoidance
2346          * and still be able to send an ECT success response without the
2347          * possibility of the bridged channel hanging up on us.
2348          */
2349         ast_mutex_unlock(&pri->lock);
2350         retval = ast_channel_transfer_masquerade(
2351                 call_2->ast,
2352                 &call_2->ast->connected,
2353                 call_2->held,
2354                 transferee,
2355                 &call_1->ast->connected,
2356                 call_1->held);
2357
2358         /* Reacquire the pri->lock to hold off completion of the transfer masquerade. */
2359         ast_mutex_lock(&pri->lock);
2360
2361         ast_channel_unlock(call_1->ast);
2362         ast_channel_unlock(call_2->ast);
2363         sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
2364         sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
2365
2366         if (rsp_callback) {
2367                 /*
2368                  * Report transfer status.
2369                  *
2370                  * Must do the callback before the masquerade completes to ensure
2371                  * that the protocol message goes out before the call leg is
2372                  * disconnected.
2373                  */
2374                 rsp_callback(data, retval ? 0 : 1);
2375         }
2376         return retval;
2377 }
2378 #endif  /* defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER) */
2379
2380 #if defined(HAVE_PRI_CCSS)
2381 /*!
2382  * \internal
2383  * \brief Compare the CC agent private data by libpri cc_id.
2384  * \since 1.8
2385  *
2386  * \param obj pointer to the (user-defined part) of an object.
2387  * \param arg callback argument from ao2_callback()
2388  * \param flags flags from ao2_callback()
2389  *
2390  * \return values are a combination of enum _cb_results.
2391  */
2392 static int sig_pri_cc_agent_cmp_cc_id(void *obj, void *arg, int flags)
2393 {
2394         struct ast_cc_agent *agent_1 = obj;
2395         struct sig_pri_cc_agent_prv *agent_prv_1 = agent_1->private_data;
2396         struct sig_pri_cc_agent_prv *agent_prv_2 = arg;
2397
2398         return (agent_prv_1 && agent_prv_1->pri == agent_prv_2->pri
2399                 && agent_prv_1->cc_id == agent_prv_2->cc_id) ? CMP_MATCH | CMP_STOP : 0;
2400 }
2401 #endif  /* defined(HAVE_PRI_CCSS) */
2402
2403 #if defined(HAVE_PRI_CCSS)
2404 /*!
2405  * \internal
2406  * \brief Find the CC agent by libpri cc_id.
2407  * \since 1.8
2408  *
2409  * \param pri PRI span control structure.
2410  * \param cc_id CC record ID to find.
2411  *
2412  * \note
2413  * Since agents are refcounted, and this function returns
2414  * a reference to the agent, it is imperative that you decrement
2415  * the refcount of the agent once you have finished using it.
2416  *
2417  * \retval agent on success.
2418  * \retval NULL not found.
2419  */
2420 static struct ast_cc_agent *sig_pri_find_cc_agent_by_cc_id(struct sig_pri_span *pri, long cc_id)
2421 {
2422         struct sig_pri_cc_agent_prv finder = {
2423                 .pri = pri,
2424                 .cc_id = cc_id,
2425         };
2426
2427         return ast_cc_agent_callback(0, sig_pri_cc_agent_cmp_cc_id, &finder,
2428                 sig_pri_cc_type_name);
2429 }
2430 #endif  /* defined(HAVE_PRI_CCSS) */
2431
2432 #if defined(HAVE_PRI_CCSS)
2433 /*!
2434  * \internal
2435  * \brief Compare the CC monitor instance by libpri cc_id.
2436  * \since 1.8
2437  *
2438  * \param obj pointer to the (user-defined part) of an object.
2439  * \param arg callback argument from ao2_callback()
2440  * \param flags flags from ao2_callback()
2441  *
2442  * \return values are a combination of enum _cb_results.
2443  */
2444 static int sig_pri_cc_monitor_cmp_cc_id(void *obj, void *arg, int flags)
2445 {
2446         struct sig_pri_cc_monitor_instance *monitor_1 = obj;
2447         struct sig_pri_cc_monitor_instance *monitor_2 = arg;
2448
2449         return (monitor_1->pri == monitor_2->pri
2450                 && monitor_1->cc_id == monitor_2->cc_id) ? CMP_MATCH | CMP_STOP : 0;
2451 }
2452 #endif  /* defined(HAVE_PRI_CCSS) */
2453
2454 #if defined(HAVE_PRI_CCSS)
2455 /*!
2456  * \internal
2457  * \brief Find the CC monitor instance by libpri cc_id.
2458  * \since 1.8
2459  *
2460  * \param pri PRI span control structure.
2461  * \param cc_id CC record ID to find.
2462  *
2463  * \note
2464  * Since monitor_instances are refcounted, and this function returns
2465  * a reference to the instance, it is imperative that you decrement
2466  * the refcount of the instance once you have finished using it.
2467  *
2468  * \retval monitor_instance on success.
2469  * \retval NULL not found.
2470  */
2471 static struct sig_pri_cc_monitor_instance *sig_pri_find_cc_monitor_by_cc_id(struct sig_pri_span *pri, long cc_id)
2472 {
2473         struct sig_pri_cc_monitor_instance finder = {
2474                 .pri = pri,
2475                 .cc_id = cc_id,
2476         };
2477
2478         return ao2_callback(sig_pri_cc_monitors, 0, sig_pri_cc_monitor_cmp_cc_id, &finder);
2479 }
2480 #endif  /* defined(HAVE_PRI_CCSS) */
2481
2482 #if defined(HAVE_PRI_CCSS)
2483 /*!
2484  * \internal
2485  * \brief Destroy the given monitor instance.
2486  * \since 1.8
2487  *
2488  * \param data Monitor instance to destroy.
2489  *
2490  * \return Nothing
2491  */
2492 static void sig_pri_cc_monitor_instance_destroy(void *data)
2493 {
2494         struct sig_pri_cc_monitor_instance *monitor_instance = data;
2495
2496         if (monitor_instance->cc_id != -1) {
2497                 ast_mutex_lock(&monitor_instance->pri->lock);
2498                 pri_cc_cancel(monitor_instance->pri->pri, monitor_instance->cc_id);
2499                 ast_mutex_unlock(&monitor_instance->pri->lock);
2500         }
2501         monitor_instance->pri->calls->module_unref();
2502 }
2503 #endif  /* defined(HAVE_PRI_CCSS) */
2504
2505 #if defined(HAVE_PRI_CCSS)
2506 /*!
2507  * \internal
2508  * \brief Construct a new monitor instance.
2509  * \since 1.8
2510  *
2511  * \param core_id CC core ID.
2512  * \param pri PRI span control structure.
2513  * \param cc_id CC record ID.
2514  * \param device_name Name of device (Asterisk channel name less sequence number).
2515  *
2516  * \note
2517  * Since monitor_instances are refcounted, and this function returns
2518  * a reference to the instance, it is imperative that you decrement
2519  * the refcount of the instance once you have finished using it.
2520  *
2521  * \retval monitor_instance on success.
2522  * \retval NULL on error.
2523  */
2524 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)
2525 {
2526         struct sig_pri_cc_monitor_instance *monitor_instance;
2527
2528         if (!pri->calls->module_ref || !pri->calls->module_unref) {
2529                 return NULL;
2530         }
2531
2532         monitor_instance = ao2_alloc(sizeof(*monitor_instance) + strlen(device_name),
2533                 sig_pri_cc_monitor_instance_destroy);
2534         if (!monitor_instance) {
2535                 return NULL;
2536         }
2537
2538         monitor_instance->cc_id = cc_id;
2539         monitor_instance->pri = pri;
2540         monitor_instance->core_id = core_id;
2541         strcpy(monitor_instance->name, device_name);
2542
2543         pri->calls->module_ref();
2544
2545         ao2_link(sig_pri_cc_monitors, monitor_instance);
2546         return monitor_instance;
2547 }
2548 #endif  /* defined(HAVE_PRI_CCSS) */
2549
2550 #if defined(HAVE_PRI_CCSS)
2551 /*!
2552  * \internal
2553  * \brief Announce to the CC core that protocol CC monitor is available for this call.
2554  * \since 1.8
2555  *
2556  * \param pri PRI span control structure.
2557  * \param chanpos Channel position in the span.
2558  * \param cc_id CC record ID.
2559  * \param service CCBS/CCNR indication.
2560  *
2561  * \note Assumes the pri->lock is already obtained.
2562  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
2563  * \note Assumes the sig_pri_lock_owner(pri, chanpos) is already obtained.
2564  *
2565  * \retval 0 on success.
2566  * \retval -1 on error.
2567  */
2568 static int sig_pri_cc_available(struct sig_pri_span *pri, int chanpos, long cc_id, enum ast_cc_service_type service)
2569 {
2570         struct sig_pri_chan *pvt;
2571         struct ast_cc_config_params *cc_params;
2572         struct sig_pri_cc_monitor_instance *monitor;
2573         enum ast_cc_monitor_policies monitor_policy;
2574         int core_id;
2575         int res;
2576         char device_name[AST_CHANNEL_NAME];
2577         char dialstring[AST_CHANNEL_NAME];
2578
2579         pvt = pri->pvts[chanpos];
2580
2581         core_id = ast_cc_get_current_core_id(pvt->owner);
2582         if (core_id == -1) {
2583                 return -1;
2584         }
2585
2586         cc_params = ast_channel_get_cc_config_params(pvt->owner);
2587         if (!cc_params) {
2588                 return -1;
2589         }
2590
2591         res = -1;
2592         monitor_policy = ast_get_cc_monitor_policy(cc_params);
2593         switch (monitor_policy) {
2594         case AST_CC_MONITOR_NEVER:
2595                 /* CCSS is not enabled. */
2596                 break;
2597         case AST_CC_MONITOR_NATIVE:
2598         case AST_CC_MONITOR_ALWAYS:
2599                 /*
2600                  * If it is AST_CC_MONITOR_ALWAYS and native fails we will attempt the fallback
2601                  * later in the call to sig_pri_cc_generic_check().
2602                  */
2603                 ast_channel_get_device_name(pvt->owner, device_name, sizeof(device_name));
2604                 sig_pri_make_cc_dialstring(pvt, dialstring, sizeof(dialstring));
2605                 monitor = sig_pri_cc_monitor_instance_init(core_id, pri, cc_id, device_name);
2606                 if (!monitor) {
2607                         break;
2608                 }
2609                 res = ast_queue_cc_frame(pvt->owner, sig_pri_cc_type_name, dialstring, service,
2610                         monitor);
2611                 if (res) {
2612                         monitor->cc_id = -1;
2613                         ao2_unlink(sig_pri_cc_monitors, monitor);
2614                         ao2_ref(monitor, -1);
2615                 }
2616                 break;
2617         case AST_CC_MONITOR_GENERIC:
2618                 ast_queue_cc_frame(pvt->owner, AST_CC_GENERIC_MONITOR_TYPE,
2619                         sig_pri_get_orig_dialstring(pvt), service, NULL);
2620                 /* Say it failed to force caller to cancel native CC. */
2621                 break;
2622         }
2623         return res;
2624 }
2625 #endif  /* defined(HAVE_PRI_CCSS) */
2626
2627 /*!
2628  * \internal
2629  * \brief Check if generic CC monitor is needed and request it.
2630  * \since 1.8
2631  *
2632  * \param pri PRI span control structure.
2633  * \param chanpos Channel position in the span.
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  *
2639  * \return Nothing
2640  */
2641 static void sig_pri_cc_generic_check(struct sig_pri_span *pri, int chanpos, enum ast_cc_service_type service)
2642 {
2643         struct ast_channel *owner;
2644         struct ast_cc_config_params *cc_params;
2645 #if defined(HAVE_PRI_CCSS)
2646         struct ast_cc_monitor *monitor;
2647         char device_name[AST_CHANNEL_NAME];
2648 #endif  /* defined(HAVE_PRI_CCSS) */
2649         enum ast_cc_monitor_policies monitor_policy;
2650         int core_id;
2651
2652         if (!pri->pvts[chanpos]->outgoing) {
2653                 /* This is not an outgoing call so it cannot be CC monitor. */
2654                 return;
2655         }
2656
2657         sig_pri_lock_owner(pri, chanpos);
2658         owner = pri->pvts[chanpos]->owner;
2659         if (!owner) {
2660                 return;
2661         }
2662         core_id = ast_cc_get_current_core_id(owner);
2663         if (core_id == -1) {
2664                 /* No CC core setup */
2665                 goto done;
2666         }
2667
2668         cc_params = ast_channel_get_cc_config_params(owner);
2669         if (!cc_params) {
2670                 /* Could not get CC config parameters. */
2671                 goto done;
2672         }
2673
2674 #if defined(HAVE_PRI_CCSS)
2675         ast_channel_get_device_name(owner, device_name, sizeof(device_name));
2676         monitor = ast_cc_get_monitor_by_recall_core_id(core_id, device_name);
2677         if (monitor) {
2678                 /* CC monitor is already present so no need for generic CC. */
2679                 ao2_ref(monitor, -1);
2680                 goto done;
2681         }
2682 #endif  /* defined(HAVE_PRI_CCSS) */
2683
2684         monitor_policy = ast_get_cc_monitor_policy(cc_params);
2685         switch (monitor_policy) {
2686         case AST_CC_MONITOR_NEVER:
2687                 /* CCSS is not enabled. */
2688                 break;
2689         case AST_CC_MONITOR_NATIVE:
2690                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype == PRI_NETWORK) {
2691                         /* Request generic CC monitor. */
2692                         ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2693                                 sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2694                 }
2695                 break;
2696         case AST_CC_MONITOR_ALWAYS:
2697                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype != PRI_NETWORK) {
2698                         /*
2699                          * Cannot monitor PTMP TE side since this is not defined.
2700                          * We are playing the roll of a phone in this case and
2701                          * a phone cannot monitor a party over the network without
2702                          * protocol help.
2703                          */
2704                         break;
2705                 }
2706                 /*
2707                  * We are either falling back or this is a PTMP NT span.
2708                  * Request generic CC monitor.
2709                  */
2710                 ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2711                         sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2712                 break;
2713         case AST_CC_MONITOR_GENERIC:
2714                 if (pri->sig == SIG_BRI_PTMP && pri->nodetype == PRI_NETWORK) {
2715                         /* Request generic CC monitor. */
2716                         ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
2717                                 sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
2718                 }
2719                 break;
2720         }
2721
2722 done:
2723         ast_channel_unlock(owner);
2724 }
2725
2726 #if defined(HAVE_PRI_CCSS)
2727 /*!
2728  * \internal
2729  * \brief The CC link canceled the CC instance.
2730  * \since 1.8
2731  *
2732  * \param pri PRI span control structure.
2733  * \param cc_id CC record ID.
2734  * \param is_agent TRUE if the cc_id is for an agent.
2735  *
2736  * \return Nothing
2737  */
2738 static void sig_pri_cc_link_canceled(struct sig_pri_span *pri, long cc_id, int is_agent)
2739 {
2740         if (is_agent) {
2741                 struct ast_cc_agent *agent;
2742
2743                 agent = sig_pri_find_cc_agent_by_cc_id(pri, cc_id);
2744                 if (!agent) {
2745                         return;
2746                 }
2747                 ast_cc_failed(agent->core_id, "%s agent got canceled by link",
2748                         sig_pri_cc_type_name);
2749                 ao2_ref(agent, -1);
2750         } else {
2751                 struct sig_pri_cc_monitor_instance *monitor;
2752
2753                 monitor = sig_pri_find_cc_monitor_by_cc_id(pri, cc_id);
2754                 if (!monitor) {
2755                         return;
2756                 }
2757                 monitor->cc_id = -1;
2758                 ast_cc_monitor_failed(monitor->core_id, monitor->name,
2759                         "%s monitor got canceled by link", sig_pri_cc_type_name);
2760                 ao2_ref(monitor, -1);
2761         }
2762 }
2763 #endif  /* defined(HAVE_PRI_CCSS) */
2764
2765 #if defined(HAVE_PRI_AOC_EVENTS)
2766 /*!
2767  * \internal
2768  * \brief Convert ast_aoc_charged_item to PRI_AOC_CHARGED_ITEM .
2769  * \since 1.8
2770  *
2771  * \param value Value to convert to string.
2772  *
2773  * \return PRI_AOC_CHARGED_ITEM
2774  */
2775 static enum PRI_AOC_CHARGED_ITEM sig_pri_aoc_charged_item_to_pri(enum PRI_AOC_CHARGED_ITEM value)
2776 {
2777         switch (value) {
2778         case AST_AOC_CHARGED_ITEM_NA:
2779                 return PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE;
2780         case AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT:
2781                 return PRI_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
2782         case AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION:
2783                 return PRI_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
2784         case AST_AOC_CHARGED_ITEM_CALL_ATTEMPT:
2785                 return PRI_AOC_CHARGED_ITEM_CALL_ATTEMPT;
2786         case AST_AOC_CHARGED_ITEM_CALL_SETUP:
2787                 return PRI_AOC_CHARGED_ITEM_CALL_SETUP;
2788         case AST_AOC_CHARGED_ITEM_USER_USER_INFO:
2789                 return PRI_AOC_CHARGED_ITEM_USER_USER_INFO;
2790         case AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE:
2791                 return PRI_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
2792         }
2793         return PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE;
2794 }
2795 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2796
2797 #if defined(HAVE_PRI_AOC_EVENTS)
2798 /*!
2799  * \internal
2800  * \brief Convert PRI_AOC_CHARGED_ITEM to ast_aoc_charged_item.
2801  * \since 1.8
2802  *
2803  * \param value Value to convert to string.
2804  *
2805  * \return ast_aoc_charged_item
2806  */
2807 static enum ast_aoc_s_charged_item sig_pri_aoc_charged_item_to_ast(enum PRI_AOC_CHARGED_ITEM value)
2808 {
2809         switch (value) {
2810         case PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE:
2811                 return AST_AOC_CHARGED_ITEM_NA;
2812         case PRI_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT:
2813                 return AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
2814         case PRI_AOC_CHARGED_ITEM_BASIC_COMMUNICATION:
2815                 return AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
2816         case PRI_AOC_CHARGED_ITEM_CALL_ATTEMPT:
2817                 return AST_AOC_CHARGED_ITEM_CALL_ATTEMPT;
2818         case PRI_AOC_CHARGED_ITEM_CALL_SETUP:
2819                 return AST_AOC_CHARGED_ITEM_CALL_SETUP;
2820         case PRI_AOC_CHARGED_ITEM_USER_USER_INFO:
2821                 return AST_AOC_CHARGED_ITEM_USER_USER_INFO;
2822         case PRI_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE:
2823                 return AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
2824         }
2825         return AST_AOC_CHARGED_ITEM_NA;
2826 }
2827 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2828
2829 #if defined(HAVE_PRI_AOC_EVENTS)
2830 /*!
2831  * \internal
2832  * \brief Convert AST_AOC_MULTIPLER to PRI_AOC_MULTIPLIER.
2833  * \since 1.8
2834  *
2835  * \return pri enum equivalent.
2836  */
2837 static int sig_pri_aoc_multiplier_from_ast(enum ast_aoc_currency_multiplier mult)
2838 {
2839         switch (mult) {
2840         case AST_AOC_MULT_ONETHOUSANDTH:
2841                 return PRI_AOC_MULTIPLIER_THOUSANDTH;
2842         case AST_AOC_MULT_ONEHUNDREDTH:
2843                 return PRI_AOC_MULTIPLIER_HUNDREDTH;
2844         case AST_AOC_MULT_ONETENTH:
2845                 return PRI_AOC_MULTIPLIER_TENTH;
2846         case AST_AOC_MULT_ONE:
2847                 return PRI_AOC_MULTIPLIER_ONE;
2848         case AST_AOC_MULT_TEN:
2849                 return PRI_AOC_MULTIPLIER_TEN;
2850         case AST_AOC_MULT_HUNDRED:
2851                 return PRI_AOC_MULTIPLIER_HUNDRED;
2852         case AST_AOC_MULT_THOUSAND:
2853                 return PRI_AOC_MULTIPLIER_THOUSAND;
2854         default:
2855                 return PRI_AOC_MULTIPLIER_ONE;
2856         }
2857 }
2858 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2859
2860 #if defined(HAVE_PRI_AOC_EVENTS)
2861 /*!
2862  * \internal
2863  * \brief Convert PRI_AOC_MULTIPLIER to AST_AOC_MULTIPLIER
2864  * \since 1.8
2865  *
2866  * \return ast enum equivalent.
2867  */
2868 static int sig_pri_aoc_multiplier_from_pri(const int mult)
2869 {
2870         switch (mult) {
2871         case PRI_AOC_MULTIPLIER_THOUSANDTH:
2872                 return AST_AOC_MULT_ONETHOUSANDTH;
2873         case PRI_AOC_MULTIPLIER_HUNDREDTH:
2874                 return AST_AOC_MULT_ONEHUNDREDTH;
2875         case PRI_AOC_MULTIPLIER_TENTH:
2876                 return AST_AOC_MULT_ONETENTH;
2877         case PRI_AOC_MULTIPLIER_ONE:
2878                 return AST_AOC_MULT_ONE;
2879         case PRI_AOC_MULTIPLIER_TEN:
2880                 return AST_AOC_MULT_TEN;
2881         case PRI_AOC_MULTIPLIER_HUNDRED:
2882                 return AST_AOC_MULT_HUNDRED;
2883         case PRI_AOC_MULTIPLIER_THOUSAND:
2884                 return AST_AOC_MULT_THOUSAND;
2885         default:
2886                 return AST_AOC_MULT_ONE;
2887         }
2888 }
2889 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2890
2891 #if defined(HAVE_PRI_AOC_EVENTS)
2892 /*!
2893  * \internal
2894  * \brief Convert ast_aoc_time_scale representation to PRI_AOC_TIME_SCALE
2895  * \since 1.8
2896  *
2897  * \param value Value to convert to ast representation
2898  *
2899  * \return PRI_AOC_TIME_SCALE
2900  */
2901 static enum PRI_AOC_TIME_SCALE sig_pri_aoc_scale_to_pri(enum ast_aoc_time_scale value)
2902 {
2903         switch (value) {
2904         default:
2905         case AST_AOC_TIME_SCALE_HUNDREDTH_SECOND:
2906                 return PRI_AOC_TIME_SCALE_HUNDREDTH_SECOND;
2907         case AST_AOC_TIME_SCALE_TENTH_SECOND:
2908                 return PRI_AOC_TIME_SCALE_TENTH_SECOND;
2909         case AST_AOC_TIME_SCALE_SECOND:
2910                 return PRI_AOC_TIME_SCALE_SECOND;
2911         case AST_AOC_TIME_SCALE_TEN_SECOND:
2912                 return PRI_AOC_TIME_SCALE_TEN_SECOND;
2913         case AST_AOC_TIME_SCALE_MINUTE:
2914                 return PRI_AOC_TIME_SCALE_MINUTE;
2915         case AST_AOC_TIME_SCALE_HOUR:
2916                 return PRI_AOC_TIME_SCALE_HOUR;
2917         case AST_AOC_TIME_SCALE_DAY:
2918                 return PRI_AOC_TIME_SCALE_DAY;
2919         }
2920 }
2921 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2922
2923 #if defined(HAVE_PRI_AOC_EVENTS)
2924 /*!
2925  * \internal
2926  * \brief Convert PRI_AOC_TIME_SCALE to ast aoc representation
2927  * \since 1.8
2928  *
2929  * \param value Value to convert to ast representation
2930  *
2931  * \return ast aoc time scale
2932  */
2933 static enum ast_aoc_time_scale sig_pri_aoc_scale_to_ast(enum PRI_AOC_TIME_SCALE value)
2934 {
2935         switch (value) {
2936         default:
2937         case PRI_AOC_TIME_SCALE_HUNDREDTH_SECOND:
2938                 return AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
2939         case PRI_AOC_TIME_SCALE_TENTH_SECOND:
2940                 return AST_AOC_TIME_SCALE_TENTH_SECOND;
2941         case PRI_AOC_TIME_SCALE_SECOND:
2942                 return AST_AOC_TIME_SCALE_SECOND;
2943         case PRI_AOC_TIME_SCALE_TEN_SECOND:
2944                 return AST_AOC_TIME_SCALE_TEN_SECOND;
2945         case PRI_AOC_TIME_SCALE_MINUTE:
2946                 return AST_AOC_TIME_SCALE_MINUTE;
2947         case PRI_AOC_TIME_SCALE_HOUR:
2948                 return AST_AOC_TIME_SCALE_HOUR;
2949         case PRI_AOC_TIME_SCALE_DAY:
2950                 return AST_AOC_TIME_SCALE_DAY;
2951         }
2952         return AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
2953 }
2954 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
2955
2956 #if defined(HAVE_PRI_AOC_EVENTS)
2957 /*!
2958  * \internal
2959  * \brief Handle AOC-S control frame
2960  * \since 1.8
2961  *
2962  * \param aoc_s AOC-S event parameters.
2963  * \param owner Asterisk channel associated with the call.
2964  * \param passthrough indicating if this message should be queued on the ast channel
2965  *
2966  * \note Assumes the pri->lock is already obtained.
2967  * \note Assumes the sig_pri private is locked
2968  * \note Assumes the owner channel lock is already obtained.
2969  *
2970  * \return Nothing
2971  */
2972 static void sig_pri_aoc_s_from_pri(const struct pri_subcmd_aoc_s *aoc_s, struct ast_channel *owner, int passthrough)
2973 {
2974         struct ast_aoc_decoded *decoded = NULL;
2975         struct ast_aoc_encoded *encoded = NULL;
2976         size_t encoded_size = 0;
2977         int idx;
2978
2979         if (!owner || !aoc_s) {
2980                 return;
2981         }
2982
2983         if (!(decoded = ast_aoc_create(AST_AOC_S, 0, 0))) {
2984                 return;
2985         }
2986
2987         for (idx = 0; idx < aoc_s->num_items; ++idx) {
2988                 enum ast_aoc_s_charged_item charged_item;
2989
2990                 charged_item = sig_pri_aoc_charged_item_to_ast(aoc_s->item[idx].chargeable);
2991                 if (charged_item == AST_AOC_CHARGED_ITEM_NA) {
2992                         /* Delete the unknown charged item from the list. */
2993                         continue;
2994                 }
2995                 switch (aoc_s->item[idx].rate_type) {
2996                 case PRI_AOC_RATE_TYPE_DURATION:
2997                         ast_aoc_s_add_rate_duration(decoded,
2998                                 charged_item,
2999                                 aoc_s->item[idx].rate.duration.amount.cost,
3000                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.duration.amount.multiplier),
3001                                 aoc_s->item[idx].rate.duration.currency,
3002                                 aoc_s->item[idx].rate.duration.time.length,
3003                                 sig_pri_aoc_scale_to_ast(aoc_s->item[idx].rate.duration.time.scale),
3004                                 aoc_s->item[idx].rate.duration.granularity.length,
3005                                 sig_pri_aoc_scale_to_ast(aoc_s->item[idx].rate.duration.granularity.scale),
3006                                 aoc_s->item[idx].rate.duration.charging_type);
3007                         break;
3008                 case PRI_AOC_RATE_TYPE_FLAT:
3009                         ast_aoc_s_add_rate_flat(decoded,
3010                                 charged_item,
3011                                 aoc_s->item[idx].rate.flat.amount.cost,
3012                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.flat.amount.multiplier),
3013                                 aoc_s->item[idx].rate.flat.currency);
3014                         break;
3015                 case PRI_AOC_RATE_TYPE_VOLUME:
3016                         ast_aoc_s_add_rate_volume(decoded,
3017                                 charged_item,
3018                                 aoc_s->item[idx].rate.volume.unit,
3019                                 aoc_s->item[idx].rate.volume.amount.cost,
3020                                 sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.volume.amount.multiplier),
3021                                 aoc_s->item[idx].rate.volume.currency);
3022                         break;
3023                 case PRI_AOC_RATE_TYPE_SPECIAL_CODE:
3024                         ast_aoc_s_add_rate_special_charge_code(decoded,
3025                                 charged_item,
3026                                 aoc_s->item[idx].rate.special);
3027                         break;
3028                 case PRI_AOC_RATE_TYPE_FREE:
3029                         ast_aoc_s_add_rate_free(decoded, charged_item, 0);
3030                         break;
3031                 case PRI_AOC_RATE_TYPE_FREE_FROM_BEGINNING:
3032                         ast_aoc_s_add_rate_free(decoded, charged_item, 1);
3033                         break;
3034                 default:
3035                         ast_aoc_s_add_rate_na(decoded, charged_item);
3036                         break;
3037                 }
3038         }
3039
3040         if (passthrough && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
3041                 ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
3042         }
3043
3044         ast_aoc_manager_event(decoded, owner);
3045
3046         ast_aoc_destroy_decoded(decoded);
3047         ast_aoc_destroy_encoded(encoded);
3048 }
3049 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3050
3051 #if defined(HAVE_PRI_AOC_EVENTS)
3052 /*!
3053  * \internal
3054  * \brief Generate AOC Request Response
3055  * \since 1.8
3056  *
3057  * \param aoc_request
3058  *
3059  * \note Assumes the pri->lock is already obtained.
3060  * \note Assumes the sig_pri private is locked
3061  * \note Assumes the owner channel lock is already obtained.
3062  *
3063  * \return Nothing
3064  */
3065 static void sig_pri_aoc_request_from_pri(const struct pri_subcmd_aoc_request *aoc_request, struct sig_pri_chan *pvt, q931_call *call)
3066 {
3067         int request;
3068
3069         if (!aoc_request) {
3070                 return;
3071         }
3072
3073         request = aoc_request->charging_request;
3074
3075         if (request & PRI_AOC_REQUEST_S) {
3076                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_S) {
3077                         /* An AOC-S response must come from the other side, so save off this invoke_id
3078                          * and see if an AOC-S message comes in before the call is answered. */
3079                         pvt->aoc_s_request_invoke_id = aoc_request->invoke_id;
3080                         pvt->aoc_s_request_invoke_id_valid = 1;
3081
3082                 } else {
3083                         pri_aoc_s_request_response_send(pvt->pri->pri,
3084                                 call,
3085                                 aoc_request->invoke_id,
3086                                 NULL);
3087                 }
3088         }
3089
3090         if (request & PRI_AOC_REQUEST_D) {
3091                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_D) {
3092                         pri_aoc_de_request_response_send(pvt->pri->pri,
3093                                 call,
3094                                 PRI_AOC_REQ_RSP_CHARGING_INFO_FOLLOWS,
3095                                 aoc_request->invoke_id);
3096                 } else {
3097                         pri_aoc_de_request_response_send(pvt->pri->pri,
3098                                 call,
3099                                 PRI_AOC_REQ_RSP_ERROR_NOT_AVAILABLE,
3100                                 aoc_request->invoke_id);
3101                 }
3102         }
3103
3104         if (request & PRI_AOC_REQUEST_E) {
3105                 if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_E) {
3106                         pri_aoc_de_request_response_send(pvt->pri->pri,
3107                                 call,
3108                                 PRI_AOC_REQ_RSP_CHARGING_INFO_FOLLOWS,
3109                                 aoc_request->invoke_id);
3110                 } else {
3111                         pri_aoc_de_request_response_send(pvt->pri->pri,
3112                                 call,
3113                                 PRI_AOC_REQ_RSP_ERROR_NOT_AVAILABLE,
3114                                 aoc_request->invoke_id);
3115                 }
3116         }
3117 }
3118 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3119
3120 #if defined(HAVE_PRI_AOC_EVENTS)
3121 /*!
3122  * \internal
3123  * \brief Generate AOC-D AST_CONTROL_AOC frame
3124  * \since 1.8
3125  *
3126  * \param aoc_e AOC-D event parameters.
3127  * \param owner Asterisk channel associated with the call.
3128  * \param passthrough indicating if this message should be queued on the ast channel
3129  *
3130  * \note Assumes the pri->lock is already obtained.
3131  * \note Assumes the sig_pri private is locked
3132  * \note Assumes the owner channel lock is already obtained.
3133  *
3134  * \return Nothing
3135  */
3136 static void sig_pri_aoc_d_from_pri(const struct pri_subcmd_aoc_d *aoc_d, struct ast_channel *owner, int passthrough)
3137 {
3138         struct ast_aoc_decoded *decoded = NULL;
3139         struct ast_aoc_encoded *encoded = NULL;
3140         size_t encoded_size = 0;
3141         enum ast_aoc_charge_type type;
3142
3143         if (!owner || !aoc_d) {
3144                 return;
3145         }
3146
3147         switch (aoc_d->charge) {
3148         case PRI_AOC_DE_CHARGE_CURRENCY:
3149                 type = AST_AOC_CHARGE_CURRENCY;
3150                 break;
3151         case PRI_AOC_DE_CHARGE_UNITS:
3152                 type = AST_AOC_CHARGE_UNIT;
3153                 break;
3154         case PRI_AOC_DE_CHARGE_FREE:
3155                 type = AST_AOC_CHARGE_FREE;
3156                 break;
3157         default:
3158                 type = AST_AOC_CHARGE_NA;
3159                 break;
3160         }
3161
3162         if (!(decoded = ast_aoc_create(AST_AOC_D, type, 0))) {
3163                 return;
3164         }
3165
3166         switch (aoc_d->billing_accumulation) {
3167         default:
3168                 ast_debug(1, "AOC-D billing accumulation has unknown value: %d\n",
3169                         aoc_d->billing_accumulation);
3170                 /* Fall through */
3171         case 0:/* subTotal */
3172                 ast_aoc_set_total_type(decoded, AST_AOC_SUBTOTAL);
3173                 break;
3174         case 1:/* total */
3175                 ast_aoc_set_total_type(decoded, AST_AOC_TOTAL);
3176                 break;
3177         }
3178
3179         switch (aoc_d->billing_id) {
3180         case PRI_AOC_D_BILLING_ID_NORMAL:
3181                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NORMAL);
3182                 break;
3183         case PRI_AOC_D_BILLING_ID_REVERSE:
3184                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_REVERSE_CHARGE);
3185                 break;
3186         case PRI_AOC_D_BILLING_ID_CREDIT_CARD:
3187                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CREDIT_CARD);
3188                 break;
3189         case PRI_AOC_D_BILLING_ID_NOT_AVAILABLE:
3190         default:
3191                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NA);
3192                 break;
3193         }
3194
3195         switch (aoc_d->charge) {
3196         case PRI_AOC_DE_CHARGE_CURRENCY:
3197                 ast_aoc_set_currency_info(decoded,
3198                         aoc_d->recorded.money.amount.cost,
3199                         sig_pri_aoc_multiplier_from_pri(aoc_d->recorded.money.amount.multiplier),
3200                         aoc_d->recorded.money.currency);
3201                 break;
3202         case PRI_AOC_DE_CHARGE_UNITS:
3203                 {
3204                         int i;
3205                         for (i = 0; i < aoc_d->recorded.unit.num_items; ++i) {
3206                                 /* if type or number are negative, then they are not present */
3207                                 ast_aoc_add_unit_entry(decoded,
3208                                         (aoc_d->recorded.unit.item[i].number >= 0 ? 1 : 0),
3209                                         aoc_d->recorded.unit.item[i].number,
3210                                         (aoc_d->recorded.unit.item[i].type >= 0 ? 1 : 0),
3211                                         aoc_d->recorded.unit.item[i].type);
3212                         }
3213                 }
3214                 break;
3215         }
3216
3217         if (passthrough && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
3218                 ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
3219         }
3220
3221         ast_aoc_manager_event(decoded, owner);
3222
3223         ast_aoc_destroy_decoded(decoded);
3224         ast_aoc_destroy_encoded(encoded);
3225 }
3226 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3227
3228 #if defined(HAVE_PRI_AOC_EVENTS)
3229 /*!
3230  * \internal
3231  * \brief Generate AOC-E AST_CONTROL_AOC frame
3232  * \since 1.8
3233  *
3234  * \param aoc_e AOC-E event parameters.
3235  * \param owner Asterisk channel associated with the call.
3236  * \param passthrough indicating if this message should be queued on the ast channel
3237  *
3238  * \note Assumes the pri->lock is already obtained.
3239  * \note Assumes the sig_pri private is locked
3240  * \note Assumes the owner channel lock is already obtained.
3241  * \note owner channel may be NULL. In that case, generate event only
3242  *
3243  * \return Nothing
3244  */
3245 static void sig_pri_aoc_e_from_pri(const struct pri_subcmd_aoc_e *aoc_e, struct ast_channel *owner, int passthrough)
3246 {
3247         struct ast_aoc_decoded *decoded = NULL;
3248         struct ast_aoc_encoded *encoded = NULL;
3249         size_t encoded_size = 0;
3250         enum ast_aoc_charge_type type;
3251
3252         if (!aoc_e) {
3253                 return;
3254         }
3255
3256         switch (aoc_e->charge) {
3257         case PRI_AOC_DE_CHARGE_CURRENCY:
3258                 type = AST_AOC_CHARGE_CURRENCY;
3259                 break;
3260         case PRI_AOC_DE_CHARGE_UNITS:
3261                 type = AST_AOC_CHARGE_UNIT;
3262                 break;
3263         case PRI_AOC_DE_CHARGE_FREE:
3264                 type = AST_AOC_CHARGE_FREE;
3265                 break;
3266         default:
3267                 type = AST_AOC_CHARGE_NA;
3268                 break;
3269         }
3270
3271         if (!(decoded = ast_aoc_create(AST_AOC_E, type, 0))) {
3272                 return;
3273         }
3274
3275         switch (aoc_e->associated.charging_type) {
3276         case PRI_AOC_E_CHARGING_ASSOCIATION_NUMBER:
3277                 if (!aoc_e->associated.charge.number.valid) {
3278                         break;
3279                 }
3280                 ast_aoc_set_association_number(decoded, aoc_e->associated.charge.number.str, aoc_e->associated.charge.number.plan);
3281                 break;
3282         case PRI_AOC_E_CHARGING_ASSOCIATION_ID:
3283                 ast_aoc_set_association_id(decoded, aoc_e->associated.charge.id);
3284                 break;
3285         default:
3286                 break;
3287         }
3288
3289         switch (aoc_e->billing_id) {
3290         case PRI_AOC_E_BILLING_ID_NORMAL:
3291                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NORMAL);
3292                 break;
3293         case PRI_AOC_E_BILLING_ID_REVERSE:
3294                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_REVERSE_CHARGE);
3295                 break;
3296         case PRI_AOC_E_BILLING_ID_CREDIT_CARD:
3297                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CREDIT_CARD);
3298                 break;
3299         case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_UNCONDITIONAL:
3300                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_UNCONDITIONAL);
3301                 break;
3302         case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_BUSY:
3303                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_BUSY);
3304                 break;
3305         case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_NO_REPLY:
3306                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_NO_REPLY);
3307                 break;
3308         case PRI_AOC_E_BILLING_ID_CALL_DEFLECTION:
3309                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_DEFLECTION);
3310                 break;
3311         case PRI_AOC_E_BILLING_ID_CALL_TRANSFER:
3312                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_TRANSFER);
3313                 break;
3314         case PRI_AOC_E_BILLING_ID_NOT_AVAILABLE:
3315         default:
3316                 ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NA);
3317                 break;
3318         }
3319
3320         switch (aoc_e->charge) {
3321         case PRI_AOC_DE_CHARGE_CURRENCY:
3322                 ast_aoc_set_currency_info(decoded,
3323                         aoc_e->recorded.money.amount.cost,
3324                         sig_pri_aoc_multiplier_from_pri(aoc_e->recorded.money.amount.multiplier),
3325                         aoc_e->recorded.money.currency);
3326                 break;
3327         case PRI_AOC_DE_CHARGE_UNITS:
3328                 {
3329                         int i;
3330                         for (i = 0; i < aoc_e->recorded.unit.num_items; ++i) {
3331                                 /* if type or number are negative, then they are not present */
3332                                 ast_aoc_add_unit_entry(decoded,
3333                                         (aoc_e->recorded.unit.item[i].number >= 0 ? 1 : 0),
3334                                         aoc_e->recorded.unit.item[i].number,
3335                                         (aoc_e->recorded.unit.item[i].type >= 0 ? 1 : 0),
3336                                         aoc_e->recorded.unit.item[i].type);
3337                         }
3338                 }
3339         }
3340
3341         if (passthrough && owner && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
3342                 ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
3343         }
3344
3345         ast_aoc_manager_event(decoded, owner);
3346
3347         ast_aoc_destroy_decoded(decoded);
3348         ast_aoc_destroy_encoded(encoded);
3349 }
3350 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3351
3352 #if defined(HAVE_PRI_AOC_EVENTS)
3353 /*!
3354  * \internal
3355  * \brief send an AOC-S message on the current call
3356  *
3357  * \param pvt sig_pri private channel structure.
3358  * \param generic decoded ast AOC message
3359  *
3360  * \return Nothing
3361  *
3362  * \note Assumes that the PRI lock is already obtained.
3363  */
3364 static void sig_pri_aoc_s_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
3365 {
3366         struct pri_subcmd_aoc_s aoc_s = { 0, };
3367         const struct ast_aoc_s_entry *entry;
3368         int idx;
3369
3370         for (idx = 0; idx < ast_aoc_s_get_count(decoded); idx++) {
3371                 if (!(entry = ast_aoc_s_get_rate_info(decoded, idx))) {
3372                         break;
3373                 }
3374
3375                 aoc_s.item[idx].chargeable = sig_pri_aoc_charged_item_to_pri(entry->charged_item);
3376
3377                 switch (entry->rate_type) {
3378                 case AST_AOC_RATE_TYPE_DURATION:
3379                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_DURATION;
3380                         aoc_s.item[idx].rate.duration.amount.cost = entry->rate.duration.amount;
3381                         aoc_s.item[idx].rate.duration.amount.multiplier =
3382                                 sig_pri_aoc_multiplier_from_ast(entry->rate.duration.multiplier);
3383                         aoc_s.item[idx].rate.duration.time.length = entry->rate.duration.time;
3384                         aoc_s.item[idx].rate.duration.time.scale =
3385                                 sig_pri_aoc_scale_to_pri(entry->rate.duration.time_scale);
3386                         aoc_s.item[idx].rate.duration.granularity.length = entry->rate.duration.granularity_time;
3387                         aoc_s.item[idx].rate.duration.granularity.scale =
3388                                 sig_pri_aoc_scale_to_pri(entry->rate.duration.granularity_time_scale);
3389                         aoc_s.item[idx].rate.duration.charging_type = entry->rate.duration.charging_type;
3390
3391                         if (!ast_strlen_zero(entry->rate.duration.currency_name)) {
3392                                 ast_copy_string(aoc_s.item[idx].rate.duration.currency,
3393                                         entry->rate.duration.currency_name,
3394                                         sizeof(aoc_s.item[idx].rate.duration.currency));
3395                         }
3396                         break;
3397                 case AST_AOC_RATE_TYPE_FLAT:
3398                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FLAT;
3399                         aoc_s.item[idx].rate.flat.amount.cost = entry->rate.flat.amount;
3400                         aoc_s.item[idx].rate.flat.amount.multiplier =
3401                                 sig_pri_aoc_multiplier_from_ast(entry->rate.flat.multiplier);
3402
3403                         if (!ast_strlen_zero(entry->rate.flat.currency_name)) {
3404                                 ast_copy_string(aoc_s.item[idx].rate.flat.currency,
3405                                         entry->rate.flat.currency_name,
3406                                         sizeof(aoc_s.item[idx].rate.flat.currency));
3407                         }
3408                         break;
3409                 case AST_AOC_RATE_TYPE_VOLUME:
3410                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_VOLUME;
3411                         aoc_s.item[idx].rate.volume.unit = entry->rate.volume.volume_unit;
3412                         aoc_s.item[idx].rate.volume.amount.cost = entry->rate.volume.amount;
3413                         aoc_s.item[idx].rate.volume.amount.multiplier =
3414                                 sig_pri_aoc_multiplier_from_ast(entry->rate.volume.multiplier);
3415
3416                         if (!ast_strlen_zero(entry->rate.volume.currency_name)) {
3417                                 ast_copy_string(aoc_s.item[idx].rate.volume.currency,
3418                                         entry->rate.volume.currency_name,
3419                                         sizeof(aoc_s.item[idx].rate.volume.currency));
3420                         }
3421                         break;
3422                 case AST_AOC_RATE_TYPE_SPECIAL_CODE:
3423                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_SPECIAL_CODE;
3424                         aoc_s.item[idx].rate.special = entry->rate.special_code;
3425                         break;
3426                 case AST_AOC_RATE_TYPE_FREE:
3427                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FREE;
3428                         break;
3429                 case AST_AOC_RATE_TYPE_FREE_FROM_BEGINNING:
3430                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FREE_FROM_BEGINNING;
3431                         break;
3432                 default:
3433                 case AST_AOC_RATE_TYPE_NA:
3434                         aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_NOT_AVAILABLE;
3435                         break;
3436                 }
3437         }
3438         aoc_s.num_items = idx;
3439
3440         /* if this rate should be sent as a response to an AOC-S request we will
3441          * have an aoc_s_request_invoke_id associated with this pvt */
3442         if (pvt->aoc_s_request_invoke_id_valid) {
3443                 pri_aoc_s_request_response_send(pvt->pri->pri, pvt->call, pvt->aoc_s_request_invoke_id, &aoc_s);
3444                 pvt->aoc_s_request_invoke_id_valid = 0;
3445         } else {
3446                 pri_aoc_s_send(pvt->pri->pri, pvt->call, &aoc_s);
3447         }
3448 }
3449 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3450
3451 #if defined(HAVE_PRI_AOC_EVENTS)
3452 /*!
3453  * \internal
3454  * \brief send an AOC-D message on the current call
3455  *
3456  * \param pvt sig_pri private channel structure.
3457  * \param generic decoded ast AOC message
3458  *
3459  * \return Nothing
3460  *
3461  * \note Assumes that the PRI lock is already obtained.
3462  */
3463 static void sig_pri_aoc_d_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
3464 {
3465         struct pri_subcmd_aoc_d aoc_d = { 0, };
3466
3467         aoc_d.billing_accumulation = (ast_aoc_get_total_type(decoded) == AST_AOC_TOTAL) ? 1 : 0;
3468
3469         switch (ast_aoc_get_billing_id(decoded)) {
3470         case AST_AOC_BILLING_NORMAL:
3471                 aoc_d.billing_id = PRI_AOC_D_BILLING_ID_NORMAL;
3472                 break;
3473         case AST_AOC_BILLING_REVERSE_CHARGE:
3474                 aoc_d.billing_id = PRI_AOC_D_BILLING_ID_REVERSE;
3475                 break;
3476         case AST_AOC_BILLING_CREDIT_CARD:
3477                 aoc_d.billing_id = PRI_AOC_D_BILLING_ID_CREDIT_CARD;
3478                 break;
3479         case AST_AOC_BILLING_NA:
3480         default:
3481                 aoc_d.billing_id = PRI_AOC_D_BILLING_ID_NOT_AVAILABLE;
3482                 break;
3483         }
3484
3485         switch (ast_aoc_get_charge_type(decoded)) {
3486         case AST_AOC_CHARGE_FREE:
3487                 aoc_d.charge = PRI_AOC_DE_CHARGE_FREE;
3488                 break;
3489         case AST_AOC_CHARGE_CURRENCY:
3490                 {
3491                         const char *currency_name = ast_aoc_get_currency_name(decoded);
3492                         aoc_d.charge = PRI_AOC_DE_CHARGE_CURRENCY;
3493                         aoc_d.recorded.money.amount.cost = ast_aoc_get_currency_amount(decoded);
3494                         aoc_d.recorded.money.amount.multiplier = sig_pri_aoc_multiplier_from_ast(ast_aoc_get_currency_multiplier(decoded));
3495                         if (!ast_strlen_zero(currency_name)) {
3496                                 ast_copy_string(aoc_d.recorded.money.currency, currency_name, sizeof(aoc_d.recorded.money.currency));
3497                         }
3498                 }
3499                 break;
3500         case AST_AOC_CHARGE_UNIT:
3501                 {
3502                         const struct ast_aoc_unit_entry *entry;
3503                         int i;
3504                         aoc_d.charge = PRI_AOC_DE_CHARGE_UNITS;
3505                         for (i = 0; i < ast_aoc_get_unit_count(decoded); i++) {
3506                                 if ((entry = ast_aoc_get_unit_info(decoded, i)) && i < ARRAY_LEN(aoc_d.recorded.unit.item)) {
3507                                         if (entry->valid_amount) {
3508                                                 aoc_d.recorded.unit.item[i].number = entry->amount;
3509                                         } else {
3510                                                 aoc_d.recorded.unit.item[i].number = -1;
3511                                         }
3512                                         if (entry->valid_type) {
3513                                                 aoc_d.recorded.unit.item[i].type = entry->type;
3514                                         } else {
3515                                                 aoc_d.recorded.unit.item[i].type = -1;
3516                                         }
3517                                         aoc_d.recorded.unit.num_items++;
3518                                 } else {
3519                                         break;
3520                                 }
3521                         }
3522                 }
3523                 break;
3524         case AST_AOC_CHARGE_NA:
3525         default:
3526                 aoc_d.charge = PRI_AOC_DE_CHARGE_NOT_AVAILABLE;
3527                 break;
3528         }
3529
3530         pri_aoc_d_send(pvt->pri->pri, pvt->call, &aoc_d);
3531 }
3532 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3533
3534 #if defined(HAVE_PRI_AOC_EVENTS)
3535 /*!
3536  * \internal
3537  * \brief send an AOC-E message on the current call
3538  *
3539  * \param pvt sig_pri private channel structure.
3540  * \param generic decoded ast AOC message
3541  *
3542  * \return Nothing
3543  *
3544  * \note Assumes that the PRI lock is already obtained.
3545  */
3546 static void sig_pri_aoc_e_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
3547 {
3548         struct pri_subcmd_aoc_e *aoc_e = &pvt->aoc_e;
3549         const struct ast_aoc_charging_association *ca = ast_aoc_get_association_info(decoded);
3550
3551         memset(aoc_e, 0, sizeof(*aoc_e));
3552         pvt->holding_aoce = 1;
3553
3554         switch (ca->charging_type) {
3555         case AST_AOC_CHARGING_ASSOCIATION_NUMBER:
3556                 aoc_e->associated.charge.number.valid = 1;
3557                 ast_copy_string(aoc_e->associated.charge.number.str,
3558                         ca->charge.number.number,
3559                         sizeof(aoc_e->associated.charge.number.str));
3560                 aoc_e->associated.charge.number.plan = ca->charge.number.plan;
3561                 aoc_e->associated.charging_type = PRI_AOC_E_CHARGING_ASSOCIATION_NUMBER;
3562                 break;
3563         case AST_AOC_CHARGING_ASSOCIATION_ID:
3564                 aoc_e->associated.charge.id = ca->charge.id;
3565                 aoc_e->associated.charging_type = PRI_AOC_E_CHARGING_ASSOCIATION_ID;
3566                 break;
3567         case AST_AOC_CHARGING_ASSOCIATION_NA:
3568         default:
3569                 break;
3570         }
3571
3572         switch (ast_aoc_get_billing_id(decoded)) {
3573         case AST_AOC_BILLING_NORMAL:
3574                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_NORMAL;
3575                 break;
3576         case AST_AOC_BILLING_REVERSE_CHARGE:
3577                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_REVERSE;
3578                 break;
3579         case AST_AOC_BILLING_CREDIT_CARD:
3580                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CREDIT_CARD;
3581                 break;
3582         case AST_AOC_BILLING_CALL_FWD_UNCONDITIONAL:
3583                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_UNCONDITIONAL;
3584                 break;
3585         case AST_AOC_BILLING_CALL_FWD_BUSY:
3586                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_BUSY;
3587                 break;
3588         case AST_AOC_BILLING_CALL_FWD_NO_REPLY:
3589                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_NO_REPLY;
3590                 break;
3591         case AST_AOC_BILLING_CALL_DEFLECTION:
3592                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_DEFLECTION;
3593                 break;
3594         case AST_AOC_BILLING_CALL_TRANSFER:
3595                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_TRANSFER;
3596                 break;
3597         case AST_AOC_BILLING_NA:
3598         default:
3599                 aoc_e->billing_id = PRI_AOC_E_BILLING_ID_NOT_AVAILABLE;
3600                 break;
3601         }
3602
3603         switch (ast_aoc_get_charge_type(decoded)) {
3604         case AST_AOC_CHARGE_FREE:
3605                 aoc_e->charge = PRI_AOC_DE_CHARGE_FREE;
3606                 break;
3607         case AST_AOC_CHARGE_CURRENCY:
3608                 {
3609                         const char *currency_name = ast_aoc_get_currency_name(decoded);
3610                         aoc_e->charge = PRI_AOC_DE_CHARGE_CURRENCY;
3611                         aoc_e->recorded.money.amount.cost = ast_aoc_get_currency_amount(decoded);
3612                         aoc_e->recorded.money.amount.multiplier = sig_pri_aoc_multiplier_from_ast(ast_aoc_get_currency_multiplier(decoded));
3613                         if (!ast_strlen_zero(currency_name)) {
3614                                 ast_copy_string(aoc_e->recorded.money.currency, currency_name, sizeof(aoc_e->recorded.money.currency));
3615                         }
3616                 }
3617                 break;
3618         case AST_AOC_CHARGE_UNIT:
3619                 {
3620                         const struct ast_aoc_unit_entry *entry;
3621                         int i;
3622                         aoc_e->charge = PRI_AOC_DE_CHARGE_UNITS;
3623                         for (i = 0; i < ast_aoc_get_unit_count(decoded); i++) {
3624                                 if ((entry = ast_aoc_get_unit_info(decoded, i)) && i < ARRAY_LEN(aoc_e->recorded.unit.item)) {
3625                                         if (entry->valid_amount) {
3626                                                 aoc_e->recorded.unit.item[i].number = entry->amount;
3627                                         } else {
3628                                                 aoc_e->recorded.unit.item[i].number = -1;
3629                                         }
3630                                         if (entry->valid_type) {
3631                                                 aoc_e->recorded.unit.item[i].type = entry->type;
3632                                         } else {
3633                                                 aoc_e->recorded.unit.item[i].type = -1;
3634                                         }
3635                                         aoc_e->recorded.unit.num_items++;
3636                                 }
3637                         }
3638                 }
3639                 break;
3640         case AST_AOC_CHARGE_NA:
3641         default:
3642                 aoc_e->charge = PRI_AOC_DE_CHARGE_NOT_AVAILABLE;
3643                 break;
3644         }
3645 }
3646 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3647
3648 #if defined(HAVE_PRI_AOC_EVENTS)
3649 /*!
3650  * \internal
3651  * \brief send an AOC-E termination request on ast_channel and set
3652  * hangup delay.
3653  *
3654  * \param pri PRI span control structure.
3655  * \param chanpos Channel position in the span.
3656  * \param ms to delay hangup
3657  *
3658  * \note Assumes the pri->lock is already obtained.
3659  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
3660  *
3661  * \return Nothing
3662  */
3663 static void sig_pri_send_aoce_termination_request(struct sig_pri_span *pri, int chanpos, unsigned int ms)
3664 {
3665         struct sig_pri_chan *pvt;
3666         struct ast_aoc_decoded *decoded = NULL;
3667         struct ast_aoc_encoded *encoded = NULL;
3668         size_t encoded_size;
3669         struct timeval whentohangup = { 0, };
3670
3671         sig_pri_lock_owner(pri, chanpos);
3672         pvt = pri->pvts[chanpos];
3673         if (!pvt->owner) {
3674                 return;
3675         }
3676
3677         if (!(decoded = ast_aoc_create(AST_AOC_REQUEST, 0, AST_AOC_REQUEST_E))) {
3678                 ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
3679                 goto cleanup_termination_request;
3680         }
3681
3682         ast_aoc_set_termination_request(decoded);
3683
3684         if (!(encoded = ast_aoc_encode(decoded, &encoded_size, pvt->owner))) {
3685                 ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
3686                 goto cleanup_termination_request;
3687         }
3688
3689         /* convert ms to timeval */
3690         whentohangup.tv_usec = (ms % 1000) * 1000;
3691         whentohangup.tv_sec = ms / 1000;
3692
3693         if (ast_queue_control_data(pvt->owner, AST_CONTROL_AOC, encoded, encoded_size)) {
3694                 ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
3695                 goto cleanup_termination_request;
3696         }
3697
3698         pvt->waiting_for_aoce = 1;
3699         ast_channel_setwhentohangup_tv(pvt->owner, whentohangup);
3700         ast_debug(1, "Delaying hangup on %s for aoc-e msg\n", pvt->owner->name);
3701
3702 cleanup_termination_request:
3703         ast_channel_unlock(pvt->owner);
3704         ast_aoc_destroy_decoded(decoded);
3705         ast_aoc_destroy_encoded(encoded);
3706 }
3707 #endif  /* defined(HAVE_PRI_AOC_EVENTS) */
3708
3709 /*!
3710  * \internal
3711  * \brief TRUE if PRI event came in on a CIS call.
3712  * \since 1.8
3713  *
3714  * \param channel PRI encoded span/channel
3715  *
3716  * \retval non-zero if CIS call.
3717  */
3718 static int sig_pri_is_cis_call(int channel)
3719 {
3720         return channel != -1 && (channel & PRI_CIS_CALL);
3721 }
3722
3723 /*!
3724  * \internal
3725  * \brief Handle the CIS associated PRI subcommand events.
3726  * \since 1.8
3727  *
3728  * \param pri PRI span control structure.
3729  * \param event_id PRI event id
3730  * \param subcmds Subcommands to process if any. (Could be NULL).
3731  * \param call_rsp libpri opaque call structure to send any responses toward.
3732  * Could be NULL either because it is not available or the call is for the
3733  * dummy call reference.  However, this should not be NULL in the cases that
3734  * need to use the pointer to send a response message back.
3735  *
3736  * \note Assumes the pri->lock is already obtained.
3737  *
3738  * \return Nothing
3739  */
3740 static void sig_pri_handle_cis_subcmds(struct sig_pri_span *pri, int event_id,
3741         const struct pri_subcommands *subcmds, q931_call *call_rsp)
3742 {
3743         int index;
3744 #if defined(HAVE_PRI_CCSS)
3745         struct ast_cc_agent *agent;
3746         struct sig_pri_cc_agent_prv *agent_prv;
3747         struct sig_pri_cc_monitor_instance *monitor;
3748 #endif  /* defined(HAVE_PRI_CCSS) */
3749
3750         if (!subcmds) {
3751                 return;
3752         }
3753         for (index = 0; index < subcmds->counter_subcmd; ++index) {
3754                 const struct pri_subcommand *subcmd = &subcmds->subcmd[index];
3755
3756                 switch (subcmd->cmd) {
3757 #if defined(STATUS_REQUEST_PLACE_HOLDER)
3758                 case PRI_SUBCMD_STATUS_REQ:
3759                 case PRI_SUBCMD_STATUS_REQ_RSP:
3760                         /* Ignore for now. */
3761                         break;
3762 #endif  /* defined(STATUS_REQUEST_PLACE_HOLDER) */
3763 #if defined(HAVE_PRI_CCSS)
3764                 case PRI_SUBCMD_CC_REQ:
3765                         agent = sig_pri_find_cc_agent_by_cc_id(pri, subcmd->u.cc_request.cc_id);
3766                         if (!agent) {
3767                                 pri_cc_cancel(pri->pri, subcmd->u.cc_request.cc_id);
3768                                 break;
3769                         }
3770                         if (!ast_cc_request_is_within_limits()) {
3771                                 if (pri_cc_req_rsp(pri->pri, subcmd->u.cc_request.cc_id,
3772                                         5/* queue_full */)) {
3773                                         pri_cc_cancel(pri->pri, subcmd->u.cc_request.cc_id);
3774                                 }
3775                                 ast_cc_failed(agent->core_id, "%s agent system CC queue full",
3776                                         sig_pri_cc_type_name);
3777                                 ao2_ref(agent, -1);
3778                                 break;
3779                         }
3780                         agent_prv = agent->private_data;
3781                         agent_prv->cc_request_response_pending = 1;
3782                         if (ast_cc_agent_accept_request(agent->core_id,
3783                                 "%s caller accepted CC offer.", sig_pri_cc_type_name)) {
3784                                 agent_prv->cc_request_response_pending = 0;
3785                                 if (pri_cc_req_rsp(pri->pri, subcmd->u.cc_request.cc_id,
3786                                         2/* short_term_denial */)) {
3787                                         pri_cc_cancel(pri->pri, subcmd->u.cc_request.cc_id);
3788                                 }
3789                                 ast_cc_failed(agent->core_id, "%s agent CC core request accept failed",
3790                                         sig_pri_cc_type_name);
3791                         }
3792                         ao2_ref(agent, -1);
3793                         break;
3794 #endif  /* defined(HAVE_PRI_CCSS) */
3795 #if defined(HAVE_PRI_CCSS)
3796                 case PRI_SUBCMD_CC_REQ_RSP:
3797                         monitor = sig_pri_find_cc_monitor_by_cc_id(pri,
3798                                 subcmd->u.cc_request_rsp.cc_id);
3799                         if (!monitor) {
3800                                 pri_cc_cancel(pri->pri, subcmd->u.cc_request_rsp.cc_id);
3801                                 break;
3802                         }
3803                         switch (subcmd->u.cc_request_rsp.status) {
3804                         case 0:/* success */
3805                                 ast_cc_monitor_request_acked(monitor->core_id,
3806                                         "%s far end accepted CC request", sig_pri_cc_type_name);
3807                                 break;
3808                         case 1:/* timeout */
3809                                 ast_verb(2, "core_id:%d %s CC request timeout\n", monitor->core_id,
3810                                         sig_pri_cc_type_name);
3811                                 ast_cc_monitor_failed(monitor->core_id, monitor->name,
3812                                         "%s CC request timeout", sig_pri_cc_type_name);
3813                                 break;
3814                         case 2:/* error */
3815                                 ast_verb(2, "core_id:%d %s CC request error: %s\n", monitor->core_id,
3816                                         sig_pri_cc_type_name,
3817                                         pri_facility_error2str(subcmd->u.cc_request_rsp.fail_code));
3818                                 ast_cc_monitor_failed(monitor->core_id, monitor->name,
3819                                         "%s CC request error", sig_pri_cc_type_name);
3820                                 break;
3821                         case 3:/* reject */
3822                                 ast_verb(2, "core_id:%d %s CC request reject: %s\n", monitor->core_id,
3823                                         sig_pri_cc_type_name,
3824                                         pri_facility_reject2str(subcmd->u.cc_request_rsp.fail_code));
3825                                 ast_cc_monitor_failed(monitor->core_id, monitor->name,
3826                                         "%s CC request reject", sig_pri_cc_type_name);
3827                                 break;
3828                         default:
3829                                 ast_verb(2, "core_id:%d %s CC request unknown status %d\n",
3830                                         monitor->core_id, sig_pri_cc_type_name,
3831                                         subcmd->u.cc_request_rsp.status);
3832                                 ast_cc_monitor_failed(monitor->core_id, monitor->name,
3833                                         "%s CC request unknown status", sig_pri_cc_type_name);
3834                                 break;
3835                         }
3836                         ao2_ref(monitor, -1);
3837                         break;
3838 #endif  /* defined(HAVE_PRI_CCSS) */
3839 #if defined(HAVE_PRI_CCSS)
3840                 case PRI_SUBCMD_CC_REMOTE_USER_FREE:
3841                         monitor = sig_pri_find_cc_monitor_by_cc_id(pri,
3842                                 subcmd->u.cc_remote_user_free.cc_id);
3843                         if (!monitor) {
3844                                 pri_cc_cancel(pri->pri, subcmd->u.cc_remote_user_free.cc_id);
3845                                 break;
3846                         }
3847                         ast_cc_monitor_callee_available(monitor->core_id,