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
  50 #include "sig_pri.h"
  51 #ifndef PRI_EVENT_FACILITY
  52 #error please update libpri
  53 #endif
  54
  55 /* define this to send PRI user-user information elements */
  56 #undef SUPPORT_USERUSER
  57
  58 #if 0
  59 #define DEFAULT_PRI_DEBUG (PRI_DEBUG_Q931_DUMP | PRI_DEBUG_Q921_DUMP | PRI_DEBUG_Q921_RAW | PRI_DEBUG_Q921_STATE)
  60 #else
  61 #define DEFAULT_PRI_DEBUG 0
  62 #endif
  63
  64 static int pri_matchdigittimeout = 3000;
  65
  66 static int pri_gendigittimeout = 8000;
  67
  68 #define DCHAN_NOTINALARM  (1 << 0)
  69 #define DCHAN_UP          (1 << 1)
  70
  71 /* Defines to help decode the encoded event channel id. */
  72 #define PRI_CHANNEL(p)  ((p) & 0xff)
  73 #define PRI_SPAN(p)             (((p) >> 8) & 0xff)
  74 #define PRI_EXPLICIT    (1 << 16)
  75 #define PRI_CIS_CALL    (1 << 17)       /* Call is using the D channel only. */
  76 #define PRI_HELD_CALL   (1 << 18)
  77
  78
  79 #define DCHAN_AVAILABLE (DCHAN_NOTINALARM | DCHAN_UP)
  80
  81 #define PRI_DEADLOCK_AVOIDANCE(p) \
  82         do { \
  83                 sig_pri_unlock_private(p); \
  84                 usleep(1); \
  85                 sig_pri_lock_private(p); \
  86         } while (0)
  87
  88 static int pri_active_dchan_index(struct sig_pri_pri *pri);
  89
  90 static inline void pri_rel(struct sig_pri_pri *pri)
  91 {
  92         ast_mutex_unlock(&pri->lock);
  93 }
  94
  95 static unsigned int PVT_TO_CHANNEL(struct sig_pri_chan *p)
  96 {
  97         int res = (((p)->prioffset) | ((p)->logicalspan << 8) | (p->mastertrunkgroup ? PRI_EXPLICIT : 0));
  98         ast_debug(5, "prioffset: %d mastertrunkgroup: %d logicalspan: %d result: %d\n",
  99                 p->prioffset, p->mastertrunkgroup, p->logicalspan, res);
 100
 101         return res;
 102 }
 103
 104 static void sig_pri_handle_dchan_exception(struct sig_pri_pri *pri, int index)
 105 {
 106         if (pri->calls->handle_dchan_exception)
 107                 pri->calls->handle_dchan_exception(pri, index);
 108 }
 109
 110 static void sig_pri_set_dialing(struct sig_pri_chan *p, int flag)
 111 {
 112         if (p->calls->set_dialing)
 113                 p->calls->set_dialing(p->chan_pvt, flag);
 114 }
 115
 116 static void sig_pri_set_digital(struct sig_pri_chan *p, int flag)
 117 {
 118         p->digital = flag;
 119         if (p->calls->set_digital)
 120                 p->calls->set_digital(p->chan_pvt, flag);
 121 }
 122
 123 /*!
 124  * \internal
 125  * \brief Set the caller id information in the parent module.
 126  * \since 1.8
 127  *
 128  * \param p sig_pri channel structure.
 129  *
 130  * \return Nothing
 131  */
 132 static void sig_pri_set_caller_id(struct sig_pri_chan *p)
 133 {
 134         struct ast_party_caller caller;
 135
 136         if (p->calls->set_callerid) {
 137                 ast_party_caller_init(&caller);
 138                 caller.id.number = p->cid_num;
 139                 caller.id.name = p->cid_name;
 140                 if (!ast_strlen_zero(p->cid_subaddr)) {
 141                         caller.id.subaddress.valid = 1;
 142                         //caller.id.subaddress.type = 0;/* nsap */
 143                         //caller.id.subaddress.odd_even_indicator = 0;
 144                         caller.id.subaddress.str = p->cid_subaddr;
 145                 }
 146                 caller.id.number_type = p->cid_ton;
 147                 caller.id.number_presentation = p->callingpres;
 148                 caller.ani = p->cid_ani;
 149                 caller.ani2 = p->cid_ani2;
 150                 p->calls->set_callerid(p->chan_pvt, &caller);
 151         }
 152 }
 153
 154 /*!
 155  * \internal
 156  * \brief Set the Dialed Number Identifier.
 157  * \since 1.8
 158  *
 159  * \param p sig_pri channel structure.
 160  * \param dnid Dialed Number Identifier string.
 161  *
 162  * \return Nothing
 163  */
 164 static void sig_pri_set_dnid(struct sig_pri_chan *p, const char *dnid)
 165 {
 166         if (p->calls->set_dnid) {
 167                 p->calls->set_dnid(p->chan_pvt, dnid);
 168         }
 169 }
 170
 171 /*!
 172  * \internal
 173  * \brief Set the Redirecting Directory Number Information Service (RDNIS).
 174  * \since 1.8
 175  *
 176  * \param p sig_pri channel structure.
 177  * \param rdnis Redirecting Directory Number Information Service (RDNIS) string.
 178  *
 179  * \return Nothing
 180  */
 181 static void sig_pri_set_rdnis(struct sig_pri_chan *p, const char *rdnis)
 182 {
 183         if (p->calls->set_rdnis) {
 184                 p->calls->set_rdnis(p->chan_pvt, rdnis);
 185         }
 186 }
 187
 188 static void sig_pri_unlock_private(struct sig_pri_chan *p)
 189 {
 190         if (p->calls->unlock_private)
 191                 p->calls->unlock_private(p->chan_pvt);
 192 }
 193
 194 static void sig_pri_lock_private(struct sig_pri_chan *p)
 195 {
 196         if (p->calls->lock_private)
 197                 p->calls->lock_private(p->chan_pvt);
 198 }
 199
 200 static inline int pri_grab(struct sig_pri_chan *p, struct sig_pri_pri *pri)
 201 {
 202         int res;
 203         /* Grab the lock first */
 204         do {
 205                 res = ast_mutex_trylock(&pri->lock);
 206                 if (res) {
 207                         PRI_DEADLOCK_AVOIDANCE(p);
 208                 }
 209         } while (res);
 210         /* Then break the poll */
 211         pthread_kill(pri->master, SIGURG);
 212         return 0;
 213 }
 214
 215 /*!
 216  * \internal
 217  * \brief Convert PRI redirecting reason to asterisk version.
 218  * \since 1.8
 219  *
 220  * \param pri_reason PRI redirecting reason.
 221  *
 222  * \return Equivalent asterisk redirecting reason value.
 223  */
 224 static enum AST_REDIRECTING_REASON pri_to_ast_reason(int pri_reason)
 225 {
 226         enum AST_REDIRECTING_REASON ast_reason;
 227
 228         switch (pri_reason) {
 229         case PRI_REDIR_FORWARD_ON_BUSY:
 230                 ast_reason = AST_REDIRECTING_REASON_USER_BUSY;
 231                 break;
 232         case PRI_REDIR_FORWARD_ON_NO_REPLY:
 233                 ast_reason = AST_REDIRECTING_REASON_NO_ANSWER;
 234                 break;
 235         case PRI_REDIR_DEFLECTION:
 236                 ast_reason = AST_REDIRECTING_REASON_DEFLECTION;
 237                 break;
 238         case PRI_REDIR_UNCONDITIONAL:
 239                 ast_reason = AST_REDIRECTING_REASON_UNCONDITIONAL;
 240                 break;
 241         case PRI_REDIR_UNKNOWN:
 242         default:
 243                 ast_reason = AST_REDIRECTING_REASON_UNKNOWN;
 244                 break;
 245         }
 246
 247         return ast_reason;
 248 }
 249
 250 /*!
 251  * \internal
 252  * \brief Convert asterisk redirecting reason to PRI version.
 253  * \since 1.8
 254  *
 255  * \param ast_reason Asterisk redirecting reason.
 256  *
 257  * \return Equivalent PRI redirecting reason value.
 258  */
 259 static int ast_to_pri_reason(enum AST_REDIRECTING_REASON ast_reason)
 260 {
 261         int pri_reason;
 262
 263         switch (ast_reason) {
 264         case AST_REDIRECTING_REASON_USER_BUSY:
 265                 pri_reason = PRI_REDIR_FORWARD_ON_BUSY;
 266                 break;
 267         case AST_REDIRECTING_REASON_NO_ANSWER:
 268                 pri_reason = PRI_REDIR_FORWARD_ON_NO_REPLY;
 269                 break;
 270         case AST_REDIRECTING_REASON_UNCONDITIONAL:
 271                 pri_reason = PRI_REDIR_UNCONDITIONAL;
 272                 break;
 273         case AST_REDIRECTING_REASON_DEFLECTION:
 274                 pri_reason = PRI_REDIR_DEFLECTION;
 275                 break;
 276         case AST_REDIRECTING_REASON_UNKNOWN:
 277         default:
 278                 pri_reason = PRI_REDIR_UNKNOWN;
 279                 break;
 280         }
 281
 282         return pri_reason;
 283 }
 284
 285 /*!
 286  * \internal
 287  * \brief Convert PRI number presentation to asterisk version.
 288  * \since 1.8
 289  *
 290  * \param pri_presentation PRI number presentation.
 291  *
 292  * \return Equivalent asterisk number presentation value.
 293  */
 294 static int pri_to_ast_presentation(int pri_presentation)
 295 {
 296         int ast_presentation;
 297
 298         switch (pri_presentation) {
 299         case PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
 300                 ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
 301                 break;
 302         case PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
 303                 ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
 304                 break;
 305         case PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
 306                 ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN;
 307                 break;
 308         case PRES_ALLOWED_NETWORK_NUMBER:
 309                 ast_presentation = AST_PRES_ALLOWED_NETWORK_NUMBER;
 310                 break;
 311         case PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
 312                 ast_presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
 313                 break;
 314         case PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
 315                 ast_presentation = AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
 316                 break;
 317         case PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
 318                 ast_presentation = AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN;
 319                 break;
 320         case PRES_PROHIB_NETWORK_NUMBER:
 321                 ast_presentation = AST_PRES_PROHIB_NETWORK_NUMBER;
 322                 break;
 323         case PRES_NUMBER_NOT_AVAILABLE:
 324                 ast_presentation = AST_PRES_NUMBER_NOT_AVAILABLE;
 325                 break;
 326         default:
 327                 ast_presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
 328                 break;
 329         }
 330
 331         return ast_presentation;
 332 }
 333
 334 /*!
 335  * \internal
 336  * \brief Convert asterisk number presentation to PRI version.
 337  * \since 1.8
 338  *
 339  * \param ast_presentation Asterisk number presentation.
 340  *
 341  * \return Equivalent PRI number presentation value.
 342  */
 343 static int ast_to_pri_presentation(int ast_presentation)
 344 {
 345         int pri_presentation;
 346
 347         switch (ast_presentation) {
 348         case AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
 349                 pri_presentation = PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
 350                 break;
 351         case AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
 352                 pri_presentation = PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
 353                 break;
 354         case AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
 355                 pri_presentation = PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN;
 356                 break;
 357         case AST_PRES_ALLOWED_NETWORK_NUMBER:
 358                 pri_presentation = PRES_ALLOWED_NETWORK_NUMBER;
 359                 break;
 360         case AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
 361                 pri_presentation = PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
 362                 break;
 363         case AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
 364                 pri_presentation = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
 365                 break;
 366         case AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
 367                 pri_presentation = PRES_PROHIB_USER_NUMBER_FAILED_SCREEN;
 368                 break;
 369         case AST_PRES_PROHIB_NETWORK_NUMBER:
 370                 pri_presentation = PRES_PROHIB_NETWORK_NUMBER;
 371                 break;
 372         case AST_PRES_NUMBER_NOT_AVAILABLE:
 373                 pri_presentation = PRES_NUMBER_NOT_AVAILABLE;
 374                 break;
 375         default:
 376                 pri_presentation = PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
 377                 break;
 378         }
 379
 380         return pri_presentation;
 381 }
 382
 383 /*!
 384  * \internal
 385  * \brief Determine the overall presentation value for the given party.
 386  * \since 1.8
 387  *
 388  * \param id Party to determine the overall presentation value.
 389  *
 390  * \return Overall presentation value for the given party converted to ast values.
 391  */
 392 static int overall_ast_presentation(const struct pri_party_id *id)
 393 {
 394         int number_priority;
 395         int number_value;
 396         int number_screening;
 397         int name_priority;
 398         int name_value;
 399
 400         /* Determine name presentation priority. */
 401         if (!id->name.valid) {
 402                 name_value = PRI_PRES_UNAVAILABLE;
 403                 name_priority = 3;
 404         } else {
 405                 name_value = id->name.presentation & PRI_PRES_RESTRICTION;
 406                 switch (name_value) {
 407                 case PRI_PRES_RESTRICTED:
 408                         name_priority = 0;
 409                         break;
 410                 case PRI_PRES_ALLOWED:
 411                         name_priority = 1;
 412                         break;
 413                 case PRI_PRES_UNAVAILABLE:
 414                         name_priority = 2;
 415                         break;
 416                 default:
 417                         name_value = PRI_PRES_UNAVAILABLE;
 418                         name_priority = 3;
 419                         break;
 420                 }
 421         }
 422
 423         /* Determine number presentation priority. */
 424         if (!id->number.valid) {
 425                 number_screening = PRI_PRES_USER_NUMBER_UNSCREENED;
 426                 number_value = PRI_PRES_UNAVAILABLE;
 427                 number_priority = 3;
 428         } else {
 429                 number_screening = id->number.presentation & PRI_PRES_NUMBER_TYPE;
 430                 number_value = id->number.presentation & PRI_PRES_RESTRICTION;
 431                 switch (number_value) {
 432                 case PRI_PRES_RESTRICTED:
 433                         number_priority = 0;
 434                         break;
 435                 case PRI_PRES_ALLOWED:
 436                         number_priority = 1;
 437                         break;
 438                 case PRI_PRES_UNAVAILABLE:
 439                         number_priority = 2;
 440                         break;
 441                 default:
 442                         number_screening = PRI_PRES_USER_NUMBER_UNSCREENED;
 443                         number_value = PRI_PRES_UNAVAILABLE;
 444                         number_priority = 3;
 445                         break;
 446                 }
 447         }
 448
 449         /* Select the wining presentation value. */
 450         if (name_priority < number_priority) {
 451                 number_value = name_value;
 452         }
 453
 454         return pri_to_ast_presentation(number_value | number_screening);
 455 }
 456
 457 #if defined(HAVE_PRI_SUBADDR)
 458 /*!
 459  * \internal
 460  * \brief Fill in the asterisk party subaddress from the given PRI party subaddress.
 461  * \since 1.8
 462  *
 463  * \param ast_subaddress Asterisk party subaddress structure.
 464  * \param pri_subaddress PRI party subaddress structure.
 465  *
 466  * \return Nothing
 467  *
 468  */
 469 static void sig_pri_set_subaddress(struct ast_party_subaddress *ast_subaddress, const struct pri_party_subaddress *pri_subaddress)
 470 {
 471         char *cnum, *ptr;
 472         int x, len;
 473
 474         if (ast_subaddress->str) {
 475                 ast_free(ast_subaddress->str);
 476         }
 477         if (pri_subaddress->length <= 0) {
 478                 ast_party_subaddress_init(ast_subaddress);
 479                 return;
 480         }
 481
 482         if (!pri_subaddress->type) {
 483                 /* NSAP */
 484                 ast_subaddress->str = ast_strdup((char *) pri_subaddress->data);
 485         } else {
 486                 /* User Specified */
 487                 if (!(cnum = ast_malloc(2 * pri_subaddress->length + 1))) {
 488                         ast_party_subaddress_init(ast_subaddress);
 489                         return;
 490                 }
 491
 492                 ptr = cnum;
 493                 len = pri_subaddress->length - 1; /* -1 account for zero based indexing */
 494                 for (x = 0; x < len; ++x) {
 495                         ptr += sprintf(ptr, "%02x", pri_subaddress->data[x]);
 496                 }
 497
 498                 if (pri_subaddress->odd_even_indicator) {
 499                         /* ODD */
 500                         sprintf(ptr, "%01x", (pri_subaddress->data[len]) >> 4);
 501                 } else {
 502                         /* EVEN */
 503                         sprintf(ptr, "%02x", pri_subaddress->data[len]);
 504                 }
 505                 ast_subaddress->str = cnum;
 506         }
 507         ast_subaddress->type = pri_subaddress->type;
 508         ast_subaddress->odd_even_indicator = pri_subaddress->odd_even_indicator;
 509         ast_subaddress->valid = 1;
 510 }
 511 #endif  /* defined(HAVE_PRI_SUBADDR) */
 512
 513 #if defined(HAVE_PRI_SUBADDR)
 514 static unsigned char ast_pri_pack_hex_char(char c)
 515 {
 516         unsigned char res;
 517
 518         if (c < '0') {
 519                 res = 0;
 520         } else if (c < ('9' + 1)) {
 521                 res = c - '0';
 522         } else if (c < 'A') {
 523                 res = 0;
 524         } else if (c < ('F' + 1)) {
 525                 res = c - 'A' + 10;
 526         } else if (c < 'a') {
 527                 res = 0;
 528         } else if (c < ('f' + 1)) {
 529                 res = c - 'a' + 10;
 530         } else {
 531                 res = 0;
 532         }
 533         return res;
 534 }
 535 #endif  /* defined(HAVE_PRI_SUBADDR) */
 536
 537 #if defined(HAVE_PRI_SUBADDR)
 538 /*!
 539  * \internal
 540  * \brief Convert a null terminated hexadecimal string to a packed hex byte array.
 541  * \details left justified, with 0 padding if odd length.
 542  * \since 1.8
 543  *
 544  * \param dst pointer to packed byte array.
 545  * \param src pointer to null terminated hexadecimal string.
 546  * \param maxlen destination array size.
 547  *
 548  * \return Length of byte array
 549  *
 550  * \note The dst is not an ASCIIz string.
 551  * \note The src is an ASCIIz hex string.
 552  */
 553 static int ast_pri_pack_hex_string(unsigned char *dst, char *src, int maxlen)
 554 {
 555         int res = 0;
 556         int len = strlen(src);
 557
 558         if (len > (2 * maxlen)) {
 559                 len = 2 * maxlen;
 560         }
 561
 562         res = len / 2 + len % 2;
 563
 564         while (len > 1) {
 565                 *dst = ast_pri_pack_hex_char(*src) << 4;
 566                 src++;
 567                 *dst |= ast_pri_pack_hex_char(*src);
 568                 dst++, src++;
 569                 len -= 2;
 570         }
 571         if (len) { /* 1 left */
 572                 *dst = ast_pri_pack_hex_char(*src) << 4;
 573         }
 574         return res;
 575 }
 576 #endif  /* defined(HAVE_PRI_SUBADDR) */
 577
 578 #if defined(HAVE_PRI_SUBADDR)
 579 /*!
 580  * \internal
 581  * \brief Fill in the PRI party subaddress from the given asterisk party subaddress.
 582  * \since 1.8
 583  *
 584  * \param pri_subaddress PRI party subaddress structure.
 585  * \param ast_subaddress Asterisk party subaddress structure.
 586  *
 587  * \return Nothing
 588  *
 589  * \note Assumes that pri_subaddress has been previously memset to zero.
 590  */
 591 static void sig_pri_party_subaddress_from_ast(struct pri_party_subaddress *pri_subaddress, const struct ast_party_subaddress *ast_subaddress)
 592 {
 593         if (ast_subaddress->valid && !ast_strlen_zero(ast_subaddress->str)) {
 594                 pri_subaddress->type = ast_subaddress->type;
 595                 if (!ast_subaddress->type) {
 596                         /* 0 = NSAP */
 597                         ast_copy_string((char *) pri_subaddress->data, ast_subaddress->str,
 598                                 sizeof(pri_subaddress->data));
 599                         pri_subaddress->length = strlen((char *) pri_subaddress->data);
 600                         pri_subaddress->odd_even_indicator = 0;
 601                         pri_subaddress->valid = 1;
 602                 } else {
 603                         /* 2 = User Specified */
 604                         /*
 605                          * Copy HexString to packed HexData,
 606                          * if odd length then right pad trailing byte with 0
 607                          */
 608                         int length = ast_pri_pack_hex_string(pri_subaddress->data,
 609                                 ast_subaddress->str, sizeof(pri_subaddress->data));
 610
 611                         pri_subaddress->length = length;
 612                         pri_subaddress->odd_even_indicator = (length & 1);
 613                         pri_subaddress->valid = 1;
 614                 }
 615         }
 616 }
 617 #endif  /* defined(HAVE_PRI_SUBADDR) */
 618
 619 /*!
 620  * \internal
 621  * \brief Fill in the PRI party id from the given asterisk party id.
 622  * \since 1.8
 623  *
 624  * \param pri_id PRI party id structure.
 625  * \param ast_id Asterisk party id structure.
 626  *
 627  * \return Nothing
 628  *
 629  * \note Assumes that pri_id has been previously memset to zero.
 630  */
 631 static void sig_pri_party_id_from_ast(struct pri_party_id *pri_id, const struct ast_party_id *ast_id)
 632 {
 633         int presentation;
 634
 635         presentation = ast_to_pri_presentation(ast_id->number_presentation);
 636         if (!ast_strlen_zero(ast_id->name)) {
 637                 pri_id->name.valid = 1;
 638                 pri_id->name.presentation = presentation;
 639                 pri_id->name.char_set = PRI_CHAR_SET_ISO8859_1;
 640                 ast_copy_string(pri_id->name.str, ast_id->name, sizeof(pri_id->name.str));
 641         }
 642         if (!ast_strlen_zero(ast_id->number)) {
 643                 pri_id->number.valid = 1;
 644                 pri_id->number.presentation = presentation;
 645                 pri_id->number.plan = ast_id->number_type;
 646                 ast_copy_string(pri_id->number.str, ast_id->number, sizeof(pri_id->number.str));
 647         }
 648 #if defined(HAVE_PRI_SUBADDR)
 649         sig_pri_party_subaddress_from_ast(&pri_id->subaddress, &ast_id->subaddress);
 650 #endif  /* defined(HAVE_PRI_SUBADDR) */
 651 }
 652
 653 /*!
 654  * \internal
 655  * \brief Update the PRI redirecting information for the current call.
 656  * \since 1.8
 657  *
 658  * \param pvt sig_pri private channel structure.
 659  * \param ast Asterisk channel
 660  *
 661  * \return Nothing
 662  *
 663  * \note Assumes that the PRI lock is already obtained.
 664  */
 665 static void sig_pri_redirecting_update(struct sig_pri_chan *pvt, struct ast_channel *ast)
 666 {
 667         struct pri_party_redirecting pri_redirecting;
 668         struct ast_party_redirecting ast_redirecting;
 669
 670         /* Gather asterisk redirecting data */
 671         ast_redirecting = ast->redirecting;
 672         ast_redirecting.from.number = ast->cid.cid_rdnis;
 673
 674 /*! \todo XXX Original called data can be put in a channel data store that is inherited. */
 675
 676         memset(&pri_redirecting, 0, sizeof(pri_redirecting));
 677         sig_pri_party_id_from_ast(&pri_redirecting.from, &ast_redirecting.from);
 678         sig_pri_party_id_from_ast(&pri_redirecting.to, &ast_redirecting.to);
 679         pri_redirecting.count = ast_redirecting.count;
 680         pri_redirecting.reason = ast_to_pri_reason(ast_redirecting.reason);
 681
 682         pri_redirecting_update(pvt->pri->pri, pvt->call, &pri_redirecting);
 683 }
 684
 685 /*!
 686  * \internal
 687  * \brief Reset DTMF detector.
 688  * \since 1.8
 689  *
 690  * \param p sig_pri channel structure.
 691  *
 692  * \return Nothing
 693  */
 694 static void sig_pri_dsp_reset_and_flush_digits(struct sig_pri_chan *p)
 695 {
 696         if (p->calls->dsp_reset_and_flush_digits) {
 697                 p->calls->dsp_reset_and_flush_digits(p->chan_pvt);
 698         }
 699 }
 700
 701 static int sig_pri_set_echocanceller(struct sig_pri_chan *p, int enable)
 702 {
 703         if (p->calls->set_echocanceller)
 704                 return p->calls->set_echocanceller(p->chan_pvt, enable);
 705         else
 706                 return -1;
 707 }
 708
 709 static void sig_pri_fixup_chans(struct sig_pri_chan *old_chan, struct sig_pri_chan *new_chan)
 710 {
 711         if (old_chan->calls->fixup_chans)
 712                 old_chan->calls->fixup_chans(old_chan->chan_pvt, new_chan->chan_pvt);
 713 }
 714
 715 static int sig_pri_play_tone(struct sig_pri_chan *p, enum sig_pri_tone tone)
 716 {
 717         if (p->calls->play_tone)
 718                 return p->calls->play_tone(p->chan_pvt, tone);
 719         else
 720                 return -1;
 721 }
 722
 723 static struct ast_channel *sig_pri_new_ast_channel(struct sig_pri_chan *p, int state, int startpbx, int ulaw, int transfercapability, char *exten, const struct ast_channel *requestor)
 724 {
 725         struct ast_channel *c;
 726
 727         if (p->calls->new_ast_channel)
 728                 c = p->calls->new_ast_channel(p->chan_pvt, state, startpbx, ulaw, transfercapability, exten, requestor);
 729         else
 730                 return NULL;
 731
 732         if (!p->owner)
 733                 p->owner = c;
 734         p->isidlecall = 0;
 735         p->alreadyhungup = 0;
 736         if (transfercapability & AST_TRANS_CAP_DIGITAL) {
 737                 c->transfercapability = transfercapability;
 738                 pbx_builtin_setvar_helper(c, "TRANSFERCAPABILITY", ast_transfercapability2str(transfercapability));
 739                 sig_pri_set_digital(p, 1);
 740         }
 741
 742         return c;
 743 }
 744
 745 struct ast_channel *sig_pri_request(struct sig_pri_chan *p, enum sig_pri_law law, const struct ast_channel *requestor, int transfercapability)
 746 {
 747         struct ast_channel *ast;
 748
 749         ast_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel);
 750
 751         p->outgoing = 1;
 752         ast = sig_pri_new_ast_channel(p, AST_STATE_RESERVED, 0, law, transfercapability, p->exten, requestor);
 753         if (!ast) {
 754                 p->outgoing = 0;
 755         }
 756         return ast;
 757 }
 758
 759 int pri_is_up(struct sig_pri_pri *pri)
 760 {
 761         int x;
 762         for (x = 0; x < NUM_DCHANS; x++) {
 763                 if (pri->dchanavail[x] == DCHAN_AVAILABLE)
 764                         return 1;
 765         }
 766         return 0;
 767 }
 768
 769 static char *pri_order(int level)
 770 {
 771         switch (level) {
 772         case 0:
 773                 return "Primary";
 774         case 1:
 775                 return "Secondary";
 776         case 2:
 777                 return "Tertiary";
 778         case 3:
 779                 return "Quaternary";
 780         default:
 781                 return "<Unknown>";
 782         }
 783 }
 784
 785 /* Returns index of the active dchan */
 786 static int pri_active_dchan_index(struct sig_pri_pri *pri)
 787 {
 788         int x;
 789
 790         for (x = 0; x < NUM_DCHANS; x++) {
 791                 if ((pri->dchans[x] == pri->pri))
 792                         return x;
 793         }
 794
 795         ast_log(LOG_WARNING, "No active dchan found!\n");
 796         return -1;
 797 }
 798
 799 static int pri_find_dchan(struct sig_pri_pri *pri)
 800 {
 801         int oldslot = -1;
 802         struct pri *old;
 803         int newslot = -1;
 804         int x;
 805         old = pri->pri;
 806         for (x = 0; x < NUM_DCHANS; x++) {
 807                 if ((pri->dchanavail[x] == DCHAN_AVAILABLE) && (newslot < 0))
 808                         newslot = x;
 809                 if (pri->dchans[x] == old) {
 810                         oldslot = x;
 811                 }
 812         }
 813         if (newslot < 0) {
 814                 newslot = 0;
 815                 /* This is annoying to see on non persistent layer 2 connections.  Let's not complain in that case */
 816                 if (pri->sig != SIG_BRI_PTMP) {
 817                         ast_log(LOG_WARNING, "No D-channels available!  Using Primary channel as D-channel anyway!\n");
 818                 }
 819         }
 820         if (old && (oldslot != newslot))
 821                 ast_log(LOG_NOTICE, "Switching from d-channel fd %d to fd %d!\n",
 822                         pri->fds[oldslot], pri->fds[newslot]);
 823         pri->pri = pri->dchans[newslot];
 824         return 0;
 825 }
 826
 827 static void pri_queue_frame(struct sig_pri_chan *p, struct ast_frame *f, struct sig_pri_pri *pri)
 828 {
 829         /* We must unlock the PRI to avoid the possibility of a deadlock */
 830         if (pri)
 831                 ast_mutex_unlock(&pri->lock);
 832         for (;;) {
 833                 if (p->owner) {
 834                         if (ast_channel_trylock(p->owner)) {
 835                                 PRI_DEADLOCK_AVOIDANCE(p);
 836                         } else {
 837                                 ast_queue_frame(p->owner, f);
 838                                 ast_channel_unlock(p->owner);
 839                                 break;
 840                         }
 841                 } else
 842                         break;
 843         }
 844         if (pri)
 845                 ast_mutex_lock(&pri->lock);
 846 }
 847
 848 static void pri_queue_control(struct sig_pri_chan *p, int subclass, struct sig_pri_pri *pri)
 849 {
 850         struct ast_frame f = {AST_FRAME_CONTROL, };
 851
 852         if (p->calls->queue_control) {
 853                 p->calls->queue_control(p->chan_pvt, subclass);
 854         }
 855
 856         f.subclass.integer = subclass;
 857         pri_queue_frame(p, &f, pri);
 858 }
 859
 860 static int pri_find_principle(struct sig_pri_pri *pri, int channel, q931_call *call)
 861 {
 862         int x;
 863         int span;
 864         int principle;
 865
 866         if (channel < 0) {
 867                 /* Channel is not picked yet. */
 868                 return -1;
 869         }
 870
 871         if (channel & PRI_HELD_CALL) {
 872                 if (!call) {
 873                         /* Cannot find a held call without a call. */
 874                         return -1;
 875                 }
 876                 principle = -1;
 877                 for (x = 0; x < pri->numchans; ++x) {
 878                         if (pri->pvts[x]
 879                                 && pri->pvts[x]->call == call) {
 880                                 principle = x;
 881                                 break;
 882                         }
 883                 }
 884                 return principle;
 885         }
 886
 887         span = PRI_SPAN(channel);
 888         if (!(channel & PRI_EXPLICIT)) {
 889                 int index;
 890
 891                 index = pri_active_dchan_index(pri);
 892                 if (index == -1) {
 893                         return -1;
 894                 }
 895                 span = pri->dchan_logical_span[index];
 896         }
 897
 898         channel = PRI_CHANNEL(channel);
 899         principle = -1;
 900         for (x = 0; x < pri->numchans; x++) {
 901                 if (pri->pvts[x]
 902                         && pri->pvts[x]->prioffset == channel
 903                         && pri->pvts[x]->logicalspan == span
 904                         && !pri->pvts[x]->no_b_channel) {
 905                         principle = x;
 906                         break;
 907                 }
 908         }
 909
 910         return principle;
 911 }
 912
 913 static int pri_fixup_principle(struct sig_pri_pri *pri, int principle, q931_call *call)
 914 {
 915         int x;
 916
 917         if (principle < 0 || pri->numchans <= principle) {
 918                 /* Out of rannge */
 919                 return -1;
 920         }
 921         if (!call) {
 922                 /* No call */
 923                 return principle;
 924         }
 925         if (pri->pvts[principle] && pri->pvts[principle]->call == call) {
 926                 /* Call is already on the specified principle. */
 927                 return principle;
 928         }
 929
 930         /* Find the old principle location. */
 931         for (x = 0; x < pri->numchans; x++) {
 932                 struct sig_pri_chan *new_chan;
 933                 struct sig_pri_chan *old_chan;
 934
 935                 if (!pri->pvts[x] || pri->pvts[x]->call != call) {
 936                         continue;
 937                 }
 938
 939                 /* Found our call */
 940                 new_chan = pri->pvts[principle];
 941                 old_chan = pri->pvts[x];
 942
 943                 ast_verb(3, "Moving call from channel %d to channel %d\n",
 944                         old_chan->channel, new_chan->channel);
 945                 if (new_chan->owner) {
 946                         ast_log(LOG_WARNING,
 947                                 "Can't fix up channel from %d to %d because %d is already in use\n",
 948                                 old_chan->channel, new_chan->channel, new_chan->channel);
 949                         return -1;
 950                 }
 951
 952                 sig_pri_fixup_chans(old_chan, new_chan);
 953
 954                 /* Fix it all up now */
 955                 new_chan->owner = old_chan->owner;
 956                 old_chan->owner = NULL;
 957
 958                 new_chan->call = old_chan->call;
 959                 old_chan->call = NULL;
 960
 961                 /* Transfer flags from the old channel. */
 962                 new_chan->alerting = old_chan->alerting;
 963                 new_chan->alreadyhungup = old_chan->alreadyhungup;
 964                 new_chan->isidlecall = old_chan->isidlecall;
 965                 new_chan->proceeding = old_chan->proceeding;
 966                 new_chan->progress = old_chan->progress;
 967                 new_chan->setup_ack = old_chan->setup_ack;
 968                 new_chan->outgoing = old_chan->outgoing;
 969                 new_chan->digital = old_chan->digital;
 970                 old_chan->alerting = 0;
 971                 old_chan->alreadyhungup = 0;
 972                 old_chan->isidlecall = 0;
 973                 old_chan->proceeding = 0;
 974                 old_chan->progress = 0;
 975                 old_chan->setup_ack = 0;
 976                 old_chan->outgoing = 0;
 977                 old_chan->digital = 0;
 978
 979                 /* More stuff to transfer to the new channel. */
 980 #if defined(HAVE_PRI_REVERSE_CHARGE)
 981                 new_chan->reverse_charging_indication = old_chan->reverse_charging_indication;
 982 #endif  /* defined(HAVE_PRI_REVERSE_CHARGE) */
 983 #if defined(HAVE_PRI_SETUP_KEYPAD)
 984                 strcpy(new_chan->keypad_digits, old_chan->keypad_digits);
 985 #endif  /* defined(HAVE_PRI_SETUP_KEYPAD) */
 986
 987                 if (new_chan->no_b_channel) {
 988                         /* Copy the real channel configuration to the no B channel interface. */
 989                         new_chan->hidecallerid = old_chan->hidecallerid;
 990                         new_chan->hidecalleridname = old_chan->hidecalleridname;
 991                         new_chan->immediate = old_chan->immediate;
 992                         new_chan->priexclusive = old_chan->priexclusive;
 993                         new_chan->priindication_oob = old_chan->priindication_oob;
 994                         new_chan->use_callerid = old_chan->use_callerid;
 995                         new_chan->use_callingpres = old_chan->use_callingpres;
 996                         new_chan->stripmsd = old_chan->stripmsd;
 997                         strcpy(new_chan->context, old_chan->context);
 998                         strcpy(new_chan->mohinterpret, old_chan->mohinterpret);
 999
1000                         /* Become a member of the old channel span/trunk-group. */
1001                         new_chan->logicalspan = old_chan->logicalspan;
1002                         new_chan->mastertrunkgroup = old_chan->mastertrunkgroup;
1003                 }
1004
1005                 return principle;
1006         }
1007         ast_log(LOG_WARNING, "Call specified, but not found?\n");
1008         return -1;
1009 }
1010
1011 static char * redirectingreason2str(int redirectingreason)
1012 {
1013         switch (redirectingreason) {
1014         case 0:
1015                 return "UNKNOWN";
1016         case 1:
1017                 return "BUSY";
1018         case 2:
1019                 return "NO_REPLY";
1020         case 0xF:
1021                 return "UNCONDITIONAL";
1022         default:
1023                 return "NOREDIRECT";
1024         }
1025 }
1026
1027 static char *dialplan2str(int dialplan)
1028 {
1029         if (dialplan == -1) {
1030                 return("Dynamically set dialplan in ISDN");
1031         }
1032         return (pri_plan2str(dialplan));
1033 }
1034
1035 static void apply_plan_to_number(char *buf, size_t size, const struct sig_pri_pri *pri, const char *number, const int plan)
1036 {
1037         switch (plan) {
1038         case PRI_INTERNATIONAL_ISDN:            /* Q.931 dialplan == 0x11 international dialplan => prepend international prefix digits */
1039                 snprintf(buf, size, "%s%s", pri->internationalprefix, number);
1040                 break;
1041         case PRI_NATIONAL_ISDN:                 /* Q.931 dialplan == 0x21 national dialplan => prepend national prefix digits */
1042                 snprintf(buf, size, "%s%s", pri->nationalprefix, number);
1043                 break;
1044         case PRI_LOCAL_ISDN:                    /* Q.931 dialplan == 0x41 local dialplan => prepend local prefix digits */
1045                 snprintf(buf, size, "%s%s", pri->localprefix, number);
1046                 break;
1047         case PRI_PRIVATE:                       /* Q.931 dialplan == 0x49 private dialplan => prepend private prefix digits */
1048                 snprintf(buf, size, "%s%s", pri->privateprefix, number);
1049                 break;
1050         case PRI_UNKNOWN:                       /* Q.931 dialplan == 0x00 unknown dialplan => prepend unknown prefix digits */
1051                 snprintf(buf, size, "%s%s", pri->unknownprefix, number);
1052                 break;
1053         default:                                /* other Q.931 dialplan => don't twiddle with callingnum */
1054                 snprintf(buf, size, "%s", number);
1055                 break;
1056         }
1057 }
1058
1059 /*! \note Assumes the pri->lock is already obtained. */
1060 static int pri_check_restart(struct sig_pri_pri *pri)
1061 {
1062 #ifdef HAVE_PRI_SERVICE_MESSAGES
1063 tryanotherpos:
1064 #endif
1065         do {
1066                 pri->resetpos++;
1067         } while (pri->resetpos < pri->numchans
1068                 && (!pri->pvts[pri->resetpos]
1069                         || pri->pvts[pri->resetpos]->no_b_channel
1070                         || pri->pvts[pri->resetpos]->call
1071                         || pri->pvts[pri->resetpos]->resetting));
1072         if (pri->resetpos < pri->numchans) {
1073 #ifdef HAVE_PRI_SERVICE_MESSAGES
1074                 char db_chan_name[20], db_answer[5], state;
1075                 int why;
1076
1077                 /* check if the channel is out of service */
1078                 snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->span, pri->pvts[pri->resetpos]->channel);
1079
1080                 /* if so, try next channel */
1081                 if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) {
1082                         sscanf(db_answer, "%1c:%30d", &state, &why);
1083                         if (why) {
1084                                 ast_log(LOG_NOTICE, "span '%d' channel '%d' out-of-service (reason: %s), not sending RESTART\n", pri->span,
1085                                         pri->pvts[pri->resetpos]->channel, (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end");
1086                                 goto tryanotherpos;
1087                         }
1088                 }
1089 #endif
1090
1091                 /* Mark the channel as resetting and restart it */
1092                 pri->pvts[pri->resetpos]->resetting = 1;
1093                 pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[pri->resetpos]));
1094         } else {
1095                 pri->resetting = 0;
1096                 time(&pri->lastreset);
1097         }
1098         return 0;
1099 }
1100
1101 static int pri_find_empty_chan(struct sig_pri_pri *pri, int backwards)
1102 {
1103         int x;
1104         if (backwards)
1105                 x = pri->numchans;
1106         else
1107                 x = 0;
1108         for (;;) {
1109                 if (backwards && (x < 0))
1110                         break;
1111                 if (!backwards && (x >= pri->numchans))
1112                         break;
1113                 if (pri->pvts[x]
1114                         && !pri->pvts[x]->no_b_channel
1115                         && !pri->pvts[x]->inalarm
1116                         && !pri->pvts[x]->owner) {
1117                         ast_debug(1, "Found empty available channel %d/%d\n",
1118                                 pri->pvts[x]->logicalspan, pri->pvts[x]->prioffset);
1119                         return x;
1120                 }
1121                 if (backwards)
1122                         x--;
1123                 else
1124                         x++;
1125         }
1126         return -1;
1127 }
1128
1129 #if defined(HAVE_PRI_CALL_HOLD)
1130 /*!
1131  * \internal
1132  * \brief Find or create an empty no-B-channel interface to use.
1133  * \since 1.8
1134  *
1135  * \param pri sig_pri span controller to find interface.
1136  *
1137  * \note Assumes the pri->lock is already obtained.
1138  *
1139  * \retval array-index into private pointer array on success.
1140  * \retval -1 on error.
1141  */
1142 static int pri_find_empty_nobch(struct sig_pri_pri *pri)
1143 {
1144         int idx;
1145
1146         for (idx = 0; idx < pri->numchans; ++idx) {
1147                 if (pri->pvts[idx]
1148                         && pri->pvts[idx]->no_b_channel
1149                         && !pri->pvts[idx]->inalarm
1150                         && !pri->pvts[idx]->owner) {
1151                         ast_debug(1, "Found empty available no B channel interface\n");
1152                         return idx;
1153                 }
1154         }
1155
1156         /* Need to create a new interface. */
1157         if (pri->calls->new_nobch_intf) {
1158                 idx = pri->calls->new_nobch_intf(pri);
1159         } else {
1160                 idx = -1;
1161         }
1162         return idx;
1163 }
1164 #endif  /* defined(HAVE_PRI_CALL_HOLD) */
1165
1166 #if defined(HAVE_PRI_CALL_HOLD)
1167 /*!
1168  * \internal
1169  * \brief Find the channel associated with the libpri call.
1170  * \since 1.8
1171  *
1172  * \param pri sig_pri span controller to find interface.
1173  * \param call LibPRI opaque call pointer to find.
1174  *
1175  * \note Assumes the pri->lock is already obtained.
1176  *
1177  * \retval array-index into private pointer array on success.
1178  * \retval -1 on error.
1179  */
1180 static int pri_find_pri_call(struct sig_pri_pri *pri, q931_call *call)
1181 {
1182         int idx;
1183
1184         for (idx = 0; idx < pri->numchans; ++idx) {
1185                 if (pri->pvts[idx] && pri->pvts[idx]->call == call) {
1186                         /* Found the channel */
1187                         return idx;
1188                 }
1189         }
1190         return -1;
1191 }
1192 #endif  /* defined(HAVE_PRI_CALL_HOLD) */
1193
1194 static void *do_idle_thread(void *vchan)
1195 {
1196         struct ast_channel *chan = vchan;
1197         struct sig_pri_chan *pvt = chan->tech_pvt;
1198         struct ast_frame *f;
1199         char ex[80];
1200         /* Wait up to 30 seconds for an answer */
1201         int newms, ms = 30000;
1202         ast_verb(3, "Initiating idle call on channel %s\n", chan->name);
1203         snprintf(ex, sizeof(ex), "%d/%s", pvt->channel, pvt->pri->idledial);
1204         if (ast_call(chan, ex, 0)) {
1205                 ast_log(LOG_WARNING, "Idle dial failed on '%s' to '%s'\n", chan->name, ex);
1206                 ast_hangup(chan);
1207                 return NULL;
1208         }
1209         while ((newms = ast_waitfor(chan, ms)) > 0) {
1210                 f = ast_read(chan);
1211                 if (!f) {
1212                         /* Got hangup */
1213                         break;
1214                 }
1215                 if (f->frametype == AST_FRAME_CONTROL) {
1216                         switch (f->subclass.integer) {
1217                         case AST_CONTROL_ANSWER:
1218                                 /* Launch the PBX */
1219                                 ast_copy_string(chan->exten, pvt->pri->idleext, sizeof(chan->exten));
1220                                 ast_copy_string(chan->context, pvt->pri->idlecontext, sizeof(chan->context));
1221                                 chan->priority = 1;
1222                                 ast_verb(4, "Idle channel '%s' answered, sending to %s@%s\n", chan->name, chan->exten, chan->context);
1223                                 ast_pbx_run(chan);
1224                                 /* It's already hungup, return immediately */
1225                                 return NULL;
1226                         case AST_CONTROL_BUSY:
1227                                 ast_verb(4, "Idle channel '%s' busy, waiting...\n", chan->name);
1228                                 break;
1229                         case AST_CONTROL_CONGESTION:
1230                                 ast_verb(4, "Idle channel '%s' congested, waiting...\n", chan->name);
1231                                 break;
1232                         };
1233                 }
1234                 ast_frfree(f);
1235                 ms = newms;
1236         }
1237         /* Hangup the channel since nothing happend */
1238         ast_hangup(chan);
1239         return NULL;
1240 }
1241
1242 static void *pri_ss_thread(void *data)
1243 {
1244         struct sig_pri_chan *p = data;
1245         struct ast_channel *chan = p->owner;
1246         char exten[AST_MAX_EXTENSION];
1247         int res;
1248         int len;
1249         int timeout;
1250
1251         if (!chan) {
1252                 /* We lost the owner before we could get started. */
1253                 return NULL;
1254         }
1255
1256         /*
1257          * In the bizarre case where the channel has become a zombie before we
1258          * even get started here, abort safely.
1259          */
1260         if (!chan->tech_pvt) {
1261                 ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", chan->name);
1262                 ast_hangup(chan);
1263                 return NULL;
1264         }
1265
1266         ast_verb(3, "Starting simple switch on '%s'\n", chan->name);
1267
1268         sig_pri_dsp_reset_and_flush_digits(p);
1269
1270         /* Now loop looking for an extension */
1271         ast_copy_string(exten, p->exten, sizeof(exten));
1272         len = strlen(exten);
1273         res = 0;
1274         while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
1275                 if (len && !ast_ignore_pattern(chan->context, exten))
1276                         sig_pri_play_tone(p, -1);
1277                 else
1278                         sig_pri_play_tone(p, SIG_PRI_TONE_DIALTONE);
1279                 if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num))
1280                         timeout = pri_matchdigittimeout;
1281                 else
1282                         timeout = pri_gendigittimeout;
1283                 res = ast_waitfordigit(chan, timeout);
1284                 if (res < 0) {
1285                         ast_log(LOG_DEBUG, "waitfordigit returned < 0...\n");
1286                         ast_hangup(chan);
1287                         return NULL;
1288                 } else if (res) {
1289                         exten[len++] = res;
1290                         exten[len] = '\0';
1291                 } else
1292                         goto exit;
1293         }
1294         /* if no extension was received ('unspecified') on overlap call, use the 's' extension */
1295         if (ast_strlen_zero(exten)) {
1296                 ast_verb(3, "Going to extension s|1 because of empty extension received on overlap call\n");
1297                 exten[0] = 's';
1298                 exten[1] = '\0';
1299         } else {
1300                 if (chan->cid.cid_dnid) {
1301                         ast_free(chan->cid.cid_dnid);
1302                 }
1303                 chan->cid.cid_dnid = ast_strdup(exten);
1304         }
1305         sig_pri_play_tone(p, -1);
1306         if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) {
1307                 /* Start the real PBX */
1308                 ast_copy_string(chan->exten, exten, sizeof(chan->exten));
1309                 sig_pri_dsp_reset_and_flush_digits(p);
1310                 sig_pri_set_echocanceller(p, 1);
1311                 ast_setstate(chan, AST_STATE_RING);
1312                 res = ast_pbx_run(chan);
1313                 if (res) {
1314                         ast_log(LOG_WARNING, "PBX exited non-zero!\n");
1315                 }
1316         } else {
1317                 ast_log(LOG_DEBUG, "No such possible extension '%s' in context '%s'\n", exten, chan->context);
1318                 chan->hangupcause = AST_CAUSE_UNALLOCATED;
1319                 ast_hangup(chan);
1320                 p->exten[0] = '\0';
1321                 /* Since we send release complete here, we won't get one */
1322                 p->call = NULL;
1323         }
1324         return NULL;
1325
1326 exit:
1327         res = sig_pri_play_tone(p, SIG_PRI_TONE_CONGESTION);
1328         if (res < 0)
1329                 ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel);
1330         ast_hangup(chan);
1331         return NULL;
1332 }
1333
1334 void pri_event_alarm(struct sig_pri_pri *pri, int index, int before_start_pri)
1335 {
1336         pri->dchanavail[index] &= ~(DCHAN_NOTINALARM | DCHAN_UP);
1337         if (!before_start_pri)
1338                 pri_find_dchan(pri);
1339 }
1340
1341 void pri_event_noalarm(struct sig_pri_pri *pri, int index, int before_start_pri)
1342 {
1343         pri->dchanavail[index] |= DCHAN_NOTINALARM;
1344         if (!before_start_pri)
1345                 pri_restart(pri->dchans[index]);
1346 }
1347
1348 /*!
1349  * \internal
1350  * \brief Convert libpri party id into asterisk party id.
1351  * \since 1.8
1352  *
1353  * \param ast_id Asterisk party id structure to fill.  Must already be set initialized.
1354  * \param pri_id libpri party id structure containing source information.
1355  * \param pri Span controlling structure.
1356  *
1357  * \note The filled in ast_id structure needs to be destroyed by
1358  * ast_party_id_free() when it is no longer needed.
1359  *
1360  * \return Nothing
1361  */
1362 static void sig_pri_party_id_convert(struct ast_party_id *ast_id,
1363         const struct pri_party_id *pri_id, struct sig_pri_pri *pri)
1364 {
1365         char number[AST_MAX_EXTENSION];
1366
1367         if (pri_id->name.valid) {
1368                 ast_id->name = ast_strdup(pri_id->name.str);
1369         }
1370         if (pri_id->number.valid) {
1371                 apply_plan_to_number(number, sizeof(number), pri, pri_id->number.str,
1372                         pri_id->number.plan);
1373                 ast_id->number = ast_strdup(number);
1374                 ast_id->number_type = pri_id->number.plan;
1375         }
1376         if (pri_id->name.valid || pri_id->number.valid) {
1377                 ast_id->number_presentation = overall_ast_presentation(pri_id);
1378         }
1379 #if defined(HAVE_PRI_SUBADDR)
1380         if (pri_id->subaddress.valid) {
1381                 sig_pri_set_subaddress(&ast_id->subaddress, &pri_id->subaddress);
1382         }
1383 #endif  /* defined(HAVE_PRI_SUBADDR) */
1384 }
1385
1386 /*!
1387  * \internal
1388  * \brief Convert libpri redirecting information into asterisk redirecting information.
1389  * \since 1.8
1390  *
1391  * \param ast_redirecting Asterisk redirecting structure to fill.
1392  * \param pri_redirecting libpri redirecting structure containing source information.
1393  * \param ast_guide Asterisk redirecting structure to use as an initialization guide.
1394  * \param pri Span controlling structure.
1395  *
1396  * \note The filled in ast_redirecting structure needs to be destroyed by
1397  * ast_party_redirecting_free() when it is no longer needed.
1398  *
1399  * \return Nothing
1400  */
1401 static void sig_pri_redirecting_convert(struct ast_party_redirecting *ast_redirecting,
1402         const struct pri_party_redirecting *pri_redirecting,
1403         const struct ast_party_redirecting *ast_guide,
1404         struct sig_pri_pri *pri)
1405 {
1406         ast_party_redirecting_set_init(ast_redirecting, ast_guide);
1407
1408         sig_pri_party_id_convert(&ast_redirecting->from, &pri_redirecting->from, pri);
1409         sig_pri_party_id_convert(&ast_redirecting->to, &pri_redirecting->to, pri);
1410         ast_redirecting->count = pri_redirecting->count;
1411         ast_redirecting->reason = pri_to_ast_reason(pri_redirecting->reason);
1412 }
1413
1414 /*!
1415  * \internal
1416  * \brief Determine if the given extension matches one of the MSNs in the pattern list.
1417  * \since 1.8
1418  *
1419  * \param msn_patterns Comma separated list of MSN patterns to match.
1420  * \param exten Extension to match in the MSN list.
1421  *
1422  * \retval 1 if matches.
1423  * \retval 0 if no match.
1424  */
1425 static int sig_pri_msn_match(const char *msn_patterns, const char *exten)
1426 {
1427         char *pattern;
1428         char *msn_list;
1429         char *list_tail;
1430
1431         msn_list = strdupa(msn_patterns);
1432
1433         list_tail = NULL;
1434         pattern = strtok_r(msn_list, ",", &list_tail);
1435         while (pattern) {
1436                 pattern = ast_strip(pattern);
1437                 if (!ast_strlen_zero(pattern) && ast_extension_match(pattern, exten)) {
1438                         /* Extension matched the pattern. */
1439                         return 1;
1440                 }
1441                 pattern = strtok_r(NULL, ",", &list_tail);
1442         }
1443         /* Did not match any pattern in the list. */
1444         return 0;
1445 }
1446
1447 /*!
1448  * \internal
1449  * \brief Obtain the sig_pri owner channel lock if the owner exists.
1450  * \since 1.8
1451  *
1452  * \param pri sig_pri PRI control structure.
1453  * \param chanpos Channel position in the span.
1454  *
1455  * \note Assumes the pri->lock is already obtained.
1456  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
1457  *
1458  * \return Nothing
1459  */
1460 static void sig_pri_lock_owner(struct sig_pri_pri *pri, int chanpos)
1461 {
1462         for (;;) {
1463                 if (!pri->pvts[chanpos]->owner) {
1464                         /* There is no owner lock to get. */
1465                         break;
1466                 }
1467                 if (!ast_channel_trylock(pri->pvts[chanpos]->owner)) {
1468                         /* We got the lock */
1469                         break;
1470                 }
1471                 /* We must unlock the PRI to avoid the possibility of a deadlock */
1472                 ast_mutex_unlock(&pri->lock);
1473                 PRI_DEADLOCK_AVOIDANCE(pri->pvts[chanpos]);
1474                 ast_mutex_lock(&pri->lock);
1475         }
1476 }
1477
1478 /*!
1479  * \internal
1480  * \brief Handle the call associated PRI subcommand events.
1481  * \since 1.8
1482  *
1483  * \param pri sig_pri PRI control structure.
1484  * \param chanpos Channel position in the span.
1485  * \param event_id PRI event id
1486  * \param channel PRI encoded span/channel
1487  * \param subcmds Subcommands to process if any. (Could be NULL).
1488  * \param call_rsp libpri opaque call structure to send any responses toward.
1489  * Could be NULL either because it is not available or the call is for the
1490  * dummy call reference.  However, this should not be NULL in the cases that
1491  * need to use the pointer to send a response message back.
1492  *
1493  * \note Assumes the pri->lock is already obtained.
1494  * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
1495  *
1496  * \return Nothing
1497  */
1498 static void sig_pri_handle_subcmds(struct sig_pri_pri *pri, int chanpos, int event_id,
1499         int channel, const struct pri_subcommands *subcmds, q931_call *call_rsp)
1500 {
1501         int index;
1502         struct ast_channel *owner;
1503         struct ast_party_redirecting ast_redirecting;
1504
1505         if (!subcmds) {
1506                 return;
1507         }
1508         for (index = 0; index < subcmds->counter_subcmd; ++index) {
1509                 const struct pri_subcommand *subcmd = &subcmds->subcmd[index];
1510
1511                 switch (subcmd->cmd) {
1512                 case PRI_SUBCMD_CONNECTED_LINE:
1513                         sig_pri_lock_owner(pri, chanpos);
1514                         owner = pri->pvts[chanpos]->owner;
1515                         if (owner) {
1516                                 struct ast_party_connected_line ast_connected;
1517                                 int caller_id_update;
1518
1519                                 /* Extract the connected line information */
1520                                 ast_party_connected_line_init(&ast_connected);
1521                                 sig_pri_party_id_convert(&ast_connected.id, &subcmd->u.connected_line.id,
1522                                         pri);
1523
1524                                 caller_id_update = 0;
1525                                 if (ast_connected.id.name) {
1526                                         /* Save name for Caller-ID update */
1527                                         ast_copy_string(pri->pvts[chanpos]->cid_name,
1528                                                 ast_connected.id.name, sizeof(pri->pvts[chanpos]->cid_name));
1529                                         caller_id_update = 1;
1530                                 }
1531                                 if (ast_connected.id.number) {
1532                                         /* Save number for Caller-ID update */
1533                                         ast_copy_string(pri->pvts[chanpos]->cid_num, ast_connected.id.number,
1534                                                 sizeof(pri->pvts[chanpos]->cid_num));
1535                                         pri->pvts[chanpos]->cid_ton = ast_connected.id.number_type;
1536                                         caller_id_update = 1;
1537                                 } else {
1538                                         ast_connected.id.number = ast_strdup("");
1539                                 }
1540                                 ast_connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
1541
1542                                 pri->pvts[chanpos]->cid_subaddr[0] = '\0';
1543 #if defined(HAVE_PRI_SUBADDR)
1544                                 if (ast_connected.id.subaddress.valid) {
1545                                         ast_party_subaddress_set(&owner->cid.subaddress,
1546                                                 &ast_connected.id.subaddress);
1547                                         if (ast_connected.id.subaddress.str) {
1548                                                 ast_copy_string(pri->pvts[chanpos]->cid_subaddr,
1549                                                         ast_connected.id.subaddress.str,
1550                                                         sizeof(pri->pvts[chanpos]->cid_subaddr));
1551                                         }
1552                                 }
1553 #endif  /* defined(HAVE_PRI_SUBADDR) */
1554                                 if (caller_id_update) {
1555                                         pri->pvts[chanpos]->callingpres =
1556                                                 ast_connected.id.number_presentation;
1557                                         sig_pri_set_caller_id(pri->pvts[chanpos]);
1558                                         ast_set_callerid(owner, S_OR(ast_connected.id.number, NULL),
1559                                                 S_OR(ast_connected.id.name, NULL),
1560                                                 S_OR(ast_connected.id.number, NULL));
1561                                 }
1562
1563                                 /* Update the connected line information on the other channel */
1564                                 if (event_id != PRI_EVENT_RING) {
1565                                         /* This connected_line update was not from a SETUP message. */
1566                                         ast_channel_queue_connected_line_update(owner, &ast_connected);
1567                                 }
1568
1569                                 ast_party_connected_line_free(&ast_connected);
1570                                 ast_channel_unlock(owner);
1571                         }
1572                         break;
1573                 case PRI_SUBCMD_REDIRECTING:
1574                         sig_pri_lock_owner(pri, chanpos);
1575                         owner = pri->pvts[chanpos]->owner;
1576                         if (owner) {
1577                                 sig_pri_redirecting_convert(&ast_redirecting, &subcmd->u.redirecting,
1578                                         &owner->redirecting, pri);
1579
1580 /*! \todo XXX Original called data can be put in a channel data store that is inherited. */
1581
1582                                 ast_channel_set_redirecting(owner, &ast_redirecting);
1583                                 if (event_id != PRI_EVENT_RING) {
1584                                         /* This redirection was not from a SETUP message. */
1585                                         ast_channel_queue_redirecting_update(owner, &ast_redirecting);
1586                                 }
1587                                 ast_party_redirecting_free(&ast_redirecting);
1588
1589                                 ast_channel_unlock(owner);
1590                         }
1591                         break;
1592 #if defined(HAVE_PRI_CALL_REROUTING)
1593                 case PRI_SUBCMD_REROUTING:
1594                         sig_pri_lock_owner(pri, chanpos);
1595                         owner = pri->pvts[chanpos]->owner;
1596                         if (owner) {
1597                                 struct pri_party_redirecting pri_deflection;
1598
1599                                 if (!call_rsp) {
1600                                         ast_channel_unlock(owner);
1601                                         ast_log(LOG_WARNING,
1602                                                 "CallRerouting/CallDeflection to '%s' without call!\n",
1603                                                 subcmd->u.rerouting.deflection.to.number.str);
1604                                         break;
1605                                 }
1606
1607                                 pri_deflection = subcmd->u.rerouting.deflection;
1608
1609                                 ast_string_field_set(owner, call_forward, pri_deflection.to.number.str);
1610
1611                                 /* Adjust the deflecting to number based upon the subscription option. */
1612                                 switch (subcmd->u.rerouting.subscription_option) {
1613                                 case 0: /* noNotification */
1614                                 case 1: /* notificationWithoutDivertedToNr */
1615                                         /* Delete the number because the far end is not supposed to see it. */
1616                                         pri_deflection.to.number.presentation =
1617                                                 PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_UNSCREENED;
1618                                         pri_deflection.to.number.plan =
1619                                                 (PRI_TON_UNKNOWN << 4) | PRI_NPI_E163_E164;
1620                                         pri_deflection.to.number.str[0] = '\0';
1621                                         break;
1622                                 case 2: /* notificationWithDivertedToNr */
1623                                         break;
1624                                 case 3: /* notApplicable */
1625                                 default:
1626                                         break;
1627                                 }
1628                                 sig_pri_redirecting_convert(&ast_redirecting, &pri_deflection,
1629                                         &owner->redirecting, pri);
1630                                 ast_channel_set_redirecting(owner, &ast_redirecting);
1631                                 ast_party_redirecting_free(&ast_redirecting);
1632
1633                                 /*
1634                                  * Send back positive ACK to CallRerouting/CallDeflection.
1635                                  *
1636                                  * Note:  This call will be hungup by the dial application when
1637                                  * it processes the call_forward string set above.
1638                                  */
1639                                 pri_rerouting_rsp(pri->pri, call_rsp, subcmd->u.rerouting.invoke_id,
1640                                         PRI_REROUTING_RSP_OK_CLEAR);
1641
1642                                 /* This line is BUSY to further attempts by this dialing attempt. */
1643                                 ast_queue_control(owner, AST_CONTROL_BUSY);
1644
1645                                 ast_channel_unlock(owner);
1646                         }
1647                         break;
1648 #endif  /* defined(HAVE_PRI_CALL_REROUTING) */
1649                 default:
1650                         ast_debug(2,
1651                                 "Unknown call subcommand(%d) in %s event on channel %d/%d on span %d.\n",
1652                                 subcmd->cmd, pri_event2str(event_id), PRI_SPAN(channel),
1653                                 PRI_CHANNEL(channel), pri->span);
1654                         break;
1655                 }
1656         }
1657 }
1658
1659 #if defined(HAVE_PRI_CALL_HOLD)
1660 /*!
1661  * \internal
1662  * \brief Attempt to transfer the active call to the held call.
1663  * \since 1.8
1664  *
1665  * \param pri sig_pri PRI control structure.
1666  * \param active_call Active call to transfer.
1667  * \param held_call Held call to transfer.
1668  *
1669  * \note Assumes the pri->lock is already obtained.
1670  *
1671  * \retval 0 on success.
1672  * \retval -1 on error.
1673  */
1674 static int sig_pri_attempt_transfer(struct sig_pri_pri *pri, q931_call *active_call, q931_call *held_call)
1675 {
1676         int retval;
1677         int active_chanpos;
1678         int held_chanpos;
1679         struct ast_channel *active_ast;
1680         struct ast_channel *held_ast;
1681         struct ast_channel *bridged;
1682
1683         active_chanpos = pri_find_pri_call(pri, active_call);
1684         held_chanpos = pri_find_pri_call(pri, held_call);
1685         if (active_chanpos < 0 || held_chanpos < 0) {
1686                 return -1;
1687         }
1688
1689         sig_pri_lock_private(pri->pvts[active_chanpos]);
1690         sig_pri_lock_private(pri->pvts[held_chanpos]);
1691         sig_pri_lock_owner(pri, active_chanpos);
1692         sig_pri_lock_owner(pri, held_chanpos);
1693
1694         active_ast = pri->pvts[active_chanpos]->owner;
1695         held_ast = pri->pvts[held_chanpos]->owner;
1696         if (!active_ast || !held_ast) {
1697                 if (active_ast) {
1698                         ast_channel_unlock(active_ast);
1699                 }
1700                 if (held_ast) {
1701                         ast_channel_unlock(held_ast);
1702                 }
1703                 sig_pri_unlock_private(pri->pvts[active_chanpos]);
1704                 sig_pri_unlock_private(pri->pvts[held_chanpos]);
1705                 return -1;
1706         }
1707
1708         bridged = ast_bridged_channel(held_ast);
1709         if (bridged) {
1710                 ast_queue_control(held_ast, AST_CONTROL_UNHOLD);
1711
1712                 ast_verb(3, "TRANSFERRING %s to %s\n", held_ast->name, active_ast->name);
1713                 retval = ast_channel_masquerade(active_ast, bridged);
1714         } else {
1715                 /*
1716                  * Could not transfer.  Held channel is not bridged anymore.
1717                  * Held party probably got tired of waiting and hung up.
1718                  */
1719                 retval = -1;
1720         }
1721
1722         ast_channel_unlock(active_ast);
1723         ast_channel_unlock(held_ast);
1724         sig_pri_unlock_private(pri->pvts[active_chanpos]);
1725         sig_pri_unlock_private(pri->pvts[held_chanpos]);
1726
1727         return retval;
1728 }
1729 #endif  /* defined(HAVE_PRI_CALL_HOLD) */
1730
1731 #if defined(HAVE_PRI_CALL_HOLD)
1732 /*!
1733  * \internal
1734  * \brief Handle the hold event from libpri.
1735  * \since 1.8
1736  *
1737  * \param pri sig_pri PRI control structure.
1738  * \param ev Hold event received.
1739  *
1740  * \note Assumes the pri->lock is already obtained.
1741  *
1742  * \retval 0 on success.
1743  * \retval -1 on error.
1744  */
1745 static int sig_pri_handle_hold(struct sig_pri_pri *pri, pri_event *ev)
1746 {
1747         int retval;
1748         int chanpos_old;
1749         int chanpos_new;
1750         struct ast_channel *bridged;
1751         struct ast_channel *owner;
1752
1753         chanpos_old = pri_find_principle(pri, ev->hold.channel, ev->hold.call);
1754         if (chanpos_old < 0) {
1755                 ast_log(LOG_WARNING,
1756                         "Received HOLD on unconfigured channel %d/%d span %d\n",
1757                         PRI_SPAN(ev->hold.channel), PRI_CHANNEL(ev->hold.channel), pri->span);
1758                 return -1;
1759         }
1760         if (pri->pvts[chanpos_old]->no_b_channel) {
1761                 /* Call is already on hold or is call waiting call. */
1762                 return -1;
1763         }
1764
1765         sig_pri_lock_private(pri->pvts[chanpos_old]);
1766         sig_pri_lock_owner(pri, chanpos_old);
1767         owner = pri->pvts[chanpos_old]->owner;
1768         if (!owner) {
1769                 retval = -1;
1770                 goto done_with_private;
1771         }
1772         bridged = ast_bridged_channel(owner);
1773         if (!bridged) {
1774                 /* Cannot hold a call that is not bridged. */
1775                 retval = -1;
1776                 goto done_with_owner;
1777         }
1778         chanpos_new = pri_find_empty_nobch(pri);
1779         if (chanpos_new < 0) {
1780                 /* No hold channel available. */
1781                 retval = -1;
1782                 goto done_with_owner;
1783         }
1784         sig_pri_handle_subcmds(pri, chanpos_old, ev->e, ev->hold.channel, ev->hold.subcmds,
1785                 ev->hold.call);
1786         chanpos_new = pri_fixup_principle(pri, chanpos_new, ev->hold.call);
1787         if (chanpos_new < 0) {
1788                 /* Should never happen. */
1789                 retval = -1;
1790         } else {
1791                 struct ast_frame f = { AST_FRAME_CONTROL, };
1792
1793                 f.subclass.integer = AST_CONTROL_HOLD;
1794                 ast_queue_frame(owner, &f);
1795                 retval = 0;
1796         }
1797
1798 done_with_owner:;
1799         ast_channel_unlock(owner);
1800 done_with_private:;
1801         sig_pri_unlock_private(pri->pvts[chanpos_old]);
1802
1803         return retval;
1804 }
1805 #endif  /* defined(HAVE_PRI_CALL_HOLD) */
1806
1807 #if defined(HAVE_PRI_CALL_HOLD)
1808 /*!
1809  * \internal
1810  * \brief Handle the retrieve event from libpri.
1811  * \since 1.8
1812  *
1813  * \param pri sig_pri PRI control structure.
1814  * \param ev Retrieve event received.
1815  *
1816  * \note Assumes the pri->lock is already obtained.
1817  *
1818  * \return Nothing
1819  */
1820 static void sig_pri_handle_retrieve(struct sig_pri_pri *pri, pri_event *ev)
1821 {
1822         int chanpos;
1823
1824         if (!(ev->retrieve.channel & PRI_HELD_CALL)
1825                 || pri_find_principle(pri, ev->retrieve.channel, ev->retrieve.call) < 0) {
1826                 /* The call is not currently held. */
1827                 pri_retrieve_rej(pri->pri, ev->retrieve.call,
1828                         PRI_CAUSE_RESOURCE_UNAVAIL_UNSPECIFIED);
1829                 return;
1830         }
1831         if (PRI_CHANNEL(ev->retrieve.channel) == 0xFF) {
1832                 chanpos = pri_find_empty_chan(pri, 1);
1833         } else {
1834                 chanpos = pri_find_principle(pri,
1835                         ev->retrieve.channel & ~PRI_HELD_CALL, ev->retrieve.call);
1836                 if (ev->retrieve.flexible
1837                         && (chanpos < 0 || pri->pvts[chanpos]->owner)) {
1838                         /*
1839                          * Channel selection is flexible and the requested channel
1840                          * is bad or already in use.  Pick another channel.
1841                          */
1842                         chanpos = pri_find_empty_chan(pri, 1);
1843                 }
1844         }
1845         if (chanpos < 0) {
1846                 pri_retrieve_rej(pri->pri, ev->retrieve.call,
1847                         ev->retrieve.flexible ? PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION
1848                         : PRI_CAUSE_REQUESTED_CHAN_UNAVAIL);
1849                 return;
1850         }
1851         chanpos = pri_fixup_principle(pri, chanpos, ev->retrieve.call);
1852         if (chanpos < 0) {
1853                 /* Channel is already in use. */
1854                 pri_retrieve_rej(pri->pri, ev->retrieve.call,
1855                         PRI_CAUSE_REQUESTED_CHAN_UNAVAIL);
1856                 return;
1857         }
1858         sig_pri_lock_private(pri->pvts[chanpos]);
1859         sig_pri_handle_subcmds(pri, chanpos, ev->e, ev->retrieve.channel,
1860                 ev->retrieve.subcmds, ev->retrieve.call);
1861         {
1862                 struct ast_frame f = { AST_FRAME_CONTROL, };
1863
1864                 f.subclass.integer = AST_CONTROL_UNHOLD;
1865                 pri_queue_frame(pri->pvts[chanpos], &f, pri);
1866         }
1867         sig_pri_unlock_private(pri->pvts[chanpos]);
1868         pri_retrieve_ack(pri->pri, ev->retrieve.call,
1869                 PVT_TO_CHANNEL(pri->pvts[chanpos]));
1870 }
1871 #endif  /* defined(HAVE_PRI_CALL_HOLD) */
1872
1873 static void *pri_dchannel(void *vpri)
1874 {
1875         struct sig_pri_pri *pri = vpri;
1876         pri_event *e;
1877         struct pollfd fds[NUM_DCHANS];
1878         int res;
1879         int chanpos = 0;
1880         int x;
1881         struct ast_channel *c;
1882         struct timeval tv, lowest, *next;
1883         int doidling=0;
1884         char *cc;
1885         time_t t;
1886         int i, which=-1;
1887         int numdchans;
1888         pthread_t threadid;
1889         char ani2str[6];
1890         char plancallingnum[AST_MAX_EXTENSION];
1891         char plancallingani[AST_MAX_EXTENSION];
1892         char calledtonstr[10];
1893         struct timeval lastidle = { 0, 0 };
1894         pthread_t p;
1895         struct ast_channel *idle;
1896         char idlen[80];
1897         int nextidle = -1;
1898         int haveidles;
1899         int activeidles;
1900
1901         gettimeofday(&lastidle, NULL);
1902         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
1903
1904         if (!ast_strlen_zero(pri->idledial) && !ast_strlen_zero(pri->idleext)) {
1905                 /* Need to do idle dialing, check to be sure though */
1906                 cc = strchr(pri->idleext, '@');
1907                 if (cc) {
1908                         *cc = '\0';
1909                         cc++;
1910                         ast_copy_string(pri->idlecontext, cc, sizeof(pri->idlecontext));
1911 #if 0
1912                         /* Extensions may not be loaded yet */
1913                         if (!ast_exists_extension(NULL, pri->idlecontext, pri->idleext, 1, NULL))
1914                                 ast_log(LOG_WARNING, "Extension '%s @ %s' does not exist\n", pri->idleext, pri->idlecontext);
1915                         else
1916 #endif
1917                                 doidling = 1;
1918                 } else
1919                         ast_log(LOG_WARNING, "Idle dial string '%s' lacks '@context'\n", pri->idleext);
1920         }
1921         for (;;) {
1922                 for (i = 0; i < NUM_DCHANS; i++) {
1923                         if (!pri->dchans[i])
1924                                 break;
1925                         fds[i].fd = pri->fds[i];
1926                         fds[i].events = POLLIN | POLLPRI;
1927                         fds[i].revents = 0;
1928                 }
1929                 numdchans = i;
1930                 time(&t);
1931                 ast_mutex_lock(&pri->lock);
1932                 if (pri->switchtype != PRI_SWITCH_GR303_TMC && (pri->sig != SIG_BRI_PTMP) && (pri->resetinterval > 0)) {
1933                         if (pri->resetting && pri_is_up(pri)) {
1934                                 if (pri->resetpos < 0)
1935                                         pri_check_restart(pri);
1936                         } else {
1937                                 if (!pri->resetting     && (t - pri->lastreset) >= pri->resetinterval) {
1938                                         pri->resetting = 1;
1939                                         pri->resetpos = -1;
1940                                 }
1941                         }
1942                 }
1943                 /* Look for any idle channels if appropriate */
1944                 if (doidling && pri_is_up(pri)) {
1945                         nextidle = -1;
1946                         haveidles = 0;
1947                         activeidles = 0;
1948                         for (x = pri->numchans; x >= 0; x--) {
1949                                 if (pri->pvts[x]
1950                                         && !pri->pvts[x]->owner
1951                                         && !pri->pvts[x]->call
1952                                         && !pri->pvts[x]->no_b_channel) {
1953                                         if (haveidles < pri->minunused) {
1954                                                 haveidles++;
1955                                         } else if (!pri->pvts[x]->resetting) {
1956                                                 nextidle = x;
1957                                                 break;
1958                                         }
1959                                 } else if (pri->pvts[x] && pri->pvts[x]->owner && pri->pvts[x]->isidlecall)
1960                                         activeidles++;
1961                         }
1962                         if (nextidle > -1) {
1963                                 if (ast_tvdiff_ms(ast_tvnow(), lastidle) > 1000) {
1964                                         /* Don't create a new idle call more than once per second */
1965                                         snprintf(idlen, sizeof(idlen), "%d/%s", pri->pvts[nextidle]->channel, pri->idledial);
1966                                         idle = sig_pri_request(pri->pvts[nextidle], AST_FORMAT_ULAW, NULL, 0);
1967                                         if (idle) {
1968                                                 pri->pvts[nextidle]->isidlecall = 1;
1969                                                 if (ast_pthread_create_background(&p, NULL, do_idle_thread, idle)) {
1970                                                         ast_log(LOG_WARNING, "Unable to start new thread for idle channel '%s'\n", idle->name);
1971                                                         ast_hangup(idle);
1972                                                 }
1973                                         } else
1974                                                 ast_log(LOG_WARNING, "Unable to request channel 'DAHDI/%s' for idle call\n", idlen);
1975                                         gettimeofday(&lastidle, NULL);
1976                                 }
1977                         } else if ((haveidles < pri->minunused) &&
1978                                 (activeidles > pri->minidle)) {
1979                                 /* Mark something for hangup if there is something
1980                                    that can be hungup */
1981                                 for (x = pri->numchans; x >= 0; x--) {
1982                                         /* find a candidate channel */
1983                                         if (pri->pvts[x] && pri->pvts[x]->owner && pri->pvts[x]->isidlecall) {
1984                                                 pri->pvts[x]->owner->_softhangup |= AST_SOFTHANGUP_DEV;
1985                                                 haveidles++;
1986                                                 /* Stop if we have enough idle channels or
1987                                                   can't spare any more active idle ones */
1988                                                 if ((haveidles >= pri->minunused) ||
1989                                                         (activeidles <= pri->minidle))
1990                                                         break;
1991                                         }
1992                                 }
1993                         }
1994                 }
1995                 /* Start with reasonable max */
1996                 lowest = ast_tv(60, 0);
1997                 for (i = 0; i < NUM_DCHANS; i++) {
1998                         /* Find lowest available d-channel */
1999                         if (!pri->dchans[i])
2000                                 break;
2001                         if ((next = pri_schedule_next(pri->dchans[i]))) {
2002                                 /* We need relative time here */
2003                                 tv = ast_tvsub(*next, ast_tvnow());
2004                                 if (tv.tv_sec < 0) {
2005                                         tv = ast_tv(0,0);
2006                                 }
2007                                 if (doidling || pri->resetting) {
2008                                         if (tv.tv_sec > 1) {
2009                                                 tv = ast_tv(1, 0);
2010                                         }
2011                                 } else {
2012                                         if (tv.tv_sec > 60) {
2013                                                 tv = ast_tv(60, 0);
2014                                         }
2015                                 }
2016                         } else if (doidling || pri->resetting) {
2017                                 /* Make sure we stop at least once per second if we're
2018                                    monitoring idle channels */
2019                                 tv = ast_tv(1,0);
2020                         } else {
2021                                 /* Don't poll for more than 60 seconds */
2022                                 tv = ast_tv(60, 0);
2023                         }
2024                         if (!i || ast_tvcmp(tv, lowest) < 0) {
2025                                 lowest = tv;
2026                         }
2027                 }
2028                 ast_mutex_unlock(&pri->lock);
2029
2030                 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
2031                 pthread_testcancel();
2032                 e = NULL;
2033                 res = poll(fds, numdchans, lowest.tv_sec * 1000 + lowest.tv_usec / 1000);
2034                 pthread_testcancel();
2035                 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
2036
2037                 ast_mutex_lock(&pri->lock);
2038                 if (!res) {
2039                         for (which = 0; which < NUM_DCHANS; which++) {
2040                                 if (!pri->dchans[which])
2041                                         break;
2042                                 /* Just a timeout, run the scheduler */
2043                                 e = pri_schedule_run(pri->dchans[which]);
2044                                 if (e)
2045                                         break;
2046                         }
2047                 } else if (res > -1) {
2048                         for (which = 0; which < NUM_DCHANS; which++) {
2049                                 if (!pri->dchans[which])
2050                                         break;
2051                                 if (fds[which].revents & POLLPRI) {
2052                                         sig_pri_handle_dchan_exception(pri, which);
2053                                 } else if (fds[which].revents & POLLIN) {
2054                                         e = pri_check_event(pri->dchans[which]);
2055                                 }
2056                                 if (e)
2057                                         break;
2058                         }
2059                 } else if (errno != EINTR)
2060                         ast_log(LOG_WARNING, "pri_event returned error %d (%s)\n", errno, strerror(errno));
2061
2062                 if (e) {
2063                         if (pri->debug)
2064                                 pri_dump_event(pri->dchans[which], e);
2065
2066                         if (e->e != PRI_EVENT_DCHAN_DOWN) {
2067                                 if (!(pri->dchanavail[which] & DCHAN_UP)) {
2068                                         ast_verb(2, "%s D-Channel on span %d up\n", pri_order(which), pri->span);
2069                                 }
2070                                 pri->dchanavail[which] |= DCHAN_UP;
2071                         } else {
2072                                 if (pri->dchanavail[which] & DCHAN_UP) {
2073                                         ast_verb(2, "%s D-Channel on span %d down\n", pri_order(which), pri->span);
2074                                 }
2075                                 pri->dchanavail[which] &= ~DCHAN_UP;
2076                         }
2077
2078                         if ((e->e != PRI_EVENT_DCHAN_UP) && (e->e != PRI_EVENT_DCHAN_DOWN) && (pri->pri != pri->dchans[which]))
2079                                 /* Must be an NFAS group that has the secondary dchan active */
2080                                 pri->pri = pri->dchans[which];
2081
2082                         switch (e->e) {
2083                         case PRI_EVENT_DCHAN_UP:
2084                                 if (!pri->pri) pri_find_dchan(pri);
2085
2086                                 /* Note presense of D-channel */
2087                                 time(&pri->lastreset);
2088
2089                                 /* Restart in 5 seconds */
2090                                 if (pri->resetinterval > -1) {
2091                                         pri->lastreset -= pri->resetinterval;
2092                                         pri->lastreset += 5;
2093                                 }
2094                                 pri->resetting = 0;
2095                                 /* Take the channels from inalarm condition */
2096                                 for (i = 0; i < pri->numchans; i++)
2097                                         if (pri->pvts[i]) {
2098                                                 pri->pvts[i]->inalarm = 0;
2099                                         }
2100                                 break;
2101                         case PRI_EVENT_DCHAN_DOWN:
2102                                 pri_find_dchan(pri);
2103                                 if (!pri_is_up(pri)) {
2104                                         pri->resetting = 0;
2105                                         if (pri->sig == SIG_BRI_PTMP) {
2106                                                 /* For PTMP connections with non persistent layer 2 we want
2107                                                  * to *not* declare inalarm unless there actually is an alarm */
2108                                                 break;
2109                                         }
2110                                         /* Hangup active channels and put them in alarm mode */
2111                                         for (i = 0; i < pri->numchans; i++) {
2112                                                 struct sig_pri_chan *p = pri->pvts[i];
2113                                                 if (p) {
2114                                                         if (!p->pri || !p->pri->pri || pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0) {
2115                                                                 /* T309 is not enabled : hangup calls when alarm occurs */
2116                                                                 if (p->call) {
2117                                                                         if (p->pri && p->pri->pri) {
2118                                                                                 pri_hangup(p->pri->pri, p->call, -1);
2119                                                                                 pri_destroycall(p->pri->pri, p->call);
2120                                                                                 p->call = NULL;
2121                                                                         } else
2122                                                                                 ast_log(LOG_WARNING, "The PRI Call have not been destroyed\n");
2123                                                                 }
2124                                                                 if (p->owner)
2125                                                                         ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
2126                                                         }
2127                                                         p->inalarm = 1;
2128                                                 }
2129                                         }
2130                                 }
2131                                 break;
2132                         case PRI_EVENT_RESTART:
2133                                 if (e->restart.channel > -1) {
2134                                         chanpos = pri_find_principle(pri, e->restart.channel, NULL);
2135                                         if (chanpos < 0)
2136                                                 ast_log(LOG_WARNING, "Restart requested on odd/unavailable channel number %d/%d on span %d\n",
2137                                                         PRI_SPAN(e->restart.channel), PRI_CHANNEL(e->restart.channel), pri->span);
2138                                         else {
2139 #ifdef HAVE_PRI_SERVICE_MESSAGES
2140                                                 char db_chan_name[20], db_answer[5], state;
2141                                                 int why, skipit = 0;
2142
2143                                                 snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->span, pri->pvts[chanpos]->channel);
2144                                                 if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) {
2145                                                         sscanf(db_answer, "%1c:%30d", &state, &why);
2146                                                         if (why) {
2147                                                                 ast_log(LOG_NOTICE, "span '%d' channel '%d' out-of-service (reason: %s), ignoring RESTART\n", pri->span,
2148                                                                         PRI_CHANNEL(e->restart.channel), (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end");
2149                                                                 skipit = 1;
2150                                                         } else {
2151                                                                 ast_db_del(db_chan_name, SRVST_DBKEY);
2152                                                         }
2153                                                 }
2154 #endif
2155                                                 sig_pri_lock_private(pri->pvts[chanpos]);
2156 #ifdef HAVE_PRI_SERVICE_MESSAGES
2157                                                 if (!skipit) {
2158 #endif
2159                                                         ast_verb(3, "B-channel %d/%d restarted on span %d\n",
2160                                                                 PRI_SPAN(e->restart.channel), PRI_CHANNEL(e->restart.channel), pri->span);
2161                                                         if (pri->pvts[chanpos]->call) {
2162                                                                 pri_destroycall(pri->pri, pri->pvts[chanpos]->call);
2163                                                                 pri->pvts[chanpos]->call = NULL;
2164                                                         }
2165 #ifdef HAVE_PRI_SERVICE_MESSAGES
2166                                                 }
2167 #endif
2168                                                 /* Force soft hangup if appropriate */
2169                                                 if (pri->pvts[chanpos]->owner)
2170                                                         ast_softhangup_nolock(pri->pvts[chanpos]->owner, AST_SOFTHANGUP_DEV);
2171                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
2172                                         }
2173                                 } else {
2174                                         ast_verb(3, "Restart requested on entire span %d\n", pri->span);
2175                                         for (x = 0; x < pri->numchans; x++)
2176                                                 if (pri->pvts[x]) {
2177                                                         sig_pri_lock_private(pri->pvts[x]);
2178                                                         if (pri->pvts[x]->call) {
2179                                                                 pri_destroycall(pri->pri, pri->pvts[x]->call);
2180                                                                 pri->pvts[x]->call = NULL;
2181                                                         }
2182                                                         if (pri->pvts[x]->owner)
2183                                                                 ast_softhangup_nolock(pri->pvts[x]->owner, AST_SOFTHANGUP_DEV);
2184                                                         sig_pri_unlock_private(pri->pvts[x]);
2185                                                 }
2186                                 }
2187                                 break;
2188                         case PRI_EVENT_KEYPAD_DIGIT:
2189                                 chanpos = pri_find_principle(pri, e->digit.channel, e->digit.call);
2190                                 if (chanpos < 0) {
2191                                         ast_log(LOG_WARNING, "KEYPAD_DIGITs received on unconfigured channel %d/%d span %d\n",
2192                                                 PRI_SPAN(e->digit.channel), PRI_CHANNEL(e->digit.channel), pri->span);
2193                                 } else {
2194                                         chanpos = pri_fixup_principle(pri, chanpos, e->digit.call);
2195                                         if (chanpos > -1) {
2196                                                 sig_pri_lock_private(pri->pvts[chanpos]);
2197                                                 sig_pri_handle_subcmds(pri, chanpos, e->e, e->digit.channel,
2198                                                         e->digit.subcmds, e->digit.call);
2199                                                 /* queue DTMF frame if the PBX for this call was already started (we're forwarding KEYPAD_DIGITs further on */
2200                                                 if ((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)
2201                                                         && pri->pvts[chanpos]->call == e->digit.call
2202                                                         && pri->pvts[chanpos]->owner) {
2203                                                         /* how to do that */
2204                                                         int digitlen = strlen(e->digit.digits);
2205                                                         int i;
2206
2207                                                         for (i = 0; i < digitlen; i++) {
2208                                                                 struct ast_frame f = { AST_FRAME_DTMF, .subclass.integer = e->digit.digits[i], };
2209
2210                                                                 pri_queue_frame(pri->pvts[chanpos], &f, pri);
2211                                                         }
2212                                                 }
2213                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
2214                                         }
2215                                 }
2216                                 break;
2217
2218                         case PRI_EVENT_INFO_RECEIVED:
2219                                 chanpos = pri_find_principle(pri, e->ring.channel, e->ring.call);
2220                                 if (chanpos < 0) {
2221                                         ast_log(LOG_WARNING, "INFO received on unconfigured channel %d/%d span %d\n",
2222                                                 PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span);
2223                                 } else {
2224                                         chanpos = pri_fixup_principle(pri, chanpos, e->ring.call);
2225                                         if (chanpos > -1) {
2226                                                 sig_pri_lock_private(pri->pvts[chanpos]);
2227                                                 sig_pri_handle_subcmds(pri, chanpos, e->e, e->ring.channel,
2228                                                         e->ring.subcmds, e->ring.call);
2229                                                 /* queue DTMF frame if the PBX for this call was already started (we're forwarding INFORMATION further on */
2230                                                 if ((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)
2231                                                         && pri->pvts[chanpos]->call == e->ring.call
2232                                                         && pri->pvts[chanpos]->owner) {
2233                                                         /* how to do that */
2234                                                         int digitlen = strlen(e->ring.callednum);
2235                                                         int i;
2236
2237                                                         for (i = 0; i < digitlen; i++) {
2238                                                                 struct ast_frame f = { AST_FRAME_DTMF, .subclass.integer = e->ring.callednum[i], };
2239
2240                                                                 pri_queue_frame(pri->pvts[chanpos], &f, pri);
2241                                                         }
2242                                                 }
2243                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
2244                                         }
2245                                 }
2246                                 break;
2247 #ifdef HAVE_PRI_SERVICE_MESSAGES
2248                         case PRI_EVENT_SERVICE:
2249                                 chanpos = pri_find_principle(pri, e->service.channel, NULL);
2250                                 if (chanpos < 0) {
2251                                         ast_log(LOG_WARNING, "Received service change status %d on unconfigured channel %d/%d span %d\n",
2252                                                 e->service_ack.changestatus, PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span);
2253                                 } else {
2254                                         char db_chan_name[20], db_answer[5], state;
2255                                         int ch, why = -1;
2256
2257                                         ch = pri->pvts[chanpos]->channel;
2258                                         snprintf(db_chan_name, sizeof(db_chan_name), "%s/%d:%d", dahdi_db, pri->span, ch);
2259                                         if (!ast_db_get(db_chan_name, SRVST_DBKEY, db_answer, sizeof(db_answer))) {
2260                                                 sscanf(db_answer, "%1c:%30d", &state, &why);
2261                                                 ast_db_del(db_chan_name, SRVST_DBKEY);
2262                                         }
2263                                         switch (e->service.changestatus) {
2264                                         case 0: /* in-service */
2265                                                 if (why > -1) {
2266                                                         if (why & SRVST_NEAREND) {
2267                                                                 snprintf(db_answer, sizeof(db_answer), "%s:%d", SRVST_TYPE_OOS, SRVST_NEAREND);
2268                                                                 ast_db_put(db_chan_name, SRVST_DBKEY, db_answer);
2269                                                                 ast_debug(2, "channel '%d' service state { near: out-of-service,  far: in-service }\n", ch);
2270                                                         }
2271                                                 }
2272                                                 break;
2273                                         case 2: /* out-of-service */
2274                                                 if (why == -1) {
2275                                                         why = SRVST_FAREND;
2276                                                 } else {
2277                                                         why |= SRVST_FAREND;
2278                                                 }
2279                                                 snprintf(db_answer, sizeof(db_answer), "%s:%d", SRVST_TYPE_OOS, why);
2280                                                 ast_db_put(db_chan_name, SRVST_DBKEY, db_answer);
2281                                                 break;
2282                                         default:
2283                                                 ast_log(LOG_ERROR, "Huh?  changestatus is: %d\n", e->service.changestatus);
2284                                         }
2285                                         ast_log(LOG_NOTICE, "Channel %d/%d span %d (logical: %d) received a change of service message, status '%d'\n",
2286                                                 PRI_SPAN(e->service.channel), PRI_CHANNEL(e->service.channel), pri->span, ch, e->service.changestatus);
2287                                 }
2288                                 break;
2289                         case PRI_EVENT_SERVICE_ACK:
2290                                 chanpos = pri_find_principle(pri, e->service_ack.channel, NULL);
2291                                 if (chanpos < 0) {
2292                                         ast_log(LOG_WARNING, "Received service acknowledge change status '%d' on unconfigured channel %d/%d span %d\n",
2293                                                 e->service_ack.changestatus, PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span);
2294                                 } else {
2295                                         ast_debug(2, "Channel %d/%d span %d received a change os service acknowledgement message, status '%d'\n",
2296                                                 PRI_SPAN(e->service_ack.channel), PRI_CHANNEL(e->service_ack.channel), pri->span, e->service_ack.changestatus);
2297                                 }
2298                                 break;
2299 #endif
2300                         case PRI_EVENT_RING:
2301                                 if (!ast_strlen_zero(pri->msn_list)
2302                                         && !sig_pri_msn_match(pri->msn_list, e->ring.callednum)) {
2303                                         /* The call is not for us so ignore it. */
2304                                         ast_verb(3,
2305                                                 "Ignoring call to '%s' on span %d.  Its not in the MSN list: %s\n",
2306                                                 e->ring.callednum, pri->span, pri->msn_list);
2307                                         pri_destroycall(pri->pri, e->ring.call);
2308                                         break;
2309                                 }
2310                                 if (e->ring.channel == -1)
2311                                         chanpos = pri_find_empty_chan(pri, 1);
2312                                 else
2313                                         chanpos = pri_find_principle(pri, e->ring.channel, e->ring.call);
2314                                 /* if no channel specified find one empty */
2315                                 if (chanpos < 0) {
2316                                         ast_log(LOG_WARNING, "Ring requested on unconfigured channel %d/%d span %d\n",
2317                                                 PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span);
2318                                 } else {
2319                                         sig_pri_lock_private(pri->pvts[chanpos]);
2320                                         if (pri->pvts[chanpos]->owner) {
2321                                                 if (pri->pvts[chanpos]->call == e->ring.call) {
2322                                                         ast_log(LOG_WARNING, "Duplicate setup requested on channel %d/%d already in use on span %d\n",
2323                                                                 PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span);
2324                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
2325                                                         break;
2326                                                 } else {
2327                                                         /* This is where we handle initial glare */
2328                                                         ast_debug(1, "Ring requested on channel %d/%d already in use or previously requested on span %d.  Attempting to renegotiating channel.\n",
2329                                                         PRI_SPAN(e->ring.channel), PRI_CHANNEL(e->ring.channel), pri->span);
2330                                                         sig_pri_unlock_private(pri->pvts[chanpos]);
2331                                                         chanpos = -1;
2332                                                 }
2333                                         }
2334                                         if (chanpos > -1)
2335                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
2336                                 }
2337                                 if ((chanpos < 0) && (e->ring.flexible))
2338                                         chanpos = pri_find_empty_chan(pri, 1);
2339                                 if (chanpos > -1) {
2340                                         sig_pri_lock_private(pri->pvts[chanpos]);
2341                                         pri->pvts[chanpos]->call = e->ring.call;
2342
2343                                         /* Use plancallingnum as a scratch buffer since it is initialized next. */
2344                                         apply_plan_to_number(plancallingnum, sizeof(plancallingnum), pri,
2345                                                 e->ring.redirectingnum, e->ring.callingplanrdnis);
2346                                         sig_pri_set_rdnis(pri->pvts[chanpos], plancallingnum);
2347
2348                                         /* Setup caller-id info */
2349                                         apply_plan_to_number(plancallingnum, sizeof(plancallingnum), pri, e->ring.callingnum, e->ring.callingplan);
2350                                         pri->pvts[chanpos]->cid_ani2 = 0;
2351                                         if (pri->pvts[chanpos]->use_callerid) {
2352                                                 ast_shrink_phone_number(plancallingnum);
2353                                                 ast_copy_string(pri->pvts[chanpos]->cid_num, plancallingnum, sizeof(pri->pvts[chanpos]->cid_num));
2354 #ifdef PRI_ANI
2355                                                 if (!ast_strlen_zero(e->ring.callingani)) {
2356                                                         apply_plan_to_number(plancallingani, sizeof(plancallingani), pri, e->ring.callingani, e->ring.callingplanani);
2357                                                         ast_shrink_phone_number(plancallingani);
2358                                                         ast_copy_string(pri->pvts[chanpos]->cid_ani, plancallingani, sizeof(pri->pvts[chanpos]->cid_ani));
2359                                                 } else {
2360                                                         pri->pvts[chanpos]->cid_ani[0] = '\0';
2361                                                 }
2362 #endif
2363                                                 pri->pvts[chanpos]->cid_subaddr[0] = '\0';
2364 #if defined(HAVE_PRI_SUBADDR)
2365                                                 if (e->ring.calling.subaddress.valid) {
2366                                                         struct ast_party_subaddress calling_subaddress;
2367
2368                                                         ast_party_subaddress_init(&calling_subaddress);
2369                                                         sig_pri_set_subaddress(&calling_subaddress,
2370                                                                 &e->ring.calling.subaddress);
2371                                                         if (calling_subaddress.str) {
2372                                                                 ast_copy_string(pri->pvts[chanpos]->cid_subaddr,
2373                                                                         calling_subaddress.str,
2374                                                                         sizeof(pri->pvts[chanpos]->cid_subaddr));
2375                                                         }
2376                                                         ast_party_subaddress_free(&calling_subaddress);
2377                                                 }
2378 #endif /* defined(HAVE_PRI_SUBADDR) */
2379                                                 ast_copy_string(pri->pvts[chanpos]->cid_name, e->ring.callingname, sizeof(pri->pvts[chanpos]->cid_name));
2380                                                 pri->pvts[chanpos]->cid_ton = e->ring.callingplan; /* this is the callingplan (TON/NPI), e->ring.callingplan>>4 would be the TON */
2381                                                 pri->pvts[chanpos]->callingpres = e->ring.callingpres;
2382                                                 if (e->ring.ani2 >= 0) {
2383                                                         pri->pvts[chanpos]->cid_ani2 = e->ring.ani2;
2384                                                 }
2385                                         } else {
2386                                                 pri->pvts[chanpos]->cid_num[0] = '\0';
2387                                                 pri->pvts[chanpos]->cid_subaddr[0] = '\0';
2388                                                 pri->pvts[chanpos]->cid_ani[0] = '\0';
2389                                                 pri->pvts[chanpos]->cid_name[0] = '\0';
2390                                                 pri->pvts[chanpos]->cid_ton = 0;
2391                                                 pri->pvts[chanpos]->callingpres = 0;
2392                                         }
2393                                         sig_pri_set_caller_id(pri->pvts[chanpos]);
2394
2395                                         /* Set DNID on all incoming calls -- even immediate */
2396                                         sig_pri_set_dnid(pri->pvts[chanpos], e->ring.callednum);
2397
2398                                         /* If immediate=yes go to s|1 */
2399                                         if (pri->pvts[chanpos]->immediate) {
2400                                                 ast_verb(3, "Going to extension s|1 because of immediate=yes\n");
2401                                                 pri->pvts[chanpos]->exten[0] = 's';
2402                                                 pri->pvts[chanpos]->exten[1] = '\0';
2403                                         }
2404                                         /* Get called number */
2405                                         else if (!ast_strlen_zero(e->ring.callednum)) {
2406                                                 ast_copy_string(pri->pvts[chanpos]->exten, e->ring.callednum, sizeof(pri->pvts[chanpos]->exten));
2407                                         } else if (pri->overlapdial)
2408                                                 pri->pvts[chanpos]->exten[0] = '\0';
2409                                         else {
2410                                                 /* Some PRI circuits are set up to send _no_ digits.  Handle them as 's'. */
2411                                                 pri->pvts[chanpos]->exten[0] = 's';
2412                                                 pri->pvts[chanpos]->exten[1] = '\0';
2413                                         }
2414                                         /* No number yet, but received "sending complete"? */
2415                                         if (e->ring.complete && (ast_strlen_zero(e->ring.callednum))) {
2416                                                 ast_verb(3, "Going to extension s|1 because of Complete received\n");
2417                                                 pri->pvts[chanpos]->exten[0] = 's';
2418                                                 pri->pvts[chanpos]->exten[1] = '\0';
2419                                         }
2420
2421                                         /* Make sure extension exists (or in overlap dial mode, can exist) */
2422                                         if (((pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) && ast_canmatch_extension(NULL, pri->pvts[chanpos]->context, pri->pvts[chanpos]->exten, 1, pri->pvts[chanpos]->cid_num)) ||
2423                                                 ast_exists_extension(NULL, pri->pvts[chanpos]->context, pri->pvts[chanpos]->exten, 1, pri->pvts[chanpos]->cid_num)) {
2424                                                 /* Setup law */
2425                                                 if (e->ring.complete || !(pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)) {
2426                                                         /* Just announce proceeding */
2427                                                         pri->pvts[chanpos]->proceeding = 1;
2428                                                         pri_proceeding(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 0);
2429                                                 } else {
2430                                                         if (pri->switchtype != PRI_SWITCH_GR303_TMC)
2431                                                                 pri_need_more_info(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 1);
2432                                                         else
2433                                                                 pri_answer(pri->pri, e->ring.call, PVT_TO_CHANNEL(pri->pvts[chanpos]), 1);
2434                                                 }
2435
2436                                                 /* Start PBX */
2437                                                 if (!e->ring.complete
2438                                                         && (pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)
2439                                                         && ast_matchmore_extension(NULL, pri->pvts[chanpos]->context, pri->pvts[chanpos]->exten, 1, pri->pvts[chanpos]->cid_num)) {
2440                                                         /*
2441                                                          * Release the PRI lock while we create the channel
2442                                                          * so other threads can send D channel messages.
2443                                                          */
2444                                                         ast_mutex_unlock(&pri->lock);
2445                                                         c = sig_pri_new_ast_channel(pri->pvts[chanpos],
2446                                                                 AST_STATE_RESERVED, 0,
2447                                                                 (e->ring.layer1 == PRI_LAYER_1_ALAW)
2448                                                                         ? SIG_PRI_ALAW : SIG_PRI_ULAW,
2449                                                                 e->ring.ctype, pri->pvts[chanpos]->exten, NULL);
2450                                                         ast_mutex_lock(&pri->lock);
2451                                                         if (c) {
2452 #if defined(HAVE_PRI_SUBADDR)
2453                                                                 if (e->ring.calling.subaddress.valid) {
2454                                                                         /* Set Calling Subaddress */
2455                                                                         sig_pri_lock_owner(pri, chanpos);
2456                                                                         sig_pri_set_subaddress(
2457                                                                                 &pri->pvts[chanpos]->owner->cid.subaddress,
2458                                                                                 &e->ring.calling.subaddress);
2459                                                                         if (!e->ring.calling.subaddress.type
2460                                                                                 && !ast_strlen_zero(
2461                                                                                         (char *) e->ring.calling.subaddress.data)) {
2462                                                                                 /* NSAP */
2463                                                                                 pbx_builtin_setvar_helper(c, "CALLINGSUBADDR",
2464                                                                                         (char *) e->ring.calling.subaddress.data);
2465                                                                         }
2466                                                                         ast_channel_unlock(c);
2467                                                                 }
2468                                                                 if (e->ring.called_subaddress.valid) {
2469                                                                         /* Set Called Subaddress */
2470                                                                         sig_pri_lock_owner(pri, chanpos);
2471                                                                         sig_pri_set_subaddress(
2472                                                                                 &pri->pvts[chanpos]->owner->cid.dialed_subaddress,
2473                                                                                 &e->ring.called_subaddress);
2474                                                                         if (!e->ring.called_subaddress.type
2475                                                                                 && !ast_strlen_zero(
2476                                                                                         (char *) e->ring.called_subaddress.data)) {
2477                                                                                 /* NSAP */
2478                                                                                 pbx_builtin_setvar_helper(c, "CALLEDSUBADDR",
2479                                                                                         (char *) e->ring.called_subaddress.data);
2480                                                                         }
2481                                                                         ast_channel_unlock(c);
2482                                                                 }
2483 #else
2484                                                                 if (!ast_strlen_zero(e->ring.callingsubaddr)) {
2485                                                                         pbx_builtin_setvar_helper(c, "CALLINGSUBADDR", e->ring.callingsubaddr);
2486                                                                 }
2487 #endif /* !defined(HAVE_PRI_SUBADDR) */
2488                                                                 if (e->ring.ani2 >= 0) {
2489                                                                         snprintf(ani2str, sizeof(ani2str), "%d", e->ring.ani2);
2490                                                                         pbx_builtin_setvar_helper(c, "ANI2", ani2str);
2491                                                                 }
2492
2493 #ifdef SUPPORT_USERUSER
2494                                                                 if (!ast_strlen_zero(e->ring.useruserinfo)) {
2495                                                                         pbx_builtin_setvar_helper(c, "USERUSERINFO", e->ring.useruserinfo);
2496                                                                 }
2497 #endif
2498
2499                                                                 snprintf(calledtonstr, sizeof(calledtonstr), "%d", e->ring.calledplan);
2500                                                                 pbx_builtin_setvar_helper(c, "CALLEDTON", calledtonstr);
2501                                                                 if (e->ring.redirectingreason >= 0) {
2502                                                                         /* This is now just a status variable.  Use REDIRECTING() dialplan function. */
2503                                                                         pbx_builtin_setvar_helper(c, "PRIREDIRECTREASON", redirectingreason2str(e->ring.redirectingreason));
2504                                                                 }
2505 #if defined(HAVE_PRI_REVERSE_CHARGE)
2506                                                                 pri->pvts[chanpos]->reverse_charging_indication = e->ring.reversecharge;
2507 #endif
2508 #if defined(HAVE_PRI_SETUP_KEYPAD)
2509                                                                 ast_copy_string(pri->pvts[chanpos]->keypad_digits,
2510                                                                         e->ring.keypad_digits,
2511                                                                         sizeof(pri->pvts[chanpos]->keypad_digits));
2512 #endif  /* defined(HAVE_PRI_SETUP_KEYPAD) */
2513
2514                                                                 sig_pri_handle_subcmds(pri, chanpos, e->e, e->ring.channel,
2515                                                                         e->ring.subcmds, e->ring.call);
2516                                                         }
2517                                                         if (c && !ast_pthread_create_detached(&threadid, NULL, pri_ss_thread, pri->pvts[chanpos])) {
2518                                                                 ast_verb(3, "Accepting overlap call from '%s' to '%s' on channel %d/%d, span %d\n",
2519                                                                         plancallingnum, S_OR(pri->pvts[chanpos]->exten, "<unspecified>"),
2520                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span);
2521                                                         } else {
2522                                                                 ast_log(LOG_WARNING, "Unable to start PBX on channel %d/%d, span %d\n",
2523                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span);
2524                                                                 if (c)
2525                                                                         ast_hangup(c);
2526                                                                 else {
2527                                                                         pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_SWITCH_CONGESTION);
2528                                                                         pri->pvts[chanpos]->call = NULL;
2529                                                                 }
2530                                                         }
2531                                                 } else {
2532                                                         /*
2533                                                          * Release the PRI lock while we create the channel
2534                                                          * so other threads can send D channel messages.
2535                                                          */
2536                                                         ast_mutex_unlock(&pri->lock);
2537                                                         c = sig_pri_new_ast_channel(pri->pvts[chanpos],
2538                                                                 AST_STATE_RING, 0,
2539                                                                 (e->ring.layer1 == PRI_LAYER_1_ALAW)
2540                                                                         ? SIG_PRI_ALAW : SIG_PRI_ULAW, e->ring.ctype,
2541                                                                 pri->pvts[chanpos]->exten, NULL);
2542                                                         ast_mutex_lock(&pri->lock);
2543                                                         if (c) {
2544                                                                 /*
2545                                                                  * It is reasonably safe to set the following
2546                                                                  * channel variables while the PRI and DAHDI private
2547                                                                  * structures are locked.  The PBX has not been
2548                                                                  * started yet and it is unlikely that any other task
2549                                                                  * will do anything with the channel we have just
2550                                                                  * created.
2551                                                                  */
2552 #if defined(HAVE_PRI_SUBADDR)
2553                                                                 if (e->ring.calling.subaddress.valid) {
2554                                                                         /* Set Calling Subaddress */
2555                                                                         sig_pri_lock_owner(pri, chanpos);
2556                                                                         sig_pri_set_subaddress(
2557                                                                                 &pri->pvts[chanpos]->owner->cid.subaddress,
2558                                                                                 &e->ring.calling.subaddress);
2559                                                                         if (!e->ring.calling.subaddress.type
2560                                                                                 && !ast_strlen_zero(
2561                                                                                         (char *) e->ring.calling.subaddress.data)) {
2562                                                                                 /* NSAP */
2563                                                                                 pbx_builtin_setvar_helper(c, "CALLINGSUBADDR",
2564                                                                                         (char *) e->ring.calling.subaddress.data);
2565                                                                         }
2566                                                                         ast_channel_unlock(c);
2567                                                                 }
2568                                                                 if (e->ring.called_subaddress.valid) {
2569                                                                         /* Set Called Subaddress */
2570                                                                         sig_pri_lock_owner(pri, chanpos);
2571                                                                         sig_pri_set_subaddress(
2572                                                                                 &pri->pvts[chanpos]->owner->cid.dialed_subaddress,
2573                                                                                 &e->ring.called_subaddress);
2574                                                                         if (!e->ring.called_subaddress.type
2575                                                                                 && !ast_strlen_zero(
2576                                                                                         (char *) e->ring.called_subaddress.data)) {
2577                                                                                 /* NSAP */
2578                                                                                 pbx_builtin_setvar_helper(c, "CALLEDSUBADDR",
2579                                                                                         (char *) e->ring.called_subaddress.data);
2580                                                                         }
2581                                                                         ast_channel_unlock(c);
2582                                                                 }
2583 #else
2584                                                                 if (!ast_strlen_zero(e->ring.callingsubaddr)) {
2585                                                                         pbx_builtin_setvar_helper(c, "CALLINGSUBADDR", e->ring.callingsubaddr);
2586                                                                 }
2587 #endif /* !defined(HAVE_PRI_SUBADDR) */
2588                                                                 if (e->ring.ani2 >= 0) {
2589                                                                         snprintf(ani2str, sizeof(ani2str), "%d", e->ring.ani2);
2590                                                                         pbx_builtin_setvar_helper(c, "ANI2", ani2str);
2591                                                                 }
2592
2593 #ifdef SUPPORT_USERUSER
2594                                                                 if (!ast_strlen_zero(e->ring.useruserinfo)) {
2595                                                                         pbx_builtin_setvar_helper(c, "USERUSERINFO", e->ring.useruserinfo);
2596                                                                 }
2597 #endif
2598
2599                                                                 if (e->ring.redirectingreason >= 0) {
2600                                                                         /* This is now just a status variable.  Use REDIRECTING() dialplan function. */
2601                                                                         pbx_builtin_setvar_helper(c, "PRIREDIRECTREASON", redirectingreason2str(e->ring.redirectingreason));
2602                                                                 }
2603 #if defined(HAVE_PRI_REVERSE_CHARGE)
2604                                                                 pri->pvts[chanpos]->reverse_charging_indication = e->ring.reversecharge;
2605 #endif
2606 #if defined(HAVE_PRI_SETUP_KEYPAD)
2607                                                                 ast_copy_string(pri->pvts[chanpos]->keypad_digits,
2608                                                                         e->ring.keypad_digits,
2609                                                                         sizeof(pri->pvts[chanpos]->keypad_digits));
2610 #endif  /* defined(HAVE_PRI_SETUP_KEYPAD) */
2611
2612                                                                 snprintf(calledtonstr, sizeof(calledtonstr), "%d", e->ring.calledplan);
2613                                                                 pbx_builtin_setvar_helper(c, "CALLEDTON", calledtonstr);
2614
2615                                                                 sig_pri_handle_subcmds(pri, chanpos, e->e, e->ring.channel,
2616                                                                         e->ring.subcmds, e->ring.call);
2617                                                         }
2618                                                         if (c && !ast_pbx_start(c)) {
2619                                                                 ast_verb(3, "Accepting call from '%s' to '%s' on channel %d/%d, span %d\n",
2620                                                                         plancallingnum, pri->pvts[chanpos]->exten,
2621                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span);
2622                                                                 sig_pri_set_echocanceller(pri->pvts[chanpos], 1);
2623                                                         } else {
2624                                                                 ast_log(LOG_WARNING, "Unable to start PBX on channel %d/%d, span %d\n",
2625                                                                         pri->pvts[chanpos]->logicalspan, pri->pvts[chanpos]->prioffset, pri->span);
2626                                                                 if (c) {
2627                                                                         ast_hangup(c);
2628                                                                 } else {
2629                                                                         pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_SWITCH_CONGESTION);
2630                                                                         pri->pvts[chanpos]->call = NULL;
2631                                                                 }
2632                                                         }
2633                                                 }
2634                                         } else {
2635                                                 ast_verb(3, "Extension '%s' in context '%s' from '%s' does not exist.  Rejecting call on channel %d/%d, span %d\n",
2636                                                         pri->pvts[chanpos]->exten, pri->pvts[chanpos]->context, pri->pvts[chanpos]->cid_num, pri->pvts[chanpos]->logicalspan,
2637                                                         pri->pvts[chanpos]->prioffset, pri->span);
2638                                                 pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_UNALLOCATED);
2639                                                 pri->pvts[chanpos]->call = NULL;
2640                                                 pri->pvts[chanpos]->exten[0] = '\0';
2641                                         }
2642                                         sig_pri_unlock_private(pri->pvts[chanpos]);
2643                                 } else {
2644                                         if (e->ring.flexible)
2645                                                 pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION);
2646                                         else
2647                                                 pri_hangup(pri->pri, e->ring.call, PRI_CAUSE_REQUESTED_CHAN_UNAVAIL);
2648                                 }
2649                                 break;
2650                         case PRI_EVENT_RINGING:
2651                                 chanpos = pri_find_principle(pri, e->ringing.channel, e->ringing.call);
2652                                 if (chanpos < 0) {
2653                                         ast_log(LOG_WARNING, "Ringing requested on unconfigured channel %d/%d span %d\n",
2654                                                 PRI_SPAN(e->ringing.channel), PRI_CHANNEL(e->ringing.channel), pri->span);
2655                                 } else {
2656                                         chanpos = pri_fixup_principle(pri, chanpos, e->ringing.call);
2657                                         if (chanpos < 0) {
2658                                                 ast_log(LOG_WARNING, "Ringing requested on channel %d/%d not in use on span %d\n",
2659                                                         PRI_SPAN(e->ringing.channel), PRI_CHANNEL(e->ringing.channel), pri->span);
2660                                         } else {
2661                                                 sig_pri_lock_private(pri->pvts[chanpos]);
2662
2663                                                 sig_pri_handle_subcmds(pri, chanpos, e->e, e->ringing.channel,
2664                                                         e->ringing.subcmds, e->ringing.call);
2665                                                 sig_pri_set_echocanceller(pri->pvts[chanpos], 1);
2666                                                 pri_queue_control(pri->pvts[chanpos], AST_CONTROL_RINGING, pri);
2667                                                 pri->pvts[chanpos]->alerting = 1;
2668
2669 #ifdef SUPPORT_USERUSER
2670                                                 if (!ast_strlen_zero(e->ringing.useruserinfo)) {
2671                                                         struct ast_channel *owner;
2672
2673                                                         sig_pri_lock_owner(pri, chanpos);
2674                                                         owner = pri->pvts[chanpos]->owner;
2675                                                         if (owner) {
2676                                                                 pbx_builtin_setvar_helper(owner, "USERUSERINFO",
2677                                                                         e->ringing.useruserinfo);
2678                                                                 ast_channel_unlock(owner);
2679                                                         }
2680                                                 }
2681 #endif
2682
2683                                                 sig_pri_unlock_private(pri->pvts[chanpos]);
2684                                         }
2685                                 }
2686                                 break;
2687                         case PRI_EVENT_PROGRESS:
2688                                 /* Get chan value if e->e is not PRI_EVNT_RINGING */
2689                                 chanpos = pri_find_principle(pri, e->proceeding.channel, e->proceeding.call);
2690                                 if (chanpos > -1) {
2691                                         sig_pri_lock_private(pri->pvts[chanpos]);
2692                                         sig_pri_handle_subcmds(pri, chanpos, e->e, e->proceeding.channel,
2693                                                 e->proceeding.subcmds, e->proceeding.call);
2694                                         if ((!pri->pvts[chanpos]->progress)
2695 #ifdef PRI_PROGRESS_MASK
2696                                                 || (e->proceeding.progressmask & PRI_PROG_INBAND_AVAILABLE)
2697 #else
2698                                                 || (e->proceeding.progress == 8)
2699 #endif
2700                                                 ) {
2701                                                 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_PROGRESS, };
2702
2703                                                 if (e->proceeding.cause > -1) {
2704                                                         ast_verb(3, "PROGRESS with cause code %d received\n", e->proceeding.cause);
2705
2706                                                         /* Work around broken, out of spec USER_BUSY cause in a progress message */
2707                                                         if (e->proceeding.cause == AST_CAUSE_USER_BUSY) {
2708                                                                 if (pri->pvts[chanpos]->owner) {
2709                                                                         ast_verb(3, "PROGRESS with 'user busy' received, signaling AST_CONTROL_BUSY instead of AST_CONTROL_PROGRESS\n");
2710
2711                                                                         pri->pvts[chanpos]->owner->hangupcause = e->proceeding.cause;
2712                                                                         f.subclass.integer = AST_CONTROL_BUSY;
2713                                                                 }
2714                                                         }
2715                                                 }
2716
2717                                                 ast_debug(1, "Queuing frame from PRI_EVENT_PROGRESS on channel %d/%d span %d\n",
2718