channel.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, 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 Channel Management
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/time.h>
  30 #include <signal.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <math.h>                       /* For PI */
  34
  35 #ifdef ZAPTEL_OPTIMIZATIONS
  36 #include <sys/ioctl.h>
  37 #ifdef __linux__
  38 #include <linux/zaptel.h>
  39 #else
  40 #include <zaptel.h>
  41 #endif /* __linux__ */
  42 #ifndef ZT_TIMERPING
  43 #error "You need newer zaptel!  Please cvs update zaptel"
  44 #endif
  45 #endif
  46
  47 #include "asterisk.h"
  48
  49 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  50
  51 #include "asterisk/pbx.h"
  52 #include "asterisk/frame.h"
  53 #include "asterisk/sched.h"
  54 #include "asterisk/options.h"
  55 #include "asterisk/channel.h"
  56 #include "asterisk/chanspy.h"
  57 #include "asterisk/musiconhold.h"
  58 #include "asterisk/logger.h"
  59 #include "asterisk/say.h"
  60 #include "asterisk/file.h"
  61 #include "asterisk/cli.h"
  62 #include "asterisk/translate.h"
  63 #include "asterisk/manager.h"
  64 #include "asterisk/chanvars.h"
  65 #include "asterisk/linkedlists.h"
  66 #include "asterisk/indications.h"
  67 #include "asterisk/monitor.h"
  68 #include "asterisk/causes.h"
  69 #include "asterisk/callerid.h"
  70 #include "asterisk/utils.h"
  71 #include "asterisk/lock.h"
  72 #include "asterisk/app.h"
  73 #include "asterisk/transcap.h"
  74 #include "asterisk/devicestate.h"
  75 #include "asterisk/sha1.h"
  76
  77 struct channel_spy_trans {
  78         int last_format;
  79         struct ast_trans_pvt *path;
  80 };
  81
  82 struct ast_channel_spy_list {
  83         struct channel_spy_trans read_translator;
  84         struct channel_spy_trans write_translator;
  85         AST_LIST_HEAD_NOLOCK(, ast_channel_spy) list;
  86 };
  87
  88 /* uncomment if you have problems with 'monitoring' synchronized files */
  89 #if 0
  90 #define MONITOR_CONSTANT_DELAY
  91 #define MONITOR_DELAY   150 * 8         /* 150 ms of MONITORING DELAY */
  92 #endif
  93
  94 /*! Prevent new channel allocation if shutting down. */
  95 static int shutting_down = 0;
  96
  97 AST_MUTEX_DEFINE_STATIC(uniquelock);
  98 static int uniqueint = 0;
  99
 100 unsigned long global_fin = 0, global_fout = 0;
 101
 102 /* XXX Lock appropriately in more functions XXX */
 103
 104 struct chanlist {
 105         const struct ast_channel_tech *tech;
 106         AST_LIST_ENTRY(chanlist) list;
 107 };
 108
 109 /*! the list of registered channel types */
 110 static AST_LIST_HEAD_NOLOCK_STATIC(backends, chanlist);
 111
 112 /*! the list of channels we have. Note that the lock for this list is used for
 113     both the channels list and the backends list.  */
 114 static AST_LIST_HEAD_STATIC(channels, ast_channel);
 115
 116 /*! map AST_CAUSE's to readable string representations */
 117 const struct ast_cause {
 118         int cause;
 119         const char *desc;
 120 } causes[] = {
 121         { AST_CAUSE_UNALLOCATED, "Unallocated (unassigned) number" },
 122         { AST_CAUSE_NO_ROUTE_TRANSIT_NET, "No route to specified transmit network" },
 123         { AST_CAUSE_NO_ROUTE_DESTINATION, "No route to destination" },
 124         { AST_CAUSE_CHANNEL_UNACCEPTABLE, "Channel unacceptable" },
 125         { AST_CAUSE_CALL_AWARDED_DELIVERED, "Call awarded and being delivered in an established channel" },
 126         { AST_CAUSE_NORMAL_CLEARING, "Normal Clearing" },
 127         { AST_CAUSE_USER_BUSY, "User busy" },
 128         { AST_CAUSE_NO_USER_RESPONSE, "No user responding" },
 129         { AST_CAUSE_NO_ANSWER, "User alerting, no answer" },
 130         { AST_CAUSE_CALL_REJECTED, "Call Rejected" },
 131         { AST_CAUSE_NUMBER_CHANGED, "Number changed" },
 132         { AST_CAUSE_DESTINATION_OUT_OF_ORDER, "Destination out of order" },
 133         { AST_CAUSE_INVALID_NUMBER_FORMAT, "Invalid number format" },
 134         { AST_CAUSE_FACILITY_REJECTED, "Facility rejected" },
 135         { AST_CAUSE_RESPONSE_TO_STATUS_ENQUIRY, "Response to STATus ENQuiry" },
 136         { AST_CAUSE_NORMAL_UNSPECIFIED, "Normal, unspecified" },
 137         { AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, "Circuit/channel congestion" },
 138         { AST_CAUSE_NETWORK_OUT_OF_ORDER, "Network out of order" },
 139         { AST_CAUSE_NORMAL_TEMPORARY_FAILURE, "Temporary failure" },
 140         { AST_CAUSE_SWITCH_CONGESTION, "Switching equipment congestion" },
 141         { AST_CAUSE_ACCESS_INFO_DISCARDED, "Access information discarded" },
 142         { AST_CAUSE_REQUESTED_CHAN_UNAVAIL, "Requested channel not available" },
 143         { AST_CAUSE_PRE_EMPTED, "Pre-empted" },
 144         { AST_CAUSE_FACILITY_NOT_SUBSCRIBED, "Facility not subscribed" },
 145         { AST_CAUSE_OUTGOING_CALL_BARRED, "Outgoing call barred" },
 146         { AST_CAUSE_INCOMING_CALL_BARRED, "Incoming call barred" },
 147         { AST_CAUSE_BEARERCAPABILITY_NOTAUTH, "Bearer capability not authorized" },
 148         { AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, "Bearer capability not available" },
 149         { AST_CAUSE_BEARERCAPABILITY_NOTIMPL, "Bearer capability not implemented" },
 150         { AST_CAUSE_CHAN_NOT_IMPLEMENTED, "Channel not implemented" },
 151         { AST_CAUSE_FACILITY_NOT_IMPLEMENTED, "Facility not implemented" },
 152         { AST_CAUSE_INVALID_CALL_REFERENCE, "Invalid call reference value" },
 153         { AST_CAUSE_INCOMPATIBLE_DESTINATION, "Incompatible destination" },
 154         { AST_CAUSE_INVALID_MSG_UNSPECIFIED, "Invalid message unspecified" },
 155         { AST_CAUSE_MANDATORY_IE_MISSING, "Mandatory information element is missing" },
 156         { AST_CAUSE_MESSAGE_TYPE_NONEXIST, "Message type nonexist." },
 157         { AST_CAUSE_WRONG_MESSAGE, "Wrong message" },
 158         { AST_CAUSE_IE_NONEXIST, "Info. element nonexist or not implemented" },
 159         { AST_CAUSE_INVALID_IE_CONTENTS, "Invalid information element contents" },
 160         { AST_CAUSE_WRONG_CALL_STATE, "Message not compatible with call state" },
 161         { AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, "Recover on timer expiry" },
 162         { AST_CAUSE_MANDATORY_IE_LENGTH_ERROR, "Mandatory IE length error" },
 163         { AST_CAUSE_PROTOCOL_ERROR, "Protocol error, unspecified" },
 164         { AST_CAUSE_INTERWORKING, "Interworking, unspecified" },
 165 };
 166
 167
 168 struct ast_variable *ast_channeltype_list(void)
 169 {
 170         struct chanlist *cl;
 171         struct ast_variable *var=NULL, *prev = NULL;
 172         AST_LIST_TRAVERSE(&backends, cl, list) {
 173                 if (prev)  {
 174                         if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description)))
 175                                 prev = prev->next;
 176                 } else {
 177                         var = ast_variable_new(cl->tech->type, cl->tech->description);
 178                         prev = var;
 179                 }
 180         }
 181         return var;
 182 }
 183
 184 static int show_channeltypes(int fd, int argc, char *argv[])
 185 {
 186 #define FORMAT  "%-10.10s  %-40.40s %-12.12s %-12.12s %-12.12s\n"
 187         struct chanlist *cl;
 188         int count_chan = 0;
 189
 190         ast_cli(fd, FORMAT, "Type", "Description",       "Devicestate", "Indications", "Transfer");
 191         ast_cli(fd, FORMAT, "----------", "-----------", "-----------", "-----------", "--------");
 192         if (AST_LIST_LOCK(&channels)) {
 193                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
 194                 return -1;
 195         }
 196         AST_LIST_TRAVERSE(&backends, cl, list) {
 197                 ast_cli(fd, FORMAT, cl->tech->type, cl->tech->description,
 198                         (cl->tech->devicestate) ? "yes" : "no",
 199                         (cl->tech->indicate) ? "yes" : "no",
 200                         (cl->tech->transfer) ? "yes" : "no");
 201                 count_chan++;
 202         }
 203         AST_LIST_UNLOCK(&channels);
 204         ast_cli(fd, "----------\n%d channel drivers registered.\n", count_chan);
 205         return RESULT_SUCCESS;
 206
 207 #undef FORMAT
 208
 209 }
 210
 211 static int show_channeltype(int fd, int argc, char *argv[])
 212 {
 213         struct chanlist *cl = NULL;
 214
 215         if (argc != 3)
 216                 return RESULT_SHOWUSAGE;
 217
 218         if (AST_LIST_LOCK(&channels)) {
 219                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
 220                 return RESULT_FAILURE;
 221         }
 222
 223         AST_LIST_TRAVERSE(&backends, cl, list) {
 224                 if (!strncasecmp(cl->tech->type, argv[2], strlen(cl->tech->type))) {
 225                         break;
 226                 }
 227         }
 228
 229
 230         if (!cl) {
 231                 ast_cli(fd, "\n%s is not a registered channel driver.\n", argv[2]);
 232                 AST_LIST_UNLOCK(&channels);
 233                 return RESULT_FAILURE;
 234         }
 235
 236         ast_cli(fd,
 237                 "-- Info about channel driver: %s --\n"
 238                 "  Device State: %s\n"
 239                 "    Indication: %s\n"
 240                 "     Transfer : %s\n"
 241                 "  Capabilities: %d\n"
 242                 "    Send Digit: %s\n"
 243                 "    Send HTML : %s\n"
 244                 " Image Support: %s\n"
 245                 "  Text Support: %s\n",
 246                 cl->tech->type,
 247                 (cl->tech->devicestate) ? "yes" : "no",
 248                 (cl->tech->indicate) ? "yes" : "no",
 249                 (cl->tech->transfer) ? "yes" : "no",
 250                 (cl->tech->capabilities) ? cl->tech->capabilities : -1,
 251                 (cl->tech->send_digit) ? "yes" : "no",
 252                 (cl->tech->send_html) ? "yes" : "no",
 253                 (cl->tech->send_image) ? "yes" : "no",
 254                 (cl->tech->send_text) ? "yes" : "no"
 255
 256         );
 257
 258         AST_LIST_UNLOCK(&channels);
 259         return RESULT_SUCCESS;
 260 }
 261
 262 static char *complete_channeltypes(const char *line, const char *word, int pos, int state)
 263 {
 264         struct chanlist *cl;
 265         int which = 0;
 266         int wordlen;
 267         char *ret = NULL;
 268
 269         if (pos != 2)
 270                 return NULL;
 271
 272         wordlen = strlen(word);
 273
 274         AST_LIST_TRAVERSE(&backends, cl, list) {
 275                 if (!strncasecmp(word, cl->tech->type, wordlen) && ++which > state) {
 276                         ret = strdup(cl->tech->type);
 277                         break;
 278                 }
 279         }
 280
 281         return ret;
 282 }
 283
 284 static char show_channeltypes_usage[] =
 285 "Usage: show channeltypes\n"
 286 "       Shows available channel types registered in your Asterisk server.\n";
 287
 288 static char show_channeltype_usage[] =
 289 "Usage: show channeltype <name>\n"
 290 "       Show details about the specified channel type, <name>.\n";
 291
 292 static struct ast_cli_entry cli_show_channeltypes =
 293         { { "show", "channeltypes", NULL }, show_channeltypes, "Show available channel types", show_channeltypes_usage };
 294
 295 static struct ast_cli_entry cli_show_channeltype =
 296         { { "show", "channeltype", NULL }, show_channeltype, "Give more details on that channel type", show_channeltype_usage, complete_channeltypes };
 297
 298 /*! \brief Checks to see if a channel is needing hang up */
 299 int ast_check_hangup(struct ast_channel *chan)
 300 {
 301         if (chan->_softhangup)          /* yes if soft hangup flag set */
 302                 return 1;
 303         if (!chan->tech_pvt)            /* yes if no technology private data */
 304                 return 1;
 305         if (!chan->whentohangup)        /* no if no hangup scheduled */
 306                 return 0;
 307         if (chan->whentohangup > time(NULL))    /* no if hangup time has not come yet. */
 308                 return 0;
 309         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;    /* record event */
 310         return 1;
 311 }
 312
 313 static int ast_check_hangup_locked(struct ast_channel *chan)
 314 {
 315         int res;
 316         ast_mutex_lock(&chan->lock);
 317         res = ast_check_hangup(chan);
 318         ast_mutex_unlock(&chan->lock);
 319         return res;
 320 }
 321
 322 /*! \brief Initiate system shutdown */
 323 void ast_begin_shutdown(int hangup)
 324 {
 325         struct ast_channel *c;
 326         shutting_down = 1;
 327         if (hangup) {
 328                 AST_LIST_LOCK(&channels);
 329                 AST_LIST_TRAVERSE(&channels, c, chan_list)
 330                         ast_softhangup(c, AST_SOFTHANGUP_SHUTDOWN);
 331                 AST_LIST_UNLOCK(&channels);
 332         }
 333 }
 334
 335 /*! \brief returns number of active/allocated channels */
 336 int ast_active_channels(void)
 337 {
 338         struct ast_channel *c;
 339         int cnt = 0;
 340         AST_LIST_LOCK(&channels);
 341         AST_LIST_TRAVERSE(&channels, c, chan_list)
 342                 cnt++;
 343         AST_LIST_UNLOCK(&channels);
 344         return cnt;
 345 }
 346
 347 /*! \brief Cancel a shutdown in progress */
 348 void ast_cancel_shutdown(void)
 349 {
 350         shutting_down = 0;
 351 }
 352
 353 /*! \brief Returns non-zero if Asterisk is being shut down */
 354 int ast_shutting_down(void)
 355 {
 356         return shutting_down;
 357 }
 358
 359 /*! \brief Set when to hangup channel */
 360 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset)
 361 {
 362         chan->whentohangup = offset ? time(NULL) + offset : 0;
 363         ast_queue_frame(chan, &ast_null_frame);
 364         return;
 365 }
 366
 367 /*! \brief Compare a offset with when to hangup channel */
 368 int ast_channel_cmpwhentohangup(struct ast_channel *chan, time_t offset)
 369 {
 370         time_t whentohangup;
 371
 372         if (chan->whentohangup == 0) {
 373                 return (offset == 0) ? 0 : -1;
 374         } else {
 375                 if (offset == 0)        /* XXX why is this special ? */
 376                         return (1);
 377                 else {
 378                         whentohangup = offset + time (NULL);
 379                         if (chan->whentohangup < whentohangup)
 380                                 return (1);
 381                         else if (chan->whentohangup == whentohangup)
 382                                 return (0);
 383                         else
 384                                 return (-1);
 385                 }
 386         }
 387 }
 388
 389 /*! \brief Register a new telephony channel in Asterisk */
 390 int ast_channel_register(const struct ast_channel_tech *tech)
 391 {
 392         struct chanlist *chan;
 393
 394         AST_LIST_LOCK(&channels);
 395
 396         AST_LIST_TRAVERSE(&backends, chan, list) {
 397                 if (!strcasecmp(tech->type, chan->tech->type)) {
 398                         ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
 399                         AST_LIST_UNLOCK(&channels);
 400                         return -1;
 401                 }
 402         }
 403
 404         if (!(chan = ast_malloc(sizeof(*chan)))) {
 405                 AST_LIST_UNLOCK(&channels);
 406                 return -1;
 407         }
 408         chan->tech = tech;
 409         AST_LIST_INSERT_HEAD(&backends, chan, list);
 410
 411         if (option_debug)
 412                 ast_log(LOG_DEBUG, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);
 413
 414         if (option_verbose > 1)
 415                 ast_verbose(VERBOSE_PREFIX_2 "Registered channel type '%s' (%s)\n", chan->tech->type,
 416                             chan->tech->description);
 417
 418         AST_LIST_UNLOCK(&channels);
 419         return 0;
 420 }
 421
 422 void ast_channel_unregister(const struct ast_channel_tech *tech)
 423 {
 424         struct chanlist *chan;
 425
 426         if (option_debug)
 427                 ast_log(LOG_DEBUG, "Unregistering channel type '%s'\n", tech->type);
 428
 429         AST_LIST_LOCK(&channels);
 430
 431         AST_LIST_TRAVERSE_SAFE_BEGIN(&backends, chan, list) {
 432                 if (chan->tech == tech) {
 433                         AST_LIST_REMOVE_CURRENT(&backends, list);
 434                         free(chan);
 435                         if (option_verbose > 1)
 436                                 ast_verbose(VERBOSE_PREFIX_2 "Unregistered channel type '%s'\n", tech->type);
 437                         break;
 438                 }
 439         }
 440         AST_LIST_TRAVERSE_SAFE_END
 441
 442         AST_LIST_UNLOCK(&channels);
 443 }
 444
 445 const struct ast_channel_tech *ast_get_channel_tech(const char *name)
 446 {
 447         struct chanlist *chanls;
 448         const struct ast_channel_tech *ret = NULL;
 449
 450         if (AST_LIST_LOCK(&channels)) {
 451                 ast_log(LOG_WARNING, "Unable to lock channel tech list\n");
 452                 return NULL;
 453         }
 454
 455         AST_LIST_TRAVERSE(&backends, chanls, list) {
 456                 if (!strcasecmp(name, chanls->tech->type)) {
 457                         ret = chanls->tech;
 458                         break;
 459                 }
 460         }
 461
 462         AST_LIST_UNLOCK(&channels);
 463
 464         return ret;
 465 }
 466
 467 /*! \brief Gives the string form of a given hangup cause */
 468 const char *ast_cause2str(int cause)
 469 {
 470         int x;
 471
 472         for (x=0; x < sizeof(causes) / sizeof(causes[0]); x++) {
 473                 if (causes[x].cause == cause)
 474                         return causes[x].desc;
 475         }
 476
 477         return "Unknown";
 478 }
 479
 480 /*! \brief Gives the string form of a given channel state */
 481 char *ast_state2str(int state)
 482 {
 483         /* XXX Not reentrant XXX */
 484         static char localtmp[256];
 485         switch(state) {
 486         case AST_STATE_DOWN:
 487                 return "Down";
 488         case AST_STATE_RESERVED:
 489                 return "Rsrvd";
 490         case AST_STATE_OFFHOOK:
 491                 return "OffHook";
 492         case AST_STATE_DIALING:
 493                 return "Dialing";
 494         case AST_STATE_RING:
 495                 return "Ring";
 496         case AST_STATE_RINGING:
 497                 return "Ringing";
 498         case AST_STATE_UP:
 499                 return "Up";
 500         case AST_STATE_BUSY:
 501                 return "Busy";
 502         default:
 503                 snprintf(localtmp, sizeof(localtmp), "Unknown (%d)\n", state);
 504                 return localtmp;
 505         }
 506 }
 507
 508 /*! \brief Gives the string form of a given transfer capability */
 509 char *ast_transfercapability2str(int transfercapability)
 510 {
 511         switch(transfercapability) {
 512         case AST_TRANS_CAP_SPEECH:
 513                 return "SPEECH";
 514         case AST_TRANS_CAP_DIGITAL:
 515                 return "DIGITAL";
 516         case AST_TRANS_CAP_RESTRICTED_DIGITAL:
 517                 return "RESTRICTED_DIGITAL";
 518         case AST_TRANS_CAP_3_1K_AUDIO:
 519                 return "3K1AUDIO";
 520         case AST_TRANS_CAP_DIGITAL_W_TONES:
 521                 return "DIGITAL_W_TONES";
 522         case AST_TRANS_CAP_VIDEO:
 523                 return "VIDEO";
 524         default:
 525                 return "UNKNOWN";
 526         }
 527 }
 528
 529 /*! \brief Pick the best codec */
 530 int ast_best_codec(int fmts)
 531 {
 532         /* This just our opinion, expressed in code.  We are asked to choose
 533            the best codec to use, given no information */
 534         int x;
 535         static int prefs[] =
 536         {
 537                 /*! Okay, ulaw is used by all telephony equipment, so start with it */
 538                 AST_FORMAT_ULAW,
 539                 /*! Unless of course, you're a silly European, so then prefer ALAW */
 540                 AST_FORMAT_ALAW,
 541                 /*! Okay, well, signed linear is easy to translate into other stuff */
 542                 AST_FORMAT_SLINEAR,
 543                 /*! G.726 is standard ADPCM */
 544                 AST_FORMAT_G726,
 545                 /*! ADPCM has great sound quality and is still pretty easy to translate */
 546                 AST_FORMAT_ADPCM,
 547                 /*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
 548                     translate and sounds pretty good */
 549                 AST_FORMAT_GSM,
 550                 /*! iLBC is not too bad */
 551                 AST_FORMAT_ILBC,
 552                 /*! Speex is free, but computationally more expensive than GSM */
 553                 AST_FORMAT_SPEEX,
 554                 /*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
 555                     to use it */
 556                 AST_FORMAT_LPC10,
 557                 /*! G.729a is faster than 723 and slightly less expensive */
 558                 AST_FORMAT_G729A,
 559                 /*! Down to G.723.1 which is proprietary but at least designed for voice */
 560                 AST_FORMAT_G723_1,
 561         };
 562
 563
 564         /* Find the first preferred codec in the format given */
 565         for (x=0; x < (sizeof(prefs) / sizeof(prefs[0]) ); x++)
 566                 if (fmts & prefs[x])
 567                         return prefs[x];
 568         ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts);
 569         return 0;
 570 }
 571
 572 static const struct ast_channel_tech null_tech = {
 573         .type = "NULL",
 574         .description = "Null channel (should not see this)",
 575 };
 576
 577 /*! \brief Create a new channel structure */
 578 struct ast_channel *ast_channel_alloc(int needqueue)
 579 {
 580         struct ast_channel *tmp;
 581         int x;
 582         int flags;
 583         struct varshead *headp;
 584
 585         /* If shutting down, don't allocate any new channels */
 586         if (shutting_down) {
 587                 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
 588                 return NULL;
 589         }
 590
 591         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
 592                 return NULL;
 593
 594         if (!(tmp->sched = sched_context_create())) {
 595                 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
 596                 free(tmp);
 597                 return NULL;
 598         }
 599
 600         ast_string_field_init(tmp, 128);
 601
 602         /* Don't bother initializing the last two FD here, because they
 603            will *always* be set just a few lines down (AST_TIMING_FD,
 604            AST_ALERT_FD). */
 605         for (x=0; x<AST_MAX_FDS - 2; x++)
 606                 tmp->fds[x] = -1;
 607
 608 #ifdef ZAPTEL_OPTIMIZATIONS
 609         tmp->timingfd = open("/dev/zap/timer", O_RDWR);
 610         if (tmp->timingfd > -1) {
 611                 /* Check if timing interface supports new
 612                    ping/pong scheme */
 613                 flags = 1;
 614                 if (!ioctl(tmp->timingfd, ZT_TIMERPONG, &flags))
 615                         needqueue = 0;
 616         }
 617 #else
 618         tmp->timingfd = -1;
 619 #endif
 620
 621         if (needqueue) {
 622                 if (pipe(tmp->alertpipe)) {
 623                         ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
 624                         free(tmp);
 625                         return NULL;
 626                 } else {
 627                         flags = fcntl(tmp->alertpipe[0], F_GETFL);
 628                         fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK);
 629                         flags = fcntl(tmp->alertpipe[1], F_GETFL);
 630                         fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK);
 631                 }
 632         } else  /* Make sure we've got it done right if they don't */
 633                 tmp->alertpipe[0] = tmp->alertpipe[1] = -1;
 634
 635         /* Always watch the alertpipe */
 636         tmp->fds[AST_ALERT_FD] = tmp->alertpipe[0];
 637         /* And timing pipe */
 638         tmp->fds[AST_TIMING_FD] = tmp->timingfd;
 639         ast_string_field_set(tmp, name, "**Unknown**");
 640         /* Initial state */
 641         tmp->_state = AST_STATE_DOWN;
 642         tmp->streamid = -1;
 643         tmp->appl = NULL;
 644         tmp->data = NULL;
 645         tmp->fin = global_fin;
 646         tmp->fout = global_fout;
 647         ast_mutex_lock(&uniquelock);
 648         if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME))
 649                 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL), uniqueint++);
 650         else
 651                 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME, (long) time(NULL), uniqueint++);
 652         ast_mutex_unlock(&uniquelock);
 653         headp = &tmp->varshead;
 654         ast_mutex_init(&tmp->lock);
 655         AST_LIST_HEAD_INIT_NOLOCK(headp);
 656         AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores);
 657         strcpy(tmp->context, "default");
 658         ast_string_field_set(tmp, language, defaultlanguage);
 659         strcpy(tmp->exten, "s");
 660         tmp->priority = 1;
 661         tmp->amaflags = ast_default_amaflags;
 662         ast_string_field_set(tmp, accountcode, ast_default_accountcode);
 663
 664         tmp->tech = &null_tech;
 665
 666         AST_LIST_LOCK(&channels);
 667         AST_LIST_INSERT_HEAD(&channels, tmp, chan_list);
 668         AST_LIST_UNLOCK(&channels);
 669         return tmp;
 670 }
 671
 672 /*! \brief Queue an outgoing media frame */
 673 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
 674 {
 675         struct ast_frame *f;
 676         struct ast_frame *prev, *cur;
 677         int blah = 1;
 678         int qlen = 0;
 679
 680         /* Build us a copy and free the original one */
 681         if (!(f = ast_frdup(fin))) {
 682                 ast_log(LOG_WARNING, "Unable to duplicate frame\n");
 683                 return -1;
 684         }
 685         ast_mutex_lock(&chan->lock);
 686         prev = NULL;
 687         for (cur = chan->readq; cur; cur = cur->next) {
 688                 if ((cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
 689                         /* Don't bother actually queueing anything after a hangup */
 690                         ast_frfree(f);
 691                         ast_mutex_unlock(&chan->lock);
 692                         return 0;
 693                 }
 694                 prev = cur;
 695                 qlen++;
 696         }
 697         /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
 698         if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen  > 128)) {
 699                 if (fin->frametype != AST_FRAME_VOICE) {
 700                         ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name);
 701                         CRASH;
 702                 } else {
 703                         ast_log(LOG_DEBUG, "Dropping voice to exceptionally long queue on %s\n", chan->name);
 704                         ast_frfree(f);
 705                         ast_mutex_unlock(&chan->lock);
 706                         return 0;
 707                 }
 708         }
 709         if (prev)
 710                 prev->next = f;
 711         else
 712                 chan->readq = f;
 713         if (chan->alertpipe[1] > -1) {
 714                 if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
 715                         ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
 716                                 chan->name, f->frametype, f->subclass, qlen, strerror(errno));
 717 #ifdef ZAPTEL_OPTIMIZATIONS
 718         } else if (chan->timingfd > -1) {
 719                 ioctl(chan->timingfd, ZT_TIMERPING, &blah);
 720 #endif
 721         } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
 722                 pthread_kill(chan->blocker, SIGURG);
 723         }
 724         ast_mutex_unlock(&chan->lock);
 725         return 0;
 726 }
 727
 728 /*! \brief Queue a hangup frame for channel */
 729 int ast_queue_hangup(struct ast_channel *chan)
 730 {
 731         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
 732         /* Yeah, let's not change a lock-critical value without locking */
 733         if (!ast_mutex_trylock(&chan->lock)) {
 734                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
 735                 ast_mutex_unlock(&chan->lock);
 736         }
 737         return ast_queue_frame(chan, &f);
 738 }
 739
 740 /*! \brief Queue a control frame */
 741 int ast_queue_control(struct ast_channel *chan, int control)
 742 {
 743         struct ast_frame f = { AST_FRAME_CONTROL, };
 744         f.subclass = control;
 745         return ast_queue_frame(chan, &f);
 746 }
 747
 748 /*! \brief Set defer DTMF flag on channel */
 749 int ast_channel_defer_dtmf(struct ast_channel *chan)
 750 {
 751         int pre = 0;
 752
 753         if (chan) {
 754                 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
 755                 ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
 756         }
 757         return pre;
 758 }
 759
 760 /*! \brief Unset defer DTMF flag on channel */
 761 void ast_channel_undefer_dtmf(struct ast_channel *chan)
 762 {
 763         if (chan)
 764                 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
 765 }
 766
 767 /*!
 768  * \brief Helper function to find channels.
 769  *
 770  * It supports these modes:
 771  *
 772  * prev != NULL : get channel next in list after prev
 773  * name != NULL : get channel with matching name
 774  * name != NULL && namelen != 0 : get channel whose name starts with prefix
 775  * exten != NULL : get channel whose exten or macroexten matches
 776  * context != NULL && exten != NULL : get channel whose context or macrocontext
 777  *
 778  * It returns with the channel's lock held. If getting the individual lock fails,
 779  * unlock and retry quickly up to 10 times, then give up.
 780  *
 781  * \note XXX Note that this code has cost O(N) because of the need to verify
 782  * that the object is still on the global list.
 783  *
 784  * \note XXX also note that accessing fields (e.g. c->name in ast_log())
 785  * can only be done with the lock held or someone could delete the
 786  * object while we work on it. This causes some ugliness in the code.
 787  * Note that removing the first ast_log() may be harmful, as it would
 788  * shorten the retry period and possibly cause failures.
 789  * We should definitely go for a better scheme that is deadlock-free.
 790  */
 791 static struct ast_channel *channel_find_locked(const struct ast_channel *prev,
 792                                                const char *name, const int namelen,
 793                                                const char *context, const char *exten)
 794 {
 795         const char *msg = prev ? "deadlock" : "initial deadlock";
 796         int retries, done;
 797         struct ast_channel *c;
 798
 799         for (retries = 0; retries < 10; retries++) {
 800                 AST_LIST_LOCK(&channels);
 801                 AST_LIST_TRAVERSE(&channels, c, chan_list) {
 802                         if (!prev) {
 803                                 /* want head of list */
 804                                 if (!name && !exten)
 805                                         break;
 806                                 if (name) {
 807                                         /* want match by full name */
 808                                         if (!namelen) {
 809                                                 if (!strcasecmp(c->name, name))
 810                                                         break;
 811                                                 else
 812                                                         continue;
 813                                         }
 814                                         /* want match by name prefix */
 815                                         if (!strncasecmp(c->name, name, namelen))
 816                                                 break;
 817                                 } else if (exten) {
 818                                         /* want match by context and exten */
 819                                         if (context && (strcasecmp(c->context, context) &&
 820                                                         strcasecmp(c->macrocontext, context)))
 821                                                 continue;
 822                                         /* match by exten */
 823                                         if (strcasecmp(c->exten, exten) &&
 824                                             strcasecmp(c->macroexten, exten))
 825                                                 continue;
 826                                         else
 827                                                 break;
 828                                 }
 829                         } else if (c == prev) { /* found, return c->next */
 830                                 c = AST_LIST_NEXT(c, chan_list);
 831                                 break;
 832                         }
 833                 }
 834                 /* exit if chan not found or mutex acquired successfully */
 835                 done = (c == NULL) || (ast_mutex_trylock(&c->lock) == 0);
 836                 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
 837                 if (!done && c)
 838                         ast_log(LOG_DEBUG, "Avoiding %s for '%s'\n", msg, c->name);
 839                 AST_LIST_UNLOCK(&channels);
 840                 if (done)
 841                         return c;
 842                 usleep(1);
 843         }
 844         /*
 845          * c is surely not null, but we don't have the lock so cannot
 846          * access c->name
 847          */
 848         ast_log(LOG_WARNING, "Avoided %s for '%p', %d retries!\n",
 849                 msg, c, retries);
 850
 851         return NULL;
 852 }
 853
 854 /*! \brief Browse channels in use */
 855 struct ast_channel *ast_channel_walk_locked(const struct ast_channel *prev)
 856 {
 857         return channel_find_locked(prev, NULL, 0, NULL, NULL);
 858 }
 859
 860 /*! \brief Get channel by name and lock it */
 861 struct ast_channel *ast_get_channel_by_name_locked(const char *name)
 862 {
 863         return channel_find_locked(NULL, name, 0, NULL, NULL);
 864 }
 865
 866 /*! \brief Get channel by name prefix and lock it */
 867 struct ast_channel *ast_get_channel_by_name_prefix_locked(const char *name, const int namelen)
 868 {
 869         return channel_find_locked(NULL, name, namelen, NULL, NULL);
 870 }
 871
 872 /*! \brief Get next channel by name prefix and lock it */
 873 struct ast_channel *ast_walk_channel_by_name_prefix_locked(struct ast_channel *chan, const char *name, const int namelen)
 874 {
 875         return channel_find_locked(chan, name, namelen, NULL, NULL);
 876 }
 877
 878 /*! \brief Get channel by exten (and optionally context) and lock it */
 879 struct ast_channel *ast_get_channel_by_exten_locked(const char *exten, const char *context)
 880 {
 881         return channel_find_locked(NULL, NULL, 0, context, exten);
 882 }
 883
 884 /*! \brief Wait, look for hangups and condition arg */
 885 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data)
 886 {
 887         struct ast_frame *f;
 888
 889         while (ms > 0) {
 890                 if (cond && ((*cond)(data) == 0))
 891                         return 0;
 892                 ms = ast_waitfor(chan, ms);
 893                 if (ms < 0)
 894                         return -1;
 895                 if (ms > 0) {
 896                         f = ast_read(chan);
 897                         if (!f)
 898                                 return -1;
 899                         ast_frfree(f);
 900                 }
 901         }
 902         return 0;
 903 }
 904
 905 /*! \brief Wait, look for hangups */
 906 int ast_safe_sleep(struct ast_channel *chan, int ms)
 907 {
 908         return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
 909 }
 910
 911 static void free_cid(struct ast_callerid *cid)
 912 {
 913         if (cid->cid_dnid)
 914                 free(cid->cid_dnid);
 915         if (cid->cid_num)
 916                 free(cid->cid_num);
 917         if (cid->cid_name)
 918                 free(cid->cid_name);
 919         if (cid->cid_ani)
 920                 free(cid->cid_ani);
 921         if (cid->cid_rdnis)
 922                 free(cid->cid_rdnis);
 923 }
 924
 925 /*! \brief Free a channel structure */
 926 void ast_channel_free(struct ast_channel *chan)
 927 {
 928         int fd;
 929         struct ast_var_t *vardata;
 930         struct ast_frame *f, *fp;
 931         struct varshead *headp;
 932         struct ast_datastore *datastore = NULL;
 933         char name[AST_CHANNEL_NAME];
 934
 935         headp=&chan->varshead;
 936
 937         AST_LIST_LOCK(&channels);
 938         AST_LIST_REMOVE(&channels, chan, chan_list);
 939         /* Lock and unlock the channel just to be sure nobody
 940            has it locked still */
 941         ast_mutex_lock(&chan->lock);
 942         ast_mutex_unlock(&chan->lock);
 943         if (chan->tech_pvt) {
 944                 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
 945                 free(chan->tech_pvt);
 946         }
 947
 948         if (chan->sched)
 949                 sched_context_destroy(chan->sched);
 950
 951         ast_copy_string(name, chan->name, sizeof(name));
 952
 953         /* Stop monitoring */
 954         if (chan->monitor) {
 955                 chan->monitor->stop( chan, 0 );
 956         }
 957
 958         /* If there is native format music-on-hold state, free it */
 959         if(chan->music_state)
 960                 ast_moh_cleanup(chan);
 961
 962         /* Free translators */
 963         if (chan->readtrans)
 964                 ast_translator_free_path(chan->readtrans);
 965         if (chan->writetrans)
 966                 ast_translator_free_path(chan->writetrans);
 967         if (chan->pbx)
 968                 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
 969         free_cid(&chan->cid);
 970         ast_mutex_destroy(&chan->lock);
 971         /* Close pipes if appropriate */
 972         if ((fd = chan->alertpipe[0]) > -1)
 973                 close(fd);
 974         if ((fd = chan->alertpipe[1]) > -1)
 975                 close(fd);
 976         if ((fd = chan->timingfd) > -1)
 977                 close(fd);
 978         f = chan->readq;
 979         chan->readq = NULL;
 980         while(f) {
 981                 fp = f;
 982                 f = f->next;
 983                 ast_frfree(fp);
 984         }
 985
 986         /* Get rid of each of the data stores on the channel */
 987         while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
 988                 /* Free the data store */
 989                 ast_channel_datastore_free(datastore);
 990         AST_LIST_HEAD_INIT_NOLOCK(&chan->datastores);
 991
 992         /* loop over the variables list, freeing all data and deleting list items */
 993         /* no need to lock the list, as the channel is already locked */
 994
 995         while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
 996                 ast_var_delete(vardata);
 997
 998         ast_string_field_free_all(chan);
 999         free(chan);
1000         AST_LIST_UNLOCK(&channels);
1001
1002         ast_device_state_changed_literal(name);
1003 }
1004
1005 struct ast_datastore *ast_channel_datastore_alloc(const struct ast_datastore_info *info, char *uid)
1006 {
1007         struct ast_datastore *datastore = NULL;
1008
1009         /* Make sure we at least have type so we can identify this */
1010         if (info == NULL) {
1011                 return NULL;
1012         }
1013
1014         /* Allocate memory for datastore and clear it */
1015         datastore = ast_calloc(1, sizeof(*datastore));
1016         if (datastore == NULL) {
1017                 return NULL;
1018         }
1019
1020         datastore->info = info;
1021
1022         if (uid != NULL) {
1023                 datastore->uid = ast_strdup(uid);
1024         }
1025
1026         return datastore;
1027 }
1028
1029 int ast_channel_datastore_free(struct ast_datastore *datastore)
1030 {
1031         int res = 0;
1032
1033         /* Using the destroy function (if present) destroy the data */
1034         if (datastore->info->destroy != NULL && datastore->data != NULL) {
1035                 datastore->info->destroy(datastore->data);
1036                 datastore->data = NULL;
1037         }
1038
1039         /* Free allocated UID memory */
1040         if (datastore->uid != NULL) {
1041                 free(datastore->uid);
1042                 datastore->uid = NULL;
1043         }
1044
1045         /* Finally free memory used by ourselves */
1046         free(datastore);
1047         datastore = NULL;
1048
1049         return res;
1050 }
1051
1052 int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
1053 {
1054         int res = 0;
1055
1056         AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
1057
1058         return res;
1059 }
1060
1061 int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
1062 {
1063         struct ast_datastore *datastore2 = NULL;
1064         int res = -1;
1065
1066         /* Find our position and remove ourselves */
1067         AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore2, entry) {
1068                 if (datastore2 == datastore) {
1069                         AST_LIST_REMOVE_CURRENT(&chan->datastores, entry);
1070                         res = 0;
1071                         break;
1072                 }
1073         }
1074         AST_LIST_TRAVERSE_SAFE_END
1075
1076         return res;
1077 }
1078
1079 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, char *uid)
1080 {
1081         struct ast_datastore *datastore = NULL;
1082
1083         if (info == NULL)
1084                 return NULL;
1085
1086         AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
1087                 if (datastore->info == info) {
1088                         if (uid != NULL && datastore->uid != NULL) {
1089                                 if (!strcasecmp(uid, datastore->uid)) {
1090                                         /* Matched by type AND uid */
1091                                         break;
1092                                 }
1093                         } else {
1094                                 /* Matched by type at least */
1095                                 break;
1096                         }
1097                 }
1098         }
1099         AST_LIST_TRAVERSE_SAFE_END
1100
1101         return datastore;
1102 }
1103
1104 int ast_channel_spy_add(struct ast_channel *chan, struct ast_channel_spy *spy)
1105 {
1106         if (!ast_test_flag(spy, CHANSPY_FORMAT_AUDIO)) {
1107                 ast_log(LOG_WARNING, "Could not add channel spy '%s' to channel '%s', only audio format spies are supported.\n",
1108                         spy->type, chan->name);
1109                 return -1;
1110         }
1111
1112         if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST) && (spy->read_queue.format != AST_FORMAT_SLINEAR)) {
1113                 ast_log(LOG_WARNING, "Cannot provide volume adjustment on '%s' format spies\n",
1114                         ast_getformatname(spy->read_queue.format));
1115                 return -1;
1116         }
1117
1118         if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST) && (spy->write_queue.format != AST_FORMAT_SLINEAR)) {
1119                 ast_log(LOG_WARNING, "Cannot provide volume adjustment on '%s' format spies\n",
1120                         ast_getformatname(spy->write_queue.format));
1121                 return -1;
1122         }
1123
1124         if (ast_test_flag(spy, CHANSPY_MIXAUDIO) &&
1125             ((spy->read_queue.format != AST_FORMAT_SLINEAR) ||
1126              (spy->write_queue.format != AST_FORMAT_SLINEAR))) {
1127                 ast_log(LOG_WARNING, "Cannot provide audio mixing on '%s'-'%s' format spies\n",
1128                         ast_getformatname(spy->read_queue.format), ast_getformatname(spy->write_queue.format));
1129                 return -1;
1130         }
1131
1132         if (!chan->spies) {
1133                 if (!(chan->spies = ast_calloc(1, sizeof(*chan->spies)))) {
1134                         return -1;
1135                 }
1136
1137                 AST_LIST_HEAD_INIT_NOLOCK(&chan->spies->list);
1138                 AST_LIST_INSERT_HEAD(&chan->spies->list, spy, list);
1139         } else {
1140                 AST_LIST_INSERT_TAIL(&chan->spies->list, spy, list);
1141         }
1142
1143         if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) {
1144                 ast_cond_init(&spy->trigger, NULL);
1145                 ast_set_flag(spy, CHANSPY_TRIGGER_READ);
1146                 ast_clear_flag(spy, CHANSPY_TRIGGER_WRITE);
1147         }
1148
1149         ast_log(LOG_DEBUG, "Spy %s added to channel %s\n",
1150                 spy->type, chan->name);
1151
1152         return 0;
1153 }
1154
1155 void ast_channel_spy_stop_by_type(struct ast_channel *chan, const char *type)
1156 {
1157         struct ast_channel_spy *spy;
1158
1159         if (!chan->spies)
1160                 return;
1161
1162         AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
1163                 ast_mutex_lock(&spy->lock);
1164                 if ((spy->type == type) && (spy->status == CHANSPY_RUNNING)) {
1165                         spy->status = CHANSPY_STOP;
1166                         if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
1167                                 ast_cond_signal(&spy->trigger);
1168                 }
1169                 ast_mutex_unlock(&spy->lock);
1170         }
1171 }
1172
1173 void ast_channel_spy_trigger_wait(struct ast_channel_spy *spy)
1174 {
1175         ast_cond_wait(&spy->trigger, &spy->lock);
1176 }
1177
1178 void ast_channel_spy_remove(struct ast_channel *chan, struct ast_channel_spy *spy)
1179 {
1180         struct ast_frame *f;
1181
1182         if (!chan->spies)
1183                 return;
1184
1185         AST_LIST_REMOVE(&chan->spies->list, spy, list);
1186
1187         ast_mutex_lock(&spy->lock);
1188
1189         for (f = spy->read_queue.head; f; f = spy->read_queue.head) {
1190                 spy->read_queue.head = f->next;
1191                 ast_frfree(f);
1192         }
1193         for (f = spy->write_queue.head; f; f = spy->write_queue.head) {
1194                 spy->write_queue.head = f->next;
1195                 ast_frfree(f);
1196         }
1197
1198         if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
1199                 ast_cond_destroy(&spy->trigger);
1200
1201         ast_mutex_unlock(&spy->lock);
1202
1203         ast_log(LOG_DEBUG, "Spy %s removed from channel %s\n",
1204                 spy->type, chan->name);
1205
1206         if (AST_LIST_EMPTY(&chan->spies->list)) {
1207                 if (chan->spies->read_translator.path)
1208                         ast_translator_free_path(chan->spies->read_translator.path);
1209                 if (chan->spies->write_translator.path)
1210                         ast_translator_free_path(chan->spies->write_translator.path);
1211                 free(chan->spies);
1212                 chan->spies = NULL;
1213         }
1214 }
1215
1216 static void detach_spies(struct ast_channel *chan)
1217 {
1218         struct ast_channel_spy *spy;
1219
1220         if (!chan->spies)
1221                 return;
1222
1223         /* Marking the spies as done is sufficient.  Chanspy or spy users will get the picture. */
1224         AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
1225                 ast_mutex_lock(&spy->lock);
1226                 if (spy->status == CHANSPY_RUNNING)
1227                         spy->status = CHANSPY_DONE;
1228                 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
1229                         ast_cond_signal(&spy->trigger);
1230                 ast_mutex_unlock(&spy->lock);
1231         }
1232
1233         AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->spies->list, spy, list)
1234                 ast_channel_spy_remove(chan, spy);
1235         AST_LIST_TRAVERSE_SAFE_END;
1236 }
1237
1238 /*! \brief Softly hangup a channel, don't lock */
1239 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
1240 {
1241         if (option_debug)
1242                 ast_log(LOG_DEBUG, "Soft-Hanging up channel '%s'\n", chan->name);
1243         /* Inform channel driver that we need to be hung up, if it cares */
1244         chan->_softhangup |= cause;
1245         ast_queue_frame(chan, &ast_null_frame);
1246         /* Interrupt any poll call or such */
1247         if (ast_test_flag(chan, AST_FLAG_BLOCKING))
1248                 pthread_kill(chan->blocker, SIGURG);
1249         return 0;
1250 }
1251
1252 /*! \brief Softly hangup a channel, lock */
1253 int ast_softhangup(struct ast_channel *chan, int cause)
1254 {
1255         int res;
1256         ast_mutex_lock(&chan->lock);
1257         res = ast_softhangup_nolock(chan, cause);
1258         ast_mutex_unlock(&chan->lock);
1259         return res;
1260 }
1261
1262 enum spy_direction {
1263         SPY_READ,
1264         SPY_WRITE,
1265 };
1266
1267 #define SPY_QUEUE_SAMPLE_LIMIT 4000                     /* half of one second */
1268
1269 static void queue_frame_to_spies(struct ast_channel *chan, struct ast_frame *f, enum spy_direction dir)
1270 {
1271         struct ast_frame *translated_frame = NULL;
1272         struct ast_channel_spy *spy;
1273         struct ast_channel_spy_queue *queue;
1274         struct channel_spy_trans *trans;
1275         struct ast_frame *last;
1276
1277         trans = (dir == SPY_READ) ? &chan->spies->read_translator : &chan->spies->write_translator;
1278
1279         AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
1280                 ast_mutex_lock(&spy->lock);
1281
1282                 queue = (dir == SPY_READ) ? &spy->read_queue : &spy->write_queue;
1283
1284                 if ((queue->format == AST_FORMAT_SLINEAR) && (f->subclass != AST_FORMAT_SLINEAR)) {
1285                         if (!translated_frame) {
1286                                 if (trans->path && (trans->last_format != f->subclass)) {
1287                                         ast_translator_free_path(trans->path);
1288                                         trans->path = NULL;
1289                                 }
1290                                 if (!trans->path) {
1291                                         ast_log(LOG_DEBUG, "Building translator from %s to SLINEAR for spies on channel %s\n",
1292                                                 ast_getformatname(f->subclass), chan->name);
1293                                         if ((trans->path = ast_translator_build_path(AST_FORMAT_SLINEAR, f->subclass)) == NULL) {
1294                                                 ast_log(LOG_WARNING, "Cannot build a path from %s to %s\n",
1295                                                         ast_getformatname(f->subclass), ast_getformatname(AST_FORMAT_SLINEAR));
1296                                                 ast_mutex_unlock(&spy->lock);
1297                                                 continue;
1298                                         } else {
1299                                                 trans->last_format = f->subclass;
1300                                         }
1301                                 }
1302                                 if (!(translated_frame = ast_translate(trans->path, f, 0))) {
1303                                         ast_log(LOG_ERROR, "Translation to %s failed, dropping frame for spies\n",
1304                                                 ast_getformatname(AST_FORMAT_SLINEAR));
1305                                         ast_mutex_unlock(&spy->lock);
1306                                         break;
1307                                 }
1308                         }
1309
1310                         for (last = queue->head; last && last->next; last = last->next);
1311                         if (last)
1312                                 last->next = ast_frdup(translated_frame);
1313                         else
1314                                 queue->head = ast_frdup(translated_frame);
1315                 } else {
1316                         if (f->subclass != queue->format) {
1317                                 ast_log(LOG_WARNING, "Spy '%s' on channel '%s' wants format '%s', but frame is '%s', dropping\n",
1318                                         spy->type, chan->name,
1319                                         ast_getformatname(queue->format), ast_getformatname(f->subclass));
1320                                 ast_mutex_unlock(&spy->lock);
1321                                 continue;
1322                         }
1323
1324                         for (last = queue->head; last && last->next; last = last->next);
1325                         if (last)
1326                                 last->next = ast_frdup(f);
1327                         else
1328                                 queue->head = ast_frdup(f);
1329                 }
1330
1331                 queue->samples += f->samples;
1332
1333                 if (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
1334                         if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) {
1335                                 switch (ast_test_flag(spy, CHANSPY_TRIGGER_MODE)) {
1336                                 case CHANSPY_TRIGGER_READ:
1337                                         if (dir == SPY_WRITE) {
1338                                                 ast_set_flag(spy, CHANSPY_TRIGGER_WRITE);
1339                                                 ast_clear_flag(spy, CHANSPY_TRIGGER_READ);
1340                                                 if (option_debug)
1341                                                         ast_log(LOG_DEBUG, "Switching spy '%s' on '%s' to write-trigger mode\n",
1342                                                                 spy->type, chan->name);
1343                                         }
1344                                         break;
1345                                 case CHANSPY_TRIGGER_WRITE:
1346                                         if (dir == SPY_READ) {
1347                                                 ast_set_flag(spy, CHANSPY_TRIGGER_READ);
1348                                                 ast_clear_flag(spy, CHANSPY_TRIGGER_WRITE);
1349                                                 if (option_debug)
1350                                                         ast_log(LOG_DEBUG, "Switching spy '%s' on '%s' to read-trigger mode\n",
1351                                                                 spy->type, chan->name);
1352                                         }
1353                                         break;
1354                                 }
1355                                 if (option_debug)
1356                                         ast_log(LOG_DEBUG, "Triggering queue flush for spy '%s' on '%s'\n",
1357                                                 spy->type, chan->name);
1358                                 ast_set_flag(spy, CHANSPY_TRIGGER_FLUSH);
1359                                 ast_cond_signal(&spy->trigger);
1360                         } else {
1361                                 if (option_debug)
1362                                         ast_log(LOG_DEBUG, "Spy '%s' on channel '%s' %s queue too long, dropping frames\n",
1363                                                 spy->type, chan->name, (dir == SPY_READ) ? "read" : "write");
1364                                 while (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
1365                                         struct ast_frame *drop = queue->head;
1366
1367                                         queue->samples -= drop->samples;
1368                                         queue->head = drop->next;
1369                                         ast_frfree(drop);
1370                                 }
1371                         }
1372                 } else {
1373                         switch (ast_test_flag(spy, CHANSPY_TRIGGER_MODE)) {
1374                         case CHANSPY_TRIGGER_READ:
1375                                 if (dir == SPY_READ)
1376                                         ast_cond_signal(&spy->trigger);
1377                                 break;
1378                         case CHANSPY_TRIGGER_WRITE:
1379                                 if (dir == SPY_WRITE)
1380                                         ast_cond_signal(&spy->trigger);
1381                                 break;
1382                         }
1383                 }
1384
1385                 ast_mutex_unlock(&spy->lock);
1386         }
1387
1388         if (translated_frame)
1389                 ast_frfree(translated_frame);
1390 }
1391
1392 static void free_translation(struct ast_channel *clone)
1393 {
1394         if (clone->writetrans)
1395                 ast_translator_free_path(clone->writetrans);
1396         if (clone->readtrans)
1397                 ast_translator_free_path(clone->readtrans);
1398         clone->writetrans = NULL;
1399         clone->readtrans = NULL;
1400         clone->rawwriteformat = clone->nativeformats;
1401         clone->rawreadformat = clone->nativeformats;
1402 }
1403
1404 /*! \brief Hangup a channel */
1405 int ast_hangup(struct ast_channel *chan)
1406 {
1407         int res = 0;
1408
1409         /* Don't actually hang up a channel that will masquerade as someone else, or
1410            if someone is going to masquerade as us */
1411         ast_mutex_lock(&chan->lock);
1412
1413         detach_spies(chan);             /* get rid of spies */
1414
1415         if (chan->masq) {
1416                 if (ast_do_masquerade(chan))
1417                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1418         }
1419
1420         if (chan->masq) {
1421                 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
1422                 ast_mutex_unlock(&chan->lock);
1423                 return 0;
1424         }
1425         /* If this channel is one which will be masqueraded into something,
1426            mark it as a zombie already, so we know to free it later */
1427         if (chan->masqr) {
1428                 ast_set_flag(chan, AST_FLAG_ZOMBIE);
1429                 ast_mutex_unlock(&chan->lock);
1430                 return 0;
1431         }
1432         free_translation(chan);
1433         if (chan->stream)               /* Close audio stream */
1434                 ast_closestream(chan->stream);
1435         if (chan->vstream)              /* Close video stream */
1436                 ast_closestream(chan->vstream);
1437         if (chan->sched) {
1438                 sched_context_destroy(chan->sched);
1439                 chan->sched = NULL;
1440         }
1441
1442         if (chan->generatordata)        /* Clear any tone stuff remaining */
1443                 chan->generator->release(chan, chan->generatordata);
1444         chan->generatordata = NULL;
1445         chan->generator = NULL;
1446         if (chan->cdr) {                /* End the CDR if it hasn't already */
1447                 ast_cdr_end(chan->cdr);
1448                 ast_cdr_detach(chan->cdr);      /* Post and Free the CDR */
1449                 chan->cdr = NULL;
1450         }
1451         if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1452                 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
1453                                         "is blocked by thread %ld in procedure %s!  Expect a failure\n",
1454                                         (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
1455                 CRASH;
1456         }
1457         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
1458                 if (option_debug)
1459                         ast_log(LOG_DEBUG, "Hanging up channel '%s'\n", chan->name);
1460                 if (chan->tech->hangup)
1461                         res = chan->tech->hangup(chan);
1462         } else {
1463                 if (option_debug)
1464                         ast_log(LOG_DEBUG, "Hanging up zombie '%s'\n", chan->name);
1465         }
1466
1467         ast_mutex_unlock(&chan->lock);
1468         manager_event(EVENT_FLAG_CALL, "Hangup",
1469                         "Channel: %s\r\n"
1470                         "Uniqueid: %s\r\n"
1471                         "Cause: %d\r\n"
1472                         "Cause-txt: %s\r\n",
1473                         chan->name,
1474                         chan->uniqueid,
1475                         chan->hangupcause,
1476                         ast_cause2str(chan->hangupcause)
1477                         );
1478         ast_channel_free(chan);
1479         return res;
1480 }
1481
1482 int ast_answer(struct ast_channel *chan)
1483 {
1484         int res = 0;
1485         ast_mutex_lock(&chan->lock);
1486         /* Stop if we're a zombie or need a soft hangup */
1487         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1488                 ast_mutex_unlock(&chan->lock);
1489                 return -1;
1490         }
1491         switch(chan->_state) {
1492         case AST_STATE_RINGING:
1493         case AST_STATE_RING:
1494                 if (chan->tech->answer)
1495                         res = chan->tech->answer(chan);
1496                 ast_setstate(chan, AST_STATE_UP);
1497                 if (chan->cdr)
1498                         ast_cdr_answer(chan->cdr);
1499                 ast_mutex_unlock(&chan->lock);
1500                 return res;
1501                 break;
1502         case AST_STATE_UP:
1503                 if (chan->cdr)
1504                         ast_cdr_answer(chan->cdr);
1505                 break;
1506         }
1507         ast_mutex_unlock(&chan->lock);
1508         return 0;
1509 }
1510
1511 void ast_deactivate_generator(struct ast_channel *chan)
1512 {
1513         ast_mutex_lock(&chan->lock);
1514         if (chan->generatordata) {
1515                 if (chan->generator && chan->generator->release)
1516                         chan->generator->release(chan, chan->generatordata);
1517                 chan->generatordata = NULL;
1518                 chan->generator = NULL;
1519                 chan->fds[AST_GENERATOR_FD] = -1;
1520                 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1521                 ast_settimeout(chan, 0, NULL, NULL);
1522         }
1523         ast_mutex_unlock(&chan->lock);
1524 }
1525
1526 static int generator_force(void *data)
1527 {
1528         /* Called if generator doesn't have data */
1529         void *tmp;
1530         int res;
1531         int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
1532         struct ast_channel *chan = data;
1533         tmp = chan->generatordata;
1534         chan->generatordata = NULL;
1535         generate = chan->generator->generate;
1536         res = generate(chan, tmp, 0, 160);
1537         chan->generatordata = tmp;
1538         if (res) {
1539                 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
1540                 ast_deactivate_generator(chan);
1541         }
1542         return 0;
1543 }
1544
1545 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1546 {
1547         int res = 0;
1548
1549         ast_mutex_lock(&chan->lock);
1550
1551         if (chan->generatordata) {
1552                 if (chan->generator && chan->generator->release)
1553                         chan->generator->release(chan, chan->generatordata);
1554                 chan->generatordata = NULL;
1555         }
1556
1557         ast_prod(chan);
1558         if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1559                 res = -1;
1560         }
1561
1562         if (!res) {
1563                 ast_settimeout(chan, 160, generator_force, chan);
1564                 chan->generator = gen;
1565         }
1566
1567         ast_mutex_unlock(&chan->lock);
1568
1569         return res;
1570 }
1571
1572 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1573 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1574 {
1575         int winner = -1;
1576         ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1577         return winner;
1578 }
1579
1580 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1581 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1582         int *exception, int *outfd, int *ms)
1583 {
1584         struct timeval start = { 0 , 0 };
1585         struct pollfd *pfds;
1586         int res;
1587         long rms;
1588         int x, y, max;
1589         int sz;
1590         time_t now = 0;
1591         long whentohangup = 0, diff;
1592         struct ast_channel *winner = NULL;
1593         struct fdmap {
1594                 int chan;
1595                 int fdno;
1596         } *fdmap;
1597
1598         sz = n * AST_MAX_FDS + nfds;
1599         if (!(pfds = alloca(sizeof(*pfds) * sz)) || !(fdmap = alloca(sizeof(*fdmap) * sz))) {
1600                 ast_log(LOG_ERROR, "Out of memory\n");
1601                 *outfd = -1;
1602                 return NULL;
1603         }
1604
1605         if (outfd)
1606                 *outfd = -99999;
1607         if (exception)
1608                 *exception = 0;
1609
1610         /* Perform any pending masquerades */
1611         for (x=0; x < n; x++) {
1612                 ast_mutex_lock(&c[x]->lock);
1613                 if (c[x]->masq) {
1614                         if (ast_do_masquerade(c[x])) {
1615                                 ast_log(LOG_WARNING, "Masquerade failed\n");
1616                                 *ms = -1;
1617                                 ast_mutex_unlock(&c[x]->lock);
1618                                 return NULL;
1619                         }
1620                 }
1621                 if (c[x]->whentohangup) {
1622                         if (!whentohangup)
1623                                 time(&now);
1624                         diff = c[x]->whentohangup - now;
1625                         if (diff < 1) {
1626                                 /* Should already be hungup */
1627                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1628                                 ast_mutex_unlock(&c[x]->lock);
1629                                 return c[x];
1630                         }
1631                         if (!whentohangup || (diff < whentohangup))
1632                                 whentohangup = diff;
1633                 }
1634                 ast_mutex_unlock(&c[x]->lock);
1635         }
1636         /* Wait full interval */
1637         rms = *ms;
1638         if (whentohangup) {
1639                 rms = (whentohangup - now) * 1000;      /* timeout in milliseconds */
1640                 if (*ms >= 0 && *ms < rms)              /* original *ms still smaller */
1641                         rms =  *ms;
1642         }
1643         /*
1644          * Build the pollfd array, putting the channels' fds first,
1645          * followed by individual fds. Order is important because
1646          * individual fd's must have priority over channel fds.
1647          */
1648         max = 0;
1649         for (x=0; x<n; x++) {
1650                 for (y=0; y<AST_MAX_FDS; y++) {
1651                         fdmap[max].fdno = y;  /* fd y is linked to this pfds */
1652                         fdmap[max].chan = x;  /* channel x is linked to this pfds */
1653                         max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1654                 }
1655                 CHECK_BLOCKING(c[x]);
1656         }
1657         /* Add the individual fds */
1658         for (x=0; x<nfds; x++) {
1659                 fdmap[max].chan = -1;
1660                 max += ast_add_fd(&pfds[max], fds[x]);
1661         }
1662
1663         if (*ms > 0)
1664                 start = ast_tvnow();
1665
1666         if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1667                 do {
1668                         int kbrms = rms;
1669                         if (kbrms > 600000)
1670                                 kbrms = 600000;
1671                         res = poll(pfds, max, kbrms);
1672                         if (!res)
1673                                 rms -= kbrms;
1674                 } while (!res && (rms > 0));
1675         } else {
1676                 res = poll(pfds, max, rms);
1677         }
1678         for (x=0; x<n; x++)
1679                 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1680         if (res < 0) { /* Simulate a timeout if we were interrupted */
1681                 if (errno != EINTR)
1682                         *ms = -1;
1683                 return NULL;
1684         }
1685         if (whentohangup) {   /* if we have a timeout, check who expired */
1686                 time(&now);
1687                 for (x=0; x<n; x++) {
1688                         if (c[x]->whentohangup && now >= c[x]->whentohangup) {
1689                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1690                                 if (winner == NULL)
1691                                         winner = c[x];
1692                         }
1693                 }
1694         }
1695         if (res == 0) { /* no fd ready, reset timeout and done */
1696                 *ms = 0;        /* XXX use 0 since we may not have an exact timeout. */
1697                 return winner;
1698         }
1699         /*
1700          * Then check if any channel or fd has a pending event.
1701          * Remember to check channels first and fds last, as they
1702          * must have priority on setting 'winner'
1703          */
1704         for (x = 0; x < max; x++) {
1705                 res = pfds[x].revents;
1706                 if (res == 0)
1707                         continue;
1708                 if (fdmap[x].chan >= 0) {       /* this is a channel */
1709                         winner = c[fdmap[x].chan];      /* override previous winners */
1710                         if (res & POLLPRI)
1711                                 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1712                         else
1713                                 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1714                         winner->fdno = fdmap[x].fdno;
1715                 } else {                        /* this is an fd */
1716                         if (outfd)
1717                                 *outfd = pfds[x].fd;
1718                         if (exception)
1719                                 *exception = (res & POLLPRI) ? -1 : 0;
1720                         winner = NULL;
1721                 }
1722         }
1723         if (*ms > 0) {
1724                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1725                 if (*ms < 0)
1726                         *ms = 0;
1727         }
1728         return winner;
1729 }
1730
1731 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
1732 {
1733         return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
1734 }
1735
1736 int ast_waitfor(struct ast_channel *c, int ms)
1737 {
1738         int oldms = ms;
1739
1740         ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
1741         if ((ms < 0) && (oldms < 0))
1742                 ms = 0;
1743         return ms;
1744 }
1745
1746 int ast_waitfordigit(struct ast_channel *c, int ms)
1747 {
1748         /* XXX Should I be merged with waitfordigit_full XXX */
1749         struct ast_frame *f;
1750         int result = 0;
1751
1752         /* Stop if we're a zombie or need a soft hangup */
1753         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
1754                 return -1;
1755
1756         /* Wait for a digit, no more than ms milliseconds total. */
1757         while(ms && !result) {
1758                 ms = ast_waitfor(c, ms);
1759                 if (ms < 0) /* Error */
1760                         result = -1;
1761                 else if (ms > 0) {
1762                         /* Read something */
1763                         f = ast_read(c);
1764                         if (f) {
1765                                 if (f->frametype == AST_FRAME_DTMF)
1766                                         result = f->subclass;
1767                                 ast_frfree(f);
1768                         } else
1769                                 result = -1;
1770                 }
1771         }
1772         return result;
1773 }
1774
1775 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(void *data), void *data)
1776 {
1777         int res = -1;
1778 #ifdef ZAPTEL_OPTIMIZATIONS
1779         if (c->timingfd > -1) {
1780                 if (!func) {
1781                         samples = 0;
1782                         data = 0;
1783                 }
1784                 ast_log(LOG_DEBUG, "Scheduling timer at %d sample intervals\n", samples);
1785                 res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
1786                 c->timingfunc = func;
1787                 c->timingdata = data;
1788         }
1789 #endif
1790         return res;
1791 }
1792
1793 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
1794 {
1795         struct ast_frame *f;
1796         struct ast_channel *rchan;
1797         int outfd;
1798         int res;
1799
1800         /* Stop if we're a zombie or need a soft hangup */
1801         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
1802                 return -1;
1803         /* Wait for a digit, no more than ms milliseconds total. */
1804         while(ms) {
1805                 errno = 0;
1806                 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
1807                 if ((!rchan) && (outfd < 0) && (ms)) {
1808                         if (errno == 0 || errno == EINTR)
1809                                 continue;
1810                         ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
1811                         return -1;
1812                 } else if (outfd > -1) {
1813                         /* The FD we were watching has something waiting */
1814                         return 1;
1815                 } else if (rchan) {
1816                         f = ast_read(c);
1817                         if(!f) {
1818                                 return -1;
1819                         }
1820
1821                         switch(f->frametype) {
1822                         case AST_FRAME_DTMF:
1823                                 res = f->subclass;
1824                                 ast_frfree(f);
1825                                 return res;
1826                         case AST_FRAME_CONTROL:
1827                                 switch(f->subclass) {
1828                                 case AST_CONTROL_HANGUP:
1829                                         ast_frfree(f);
1830                                         return -1;
1831                                 case AST_CONTROL_RINGING:
1832                                 case AST_CONTROL_ANSWER:
1833                                         /* Unimportant */
1834                                         break;
1835                                 default:
1836                                         ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
1837                                 }
1838                         case AST_FRAME_VOICE:
1839                                 /* Write audio if appropriate */
1840                                 if (audiofd > -1)
1841                                         write(audiofd, f->data, f->datalen);
1842                         }
1843                         /* Ignore */
1844                         ast_frfree(f);
1845                 }
1846         }
1847         return 0; /* Time is up */
1848 }
1849
1850 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
1851 {
1852         struct ast_frame *f = NULL;
1853         int blah;
1854         int prestate;
1855 #ifdef ZAPTEL_OPTIMIZATIONS
1856         int (*func)(void *);
1857         void *data;
1858         int res;
1859 #endif
1860         ast_mutex_lock(&chan->lock);
1861         if (chan->masq) {
1862                 if (ast_do_masquerade(chan)) {
1863                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1864                         f = NULL;
1865                 } else
1866                         f =  &ast_null_frame;
1867                 ast_mutex_unlock(&chan->lock);
1868                 return f;
1869         }
1870
1871         /* Stop if we're a zombie or need a soft hangup */
1872         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1873                 if (chan->generator)
1874                         ast_deactivate_generator(chan);
1875                 ast_mutex_unlock(&chan->lock);
1876                 return NULL;
1877         }
1878         prestate = chan->_state;
1879
1880         if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF) && !ast_strlen_zero(chan->dtmfq)) {
1881                 /* We have DTMF that has been deferred.  Return it now */
1882                 chan->dtmff.frametype = AST_FRAME_DTMF;
1883                 chan->dtmff.subclass = chan->dtmfq[0];
1884                 /* Drop first digit */
1885                 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
1886                 ast_mutex_unlock(&chan->lock);
1887                 return &chan->dtmff;
1888         }
1889
1890         /* Read and ignore anything on the alertpipe, but read only
1891            one sizeof(blah) per frame that we send from it */
1892         if (chan->alertpipe[0] > -1) {
1893                 read(chan->alertpipe[0], &blah, sizeof(blah));
1894         }
1895 #ifdef ZAPTEL_OPTIMIZATIONS
1896         if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
1897                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
1898                 blah = -1;
1899                 /* IF we can't get event, assume it's an expired as-per the old interface */
1900                 res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
1901                 if (res)
1902                         blah = ZT_EVENT_TIMER_EXPIRED;
1903
1904                 if (blah == ZT_EVENT_TIMER_PING) {
1905 #if 0
1906                         ast_log(LOG_NOTICE, "Oooh, there's a PING!\n");
1907 #endif
1908                         if (!chan->readq || !chan->readq->next) {
1909                                 /* Acknowledge PONG unless we need it again */
1910 #if 0
1911                                 ast_log(LOG_NOTICE, "Sending a PONG!\n");
1912 #endif
1913                                 if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
1914                                         ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
1915                                 }
1916                         }
1917                 } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
1918                         ioctl(chan->timingfd, ZT_TIMERACK, &blah);
1919                         func = chan->timingfunc;
1920                         data = chan->timingdata;
1921                         ast_mutex_unlock(&chan->lock);
1922                         if (func) {
1923 #if 0
1924                                 ast_log(LOG_DEBUG, "Calling private function\n");
1925 #endif
1926                                 func(data);
1927                         } else {
1928                                 blah = 0;
1929                                 ast_mutex_lock(&chan->lock);
1930                                 ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
1931                                 chan->timingdata = NULL;
1932                                 ast_mutex_unlock(&chan->lock);
1933                         }
1934                         return &ast_null_frame;
1935                 } else
1936                         ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
1937         } else
1938 #endif
1939         /* Check for AST_GENERATOR_FD if not null.  If so, call generator with -1
1940            arguments now so it can do whatever it needs to. */
1941         if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
1942                 void *tmp = chan->generatordata;
1943                 chan->generatordata = NULL;     /* reset to let ast_write get through */
1944                 chan->generator->generate(chan, tmp, -1, -1);
1945                 chan->generatordata = tmp;
1946                 return &ast_null_frame;
1947         }
1948
1949         /* Check for pending read queue */
1950         if (chan->readq) {
1951                 f = chan->readq;
1952                 chan->readq = f->next;
1953                 f->next = NULL;
1954                 /* Interpret hangup and return NULL */
1955                 if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
1956                         ast_frfree(f);
1957                         f = NULL;
1958                 }
1959         } else {
1960                 chan->blocker = pthread_self();
1961                 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
1962                         if (chan->tech->exception)
1963                                 f = chan->tech->exception(chan);
1964                         else {
1965                                 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
1966                                 f = &ast_null_frame;
1967                         }
1968                         /* Clear the exception flag */
1969                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
1970                 } else {
1971                         if (chan->tech->read)
1972                                 f = chan->tech->read(chan);
1973                         else
1974                                 ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
1975                 }
1976         }
1977
1978         if (f) {
1979                 /* if the channel driver returned more than one frame, stuff the excess
1980                    into the readq for the next ast_read call
1981                 */
1982                 if (f->next) {
1983                         chan->readq = f->next;
1984                         f->next = NULL;
1985                 }
1986
1987                 switch (f->frametype) {
1988                 case AST_FRAME_CONTROL:
1989                         if (f->subclass == AST_CONTROL_ANSWER) {
1990                                 if (prestate == AST_STATE_UP) {
1991                                         ast_log(LOG_DEBUG, "Dropping duplicate answer!\n");
1992                                         f = &ast_null_frame;
1993                                 }
1994                                 /* Answer the CDR */
1995                                 ast_setstate(chan, AST_STATE_UP);
1996                                 ast_cdr_answer(chan->cdr);
1997                         }
1998                         break;
1999                 case AST_FRAME_DTMF:
2000                         ast_log(LOG_DTMF, "DTMF '%c' received on %s\n", f->subclass, chan->name);
2001                         if (ast_test_flag(chan, AST_FLAG_DEFER_DTMF)) {
2002                                 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2)
2003                                         chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2004                                 else
2005                                         ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2006                                 f = &ast_null_frame;
2007                         }
2008                         break;
2009                 case AST_FRAME_DTMF_BEGIN:
2010                         ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2011                         break;
2012                 case AST_FRAME_DTMF_END:
2013                         ast_log(LOG_DTMF, "DTMF end '%c' received on %s\n", f->subclass, chan->name);
2014                         break;
2015                 case AST_FRAME_VOICE:
2016                         if (dropaudio) {
2017                                 ast_frfree(f);
2018                                 f = &ast_null_frame;
2019                         } else if (!(f->subclass & chan->nativeformats)) {
2020                                 /* This frame can't be from the current native formats -- drop it on the
2021                                    floor */
2022                                 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2023                                         chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
2024                                 ast_frfree(f);
2025                                 f = &ast_null_frame;
2026                         } else {
2027                                 if (chan->spies)
2028                                         queue_frame_to_spies(chan, f, SPY_READ);
2029
2030                                 if (chan->monitor && chan->monitor->read_stream ) {
2031 #ifndef MONITOR_CONSTANT_DELAY
2032                                         int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2033                                         if (jump >= 0) {
2034                                                 if (ast_seekstream(chan->monitor->read_stream, jump + f->samples, SEEK_FORCECUR) == -1)
2035                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2036                                                 chan->insmpl += jump + 4 * f->samples;
2037                                         } else
2038                                                 chan->insmpl+= f->samples;
2039 #else
2040                                         int jump = chan->outsmpl - chan->insmpl;
2041                                         if (jump - MONITOR_DELAY >= 0) {
2042                                                 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2043                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2044                                                 chan->insmpl += jump;
2045                                         } else
2046                                                 chan->insmpl += f->samples;
2047 #endif
2048                                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2049                                                 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2050                                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2051                                         }
2052                                 }
2053
2054                                 if (chan->readtrans) {
2055                                         if (!(f = ast_translate(chan->readtrans, f, 1)))
2056                                                 f = &ast_null_frame;
2057                                 }
2058
2059                                 /* Run generator sitting on the line if timing device not available
2060                                 * and synchronous generation of outgoing frames is necessary       */
2061                                 if (chan->generatordata &&  !ast_internal_timing_enabled(chan)) {
2062                                         void *tmp;
2063                                         int res;
2064                                         int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
2065
2066                                         if (chan->timingfunc) {
2067                                                 if (option_debug > 1)
2068                                                         ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n");
2069                                                 ast_settimeout(chan, 0, NULL, NULL);
2070                                         }
2071
2072                                         tmp = chan->generatordata;
2073                                         chan->generatordata = NULL;
2074                                         generate = chan->generator->generate;
2075                                         res = generate(chan, tmp, f->datalen, f->samples);
2076                                         chan->generatordata = tmp;
2077                                         if (res) {
2078                                                 if (option_debug > 1)
2079                                                         ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
2080                                                 ast_deactivate_generator(chan);
2081                                         }
2082
2083                                 } else if (f->frametype == AST_FRAME_CNG) {
2084                                         if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
2085                                                 if (option_debug > 1)
2086                                                         ast_log(LOG_DEBUG, "Generator got CNG, switching to timed mode\n");
2087                                                 ast_settimeout(chan, 160, generator_force, chan);
2088                                         }
2089                                 }
2090                         }
2091                 }
2092         } else {
2093                 /* Make sure we always return NULL in the future */
2094                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2095                 if (chan->generator)
2096                         ast_deactivate_generator(chan);
2097                 /* End the CDR if appropriate */
2098                 if (chan->cdr)
2099                         ast_cdr_end(chan->cdr);
2100         }
2101
2102         /* High bit prints debugging */
2103         if (chan->fin & 0x80000000)
2104                 ast_frame_dump(chan->name, f, "<<");
2105         if ((chan->fin & 0x7fffffff) == 0x7fffffff)
2106                 chan->fin &= 0x80000000;
2107         else
2108                 chan->fin++;
2109         ast_mutex_unlock(&chan->lock);
2110
2111         return f;
2112 }
2113
2114 int ast_internal_timing_enabled(struct ast_channel *chan)
2115 {
2116         int ret = ast_opt_internal_timing && chan->timingfd > -1;
2117         if (option_debug > 3)
2118                 ast_log(LOG_DEBUG, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
2119         return ret;
2120 }
2121
2122 struct ast_frame *ast_read(struct ast_channel *chan)
2123 {
2124         return __ast_read(chan, 0);
2125 }
2126
2127 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2128 {
2129         return __ast_read(chan, 1);
2130 }
2131
2132 int ast_indicate(struct ast_channel *chan, int condition)
2133 {
2134         int res = -1;
2135
2136         ast_mutex_lock(&chan->lock);
2137         /* Stop if we're a zombie or need a soft hangup */
2138         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2139                 ast_mutex_unlock(&chan->lock);
2140                 return -1;
2141         }
2142         if (chan->tech->indicate)
2143                 res = chan->tech->indicate(chan, condition);
2144         ast_mutex_unlock(&chan->lock);
2145         if (!chan->tech->indicate || res) {
2146                 /*
2147                  * Device does not support (that) indication, lets fake
2148                  * it by doing our own tone generation. (PM2002)
2149                  */
2150                 if (condition >= 0) {
2151                         const struct tone_zone_sound *ts = NULL;
2152                         switch (condition) {
2153                         case AST_CONTROL_RINGING:
2154                                 ts = ast_get_indication_tone(chan->zone, "ring");
2155                                 break;
2156                         case AST_CONTROL_BUSY:
2157                                 ts = ast_get_indication_tone(chan->zone, "busy");
2158                                 break;
2159                         case AST_CONTROL_CONGESTION:
2160                                 ts = ast_get_indication_tone(chan->zone, "congestion");
2161                                 break;
2162                         }
2163                         if (ts && ts->data[0]) {
2164                                 ast_log(LOG_DEBUG, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2165                                 ast_playtones_start(chan,0,ts->data, 1);
2166                                 res = 0;
2167                         } else if (condition == AST_CONTROL_PROGRESS) {
2168                                 /* ast_playtones_stop(chan); */
2169                         } else if (condition == AST_CONTROL_PROCEEDING) {
2170                                 /* Do nothing, really */
2171                         } else if (condition == AST_CONTROL_HOLD) {
2172                                 /* Do nothing.... */
2173                         } else if (condition == AST_CONTROL_UNHOLD) {
2174                                 /* Do nothing.... */
2175                         } else if (condition == AST_CONTROL_VIDUPDATE) {
2176                                 /* Do nothing.... */
2177                         } else {
2178                                 /* not handled */
2179                                 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2180                                 res = -1;
2181                         }
2182                 }
2183                 else ast_playtones_stop(chan);
2184         }
2185         return res;
2186 }
2187
2188 int ast_recvchar(struct ast_channel *chan, int timeout)
2189 {
2190         int c;
2191         char *buf = ast_recvtext(chan, timeout);
2192         if (buf == NULL)
2193                 return -1;      /* error or timeout */
2194         c = *(unsigned char *)buf;
2195         free(buf);
2196         return c;
2197 }
2198
2199 char *ast_recvtext(struct ast_channel *chan, int timeout)
2200 {
2201         int res, done = 0;
2202         char *buf = NULL;
2203
2204         while (!done) {
2205                 struct ast_frame *f;
2206                 if (ast_check_hangup(chan))
2207                         break;
2208                 res = ast_waitfor(chan, timeout);
2209                 if (res <= 0) /* timeout or error */
2210                         break;
2211                 timeout = res;  /* update timeout */
2212                 f = ast_read(chan);
2213                 if (f == NULL)
2214                         break; /* no frame */
2215                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2216                         done = 1;       /* force a break */
2217                 else if (f->frametype == AST_FRAME_TEXT) {              /* what we want */
2218                         buf = ast_strndup((char *) f->data, f->datalen);        /* dup and break */
2219                         done = 1;
2220                 }
2221                 ast_frfree(f);
2222         }
2223         return buf;
2224 }
2225
2226 int ast_sendtext(struct ast_channel *chan, const char *text)
2227 {
2228         int res = 0;
2229         /* Stop if we're a zombie or need a soft hangup */
2230         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2231                 return -1;
2232         CHECK_BLOCKING(chan);
2233         if (chan->tech->send_text)
2234                 res = chan->tech->send_text(chan, text);
2235         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2236         return res;
2237 }
2238
2239 static int do_senddigit(struct ast_channel *chan, char digit)
2240 {
2241         int res = -1;
2242
2243         if (chan->tech->send_digit)
2244                 res = chan->tech->send_digit(chan, digit);
2245         if (!(chan->tech->send_digit && chan->tech->send_digit_begin) ||
2246             res) {
2247                 /*
2248                  * Device does not support DTMF tones, lets fake
2249                  * it by doing our own generation. (PM2002)
2250                  */
2251                 static const char* dtmf_tones[] = {
2252                         "!941+1336/100,!0/100", /* 0 */
2253                         "!697+1209/100,!0/100", /* 1 */
2254                         "!697+1336/100,!0/100", /* 2 */
2255                         "!697+1477/100,!0/100", /* 3 */
2256                         "!770+1209/100,!0/100", /* 4 */
2257                         "!770+1336/100,!0/100", /* 5 */
2258                         "!770+1477/100,!0/100", /* 6 */
2259                         "!852+1209/100,!0/100", /* 7 */
2260                         "!852+1336/100,!0/100", /* 8 */
2261                         "!852+1477/100,!0/100", /* 9 */
2262                         "!697+1633/100,!0/100", /* A */
2263                         "!770+1633/100,!0/100", /* B */
2264                         "!852+1633/100,!0/100", /* C */
2265                         "!941+1633/100,!0/100", /* D */
2266                         "!941+1209/100,!0/100", /* * */
2267                         "!941+1477/100,!0/100" };       /* # */
2268                 if (digit >= '0' && digit <='9')
2269                         ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2270                 else if (digit >= 'A' && digit <= 'D')
2271                         ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2272                 else if (digit == '*')
2273                         ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2274                 else if (digit == '#')
2275                         ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2276                 else {
2277                         /* not handled */
2278                         ast_log(LOG_DEBUG, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2279                 }
2280         }
2281         return 0;
2282 }
2283
2284 int ast_senddigit(struct ast_channel *chan, char digit)
2285 {
2286         return do_senddigit(chan, digit);
2287 }
2288
2289 int ast_prod(struct ast_channel *chan)
2290 {
2291         struct ast_frame a = { AST_FRAME_VOICE };
2292         char nothing[128];
2293
2294         /* Send an empty audio frame to get things moving */
2295         if (chan->_state != AST_STATE_UP) {
2296                 ast_log(LOG_DEBUG, "Prodding channel '%s'\n", chan->name);
2297                 a.subclass = chan->rawwriteformat;
2298                 a.data = nothing + AST_FRIENDLY_OFFSET;
2299                 a.src = "ast_prod";
2300                 if (ast_write(chan, &a))
2301                         ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2302         }
2303         return 0;
2304 }
2305
2306 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2307 {
2308         int res;
2309         if (!chan->tech->write_video)
2310                 return 0;
2311         res = ast_write(chan, fr);
2312         if (!res)
2313                 res = 1;
2314         return res;
2315 }
2316
2317 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2318 {
2319         int res = -1;
2320         struct ast_frame *f = NULL;
2321         /* Stop if we're a zombie or need a soft hangup */
2322         ast_mutex_lock(&chan->lock);
2323         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))  {
2324                 ast_mutex_unlock(&chan->lock);
2325                 return -1;
2326         }
2327         /* Handle any pending masquerades */
2328         if (chan->masq) {
2329                 if (ast_do_masquerade(chan)) {
2330                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2331                         ast_mutex_unlock(&chan->lock);
2332                         return -1;
2333                 }
2334         }
2335         if (chan->masqr) {
2336                 ast_mutex_unlock(&chan->lock);
2337                 return 0;
2338         }
2339         if (chan->generatordata) {
2340                 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
2341                         ast_deactivate_generator(chan);
2342                 else {
2343                         ast_mutex_unlock(&chan->lock);
2344                         return 0;
2345                 }
2346         }
2347         /* High bit prints debugging */
2348         if (chan->fout & 0x80000000)
2349                 ast_frame_dump(chan->name, fr, ">>");
2350         CHECK_BLOCKING(chan);
2351         switch(fr->frametype) {
2352         case AST_FRAME_CONTROL:
2353                 /* XXX Interpret control frames XXX */
2354                 ast_log(LOG_WARNING, "Don't know how to handle control frames yet\n");
2355                 break;
2356         case AST_FRAME_DTMF_BEGIN:
2357                 if (chan->tech->send_digit_begin)
2358                         res = chan->tech->send_digit_begin(chan, fr->subclass);
2359                 else
2360                         res = 0;
2361                 break;
2362         case AST_FRAME_DTMF_END:
2363                 if (chan->tech->send_digit_end)
2364                         res = chan->tech->send_digit_end(chan);
2365                 else
2366                         res = 0;
2367                 break;
2368         case AST_FRAME_DTMF:
2369                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2370                 ast_mutex_unlock(&chan->lock);
2371                 res = do_senddigit(chan,fr->subclass);
2372                 ast_mutex_lock(&chan->lock);
2373                 CHECK_BLOCKING(chan);
2374                 break;
2375         case AST_FRAME_TEXT:
2376                 if (chan->tech->send_text)
2377                         res = chan->tech->send_text(chan, (char *) fr->data);
2378                 else
2379                         res = 0;
2380                 break;
2381         case AST_FRAME_HTML:
2382                 if (chan->tech->send_html)
2383                         res = chan->tech->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen);
2384                 else
2385                         res = 0;
2386                 break;
2387         case AST_FRAME_VIDEO:
2388                 /* XXX Handle translation of video codecs one day XXX */
2389                 if (chan->tech->write_video)
2390                         res = chan->tech->write_video(chan, fr);
2391                 else
2392                         res = 0;
2393                 break;
2394         case AST_FRAME_VOICE:
2395                 if (chan->tech->write) {
2396                         /* Bypass translator if we're writing format in the raw write format.  This
2397                            allows mixing of native / non-native formats */
2398                         if (fr->subclass == chan->rawwriteformat)
2399                                 f = fr;
2400                         else
2401                                 f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
2402                         if (f) {
2403                                 if (chan->spies)
2404                                         queue_frame_to_spies(chan, f, SPY_WRITE);
2405
2406                                 if (chan->monitor && chan->monitor->write_stream) {
2407 #ifndef MONITOR_CONSTANT_DELAY
2408                                         int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
2409                                         if (jump >= 0) {
2410                                                 if (ast_seekstream(chan->monitor->write_stream, jump + f->samples, SEEK_FORCECUR) == -1)
2411                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2412                                                 chan->outsmpl += jump + 4 * f->samples;
2413                                         } else
2414                                                 chan->outsmpl += f->samples;
2415 #else
2416                                         int jump = chan->insmpl - chan->outsmpl;
2417                                         if (jump - MONITOR_DELAY >= 0) {
2418                                                 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2419                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2420                                                 chan->outsmpl += jump;
2421                                         } else
2422                                                 chan->outsmpl += f->samples;
2423 #endif
2424                                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2425                                                 if (ast_writestream(chan->monitor->write_stream, f) < 0)
2426                                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
2427                                         }
2428                                 }
2429
2430                                 res = chan->tech->write(chan, f);
2431                         } else
2432                                 res = 0;
2433                 }
2434         }
2435
2436         if (f && (f != fr))
2437                 ast_frfree(f);
2438         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2439         /* Consider a write failure to force a soft hangup */
2440         if (res < 0)
2441                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2442         else {
2443                 if ((chan->fout & 0x7fffffff) == 0x7fffffff)
2444                         chan->fout &= 0x80000000;
2445                 else
2446                         chan->fout++;
2447         }
2448         ast_mutex_unlock(&chan->lock);
2449         return res;
2450 }
2451
2452 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
2453                       struct ast_trans_pvt **trans, const int direction)
2454 {
2455         int native;
2456         int res;
2457
2458         /* Make sure we only consider audio */
2459         fmt &= AST_FORMAT_AUDIO_MASK;
2460
2461         native = chan->nativeformats;
2462         /* Find a translation path from the native format to one of the desired formats */
2463         if (!direction)
2464                 /* reading */
2465                 res = ast_translator_best_choice(&fmt, &native);
2466         else
2467                 /* writing */
2468                 res = ast_translator_best_choice(&native, &fmt);
2469
2470         if (res < 0) {
2471                 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
2472                         ast_getformatname(native), ast_getformatname(fmt));
2473                 return -1;
2474         }
2475
2476         /* Now we have a good choice for both. */
2477         ast_mutex_lock(&chan->lock);
2478         *rawformat = native;
2479         /* User perspective is fmt */
2480         *format = fmt;
2481         /* Free any read translation we have right now */
2482         if (*trans)
2483                 ast_translator_free_path(*trans);
2484         /* Build a translation path from the raw format to the desired format */
2485         if (!direction)
2486                 /* reading */
2487                 *trans = ast_translator_build_path(*format, *rawformat);
2488         else
2489                 /* writing */
2490                 *trans = ast_translator_build_path(*rawformat, *format);
2491         ast_mutex_unlock(&chan->lock);
2492         if (option_debug)
2493                 ast_log(LOG_DEBUG, "Set channel %s to %s format %s\n", chan->name,
2494                         direction ? "write" : "read", ast_getformatname(fmt));
2495         return 0;
2496 }
2497
2498 int ast_set_read_format(struct ast_channel *chan, int fmt)
2499 {
2500         return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
2501                           &chan->readtrans, 0);
2502 }
2503
2504 int ast_set_write_format(struct ast_channel *chan, int fmt)
2505 {
2506         return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
2507                           &chan->writetrans, 1);
2508 }
2509
2510 struct ast_channel *__ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name, struct outgoing_helper *oh)
2511 {
2512         int state = 0;
2513         int cause = 0;
2514         struct ast_channel *chan;
2515         struct ast_frame *f;
2516         int res = 0;
2517
2518         chan = ast_request(type, format, data, &cause);
2519         if (chan) {
2520                 if (oh) {
2521                         if (oh->vars)
2522                                 ast_set_variables(chan, oh->vars);
2523                         if (oh->cid_num && *oh->cid_num && oh->cid_name && *oh->cid_name)
2524                                 ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
2525                         if (oh->parent_channel)
2526                                 ast_channel_inherit_variables(oh->parent_channel, chan);
2527                         if (oh->account)
2528                                 ast_cdr_setaccount(chan, oh->account);
2529                 }
2530                 ast_set_callerid(chan, cid_num, cid_name, cid_num);
2531
2532                 if (!ast_call(chan, data, 0)) {
2533                         res = 1;        /* in case chan->_state is already AST_STATE_UP */
2534                         while (timeout && (chan->_state != AST_STATE_UP)) {
2535                                 res = ast_waitfor(chan, timeout);
2536                                 if (res < 0) {
2537                                         /* Something not cool, or timed out */
2538                                         break;
2539                                 }
2540                                 /* If done, break out */
2541                                 if (!res)
2542                                         break;
2543                                 if (timeout > -1)
2544                                         timeout = res;
2545                                 f = ast_read(chan);
2546                                 if (!f) {
2547                                         state = AST_CONTROL_HANGUP;
2548                                         res = 0;
2549                                         break;
2550                                 }
2551                                 if (f->frametype == AST_FRAME_CONTROL) {
2552                                         if (f->subclass == AST_CONTROL_RINGING)
2553                                                 state = AST_CONTROL_RINGING;
2554                                         else if ((f->subclass == AST_CONTROL_BUSY) || (f->subclass == AST_CONTROL_CONGESTION)) {
2555                                                 state = f->subclass;
2556                                                 ast_frfree(f);
2557                                                 break;
2558                                         } else if (f->subclass == AST_CONTROL_ANSWER) {
2559                                                 state = f->subclass;
2560                                                 ast_frfree(f);
2561                                                 break;
2562                                         } else if (f->subclass == AST_CONTROL_PROGRESS) {
2563                                                 /* Ignore */
2564                                         } else if (f->subclass == -1) {
2565                                                 /* Ignore -- just stopping indications */
2566                                         } else {
2567                                                 ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
2568                                         }
2569                                 }
2570                                 ast_frfree(f);
2571                         }
2572                 } else
2573                         ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
2574         } else {
2575                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
2576                 switch(cause) {
2577                 case AST_CAUSE_BUSY:
2578                         state = AST_CONTROL_BUSY;
2579                         break;
2580                 case AST_CAUSE_CONGESTION:
2581                         state = AST_CONTROL_CONGESTION;
2582                         break;
2583                 }
2584         }
2585         if (chan) {
2586                 /* Final fixups */
2587                 if (oh) {
2588                         if (oh->context && *oh->context)
2589                                 ast_copy_string(chan->context, oh->context, sizeof(chan->context));
2590                         if (oh->exten && *oh->exten)
2591                                 ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
2592                         if (oh->priority)
2593                                 chan->priority = oh->priority;
2594                 }
2595                 if (chan->_state == AST_STATE_UP)
2596                         state = AST_CONTROL_ANSWER;
2597         }
2598         if (outstate)
2599                 *outstate = state;
2600         if (chan && res <= 0) {
2601                 if (!chan->cdr && (chan->cdr = ast_cdr_alloc())) {
2602                         ast_cdr_init(chan->cdr, chan);
2603                 }
2604                 if (chan->cdr) {
2605                         char tmp[256];
2606                         snprintf(tmp, 256, "%s/%s", type, (char *)data);
2607                         ast_cdr_setapp(chan->cdr,"Dial",tmp);
2608                         ast_cdr_update(chan);
2609                         ast_cdr_start(chan->cdr);
2610                         ast_cdr_end(chan->cdr);
2611                         /* If the cause wasn't handled properly */
2612                         if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
2613                                 ast_cdr_failed(chan->cdr);
2614                 }
2615                 ast_hangup(chan);
2616                 chan = NULL;
2617         }
2618         return chan;
2619 }
2620
2621 struct ast_channel *ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname)
2622 {
2623         return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
2624 }
2625
2626 struct ast_channel *ast_request(const char *type, int format, void *data, int *cause)
2627 {
2628         struct chanlist *chan;
2629         struct ast_channel *c;
2630         int capabilities;
2631         int fmt;
2632         int res;
2633         int foo;
2634
2635         if (!cause)
2636                 cause = &foo;
2637         *cause = AST_CAUSE_NOTDEFINED;
2638
2639         if (AST_LIST_LOCK(&channels)) {
2640                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
2641                 return NULL;
2642         }
2643
2644         AST_LIST_TRAVERSE(&backends, chan, list) {
2645                 if (strcasecmp(type, chan->tech->type))
2646                         continue;
2647
2648                 capabilities = chan->tech->capabilities;
2649                 fmt = format;
2650                 res = ast_translator_best_choice(&fmt, &capabilities);
2651                 if (res < 0) {
2652                         ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %d) to %d\n", type, chan->tech->capabilities, format);
2653                         AST_LIST_UNLOCK(&channels);
2654                         return NULL;
2655                 }
2656                 AST_LIST_UNLOCK(&channels);
2657                 if (!chan->tech->requester)
2658                         return NULL;
2659
2660                 if (!(c = chan->tech->requester(type, capabilities, data, cause)))
2661                         return NULL;
2662
2663                 if (c->_state == AST_STATE_DOWN) {
2664                         manager_event(EVENT_FLAG_CALL, "Newchannel",
2665                                       "Channel: %s\r\n"
2666                                       "State: %s\r\n"
2667                                       "CallerID: %s\r\n"
2668                                       "CallerIDName: %s\r\n"
2669                                       "Uniqueid: %s\r\n",
2670                                       c->name, ast_state2str(c->_state),
2671                                       c->cid.cid_num ? c->cid.cid_num : "<unknown>",
2672                                       c->cid.cid_name ? c->cid.cid_name : "<unknown>",
2673                                       c->uniqueid);
2674                 }
2675                 return c;
2676         }
2677
2678         ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
2679         *cause = AST_CAUSE_NOSUCHDRIVER;
2680         AST_LIST_UNLOCK(&channels);
2681
2682         return NULL;
2683 }
2684
2685 int ast_call(struct ast_channel *chan, char *addr, int timeout)
2686 {
2687         /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
2688            If the remote end does not answer within the timeout, then do NOT hang up, but
2689            return anyway.  */
2690         int res = -1;
2691         /* Stop if we're a zombie or need a soft hangup */
2692         ast_mutex_lock(&chan->lock);
2693         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan))
2694                 if (chan->tech->call)
2695                         res = chan->tech->call(chan, addr, timeout);
2696         ast_mutex_unlock(&chan->lock);
2697         return res;
2698 }
2699
2700 /*!
2701   \brief Transfer a call to dest, if the channel supports transfer
2702
2703   Called by:
2704     \arg app_transfer
2705     \arg the manager interface
2706 */
2707 int ast_transfer(struct ast_channel *chan, char *dest)
2708 {
2709         int res = -1;
2710
2711         /* Stop if we're a zombie or need a soft hangup */
2712         ast_mutex_lock(&chan->lock);
2713         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
2714                 if (chan->tech->transfer) {
2715                         res = chan->tech->transfer(chan, dest);
2716                         if (!res)
2717                                 res = 1;
2718                 } else
2719                         res = 0;
2720         }
2721         ast_mutex_unlock(&chan->lock);
2722         return res;
2723 }
2724
2725 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
2726 {
2727         int pos=0;
2728         int to = ftimeout;
2729         int d;
2730
2731         /* XXX Merge with full version? XXX */
2732         /* Stop if we're a zombie or need a soft hangup */
2733         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
2734                 return -1;
2735         if (!len)
2736                 return -1;
2737         do {
2738                 if (c->stream) {
2739                         d = ast_waitstream(c, AST_DIGIT_ANY);
2740                         ast_stopstream(c);
2741                         usleep(1000);
2742                         if (!d)
2743                                 d = ast_waitfordigit(c, to);
2744                 } else {
2745                         d = ast_waitfordigit(c, to);
2746                 }
2747                 if (d < 0)
2748                         return -1;
2749                 if (d == 0) {
2750                         s[pos]='\0';
2751                         return 1;
2752                 }
2753                 if (!strchr(enders, d))
2754                         s[pos++] = d;
2755                 if (strchr(enders, d) || (pos >= len)) {
2756                         s[pos]='\0';
2757                         return 0;
2758                 }
2759                 to = timeout;
2760         } while(1);
2761         /* Never reached */
2762         return 0;
2763 }
2764
2765 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
2766 {
2767         int pos=0;
2768         int to = ftimeout;
2769         int d;
2770
2771         /* Stop if we're a zombie or need a soft hangup */
2772         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
2773                 return -1;
2774         if (!len)
2775                 return -1;
2776         do {
2777                 if (c->stream) {
2778                         d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
2779                         ast_stopstream(c);
2780                         usleep(1000);
2781                         if (!d)
2782                                 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
2783                 } else {
2784                         d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
2785                 }
2786                 if (d < 0)
2787                         return -1;
2788                 if (d == 0) {
2789                         s[pos]='\0';
2790                         return 1;
2791                 }
2792                 if (d == 1) {
2793                         s[pos]='\0';
2794                         return 2;
2795                 }
2796                 if (!strchr(enders, d))
2797                         s[pos++] = d;
2798                 if (strchr(enders, d) || (pos >= len)) {
2799                         s[pos]='\0';
2800                         return 0;
2801                 }
2802                 to = timeout;
2803         } while(1);
2804         /* Never reached */
2805         return 0;
2806 }
2807
2808 int ast_channel_supports_html(struct ast_channel *chan)
2809 {
2810         if (chan->tech->send_html)
2811                 return 1;
2812         return 0;
2813 }
2814
2815 int ast_channel_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen)
2816 {
2817         if (chan->tech->send_html)
2818                 return chan->tech->send_html(chan, subclass, data, datalen);
2819         return -1;
2820 }
2821
2822 int ast_channel_sendurl(struct ast_channel *chan, const char *url)
2823 {
2824         if (chan->tech->send_html)
2825                 return chan->tech->send_html(chan, AST_HTML_URL, url, strlen(url) + 1);
2826         return -1;
2827 }
2828
2829 int ast_channel_make_compatible(struct ast_channel *chan, struct ast_channel *peer)
2830 {
2831         int src;
2832         int dst;
2833
2834         /* Set up translation from the chan to the peer */
2835         src = chan->nativeformats;
2836         dst = peer->nativeformats;
2837         if (ast_translator_best_choice(&dst, &src) < 0) {
2838                 ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", chan->name, src, peer->name, dst);
2839                 return -1;
2840         }
2841
2842         /* if the best path is not 'pass through', then
2843            transcoding is needed; if desired, force transcode path
2844            to use SLINEAR between channels */
2845         if ((src != dst) && ast_opt_transcode_via_slin)
2846                 dst = AST_FORMAT_SLINEAR;
2847         if (ast_set_read_format(chan, dst) < 0) {
2848                 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", chan->name, dst);
2849                 return -1;
2850         }
2851         if (ast_set_write_format(peer, dst) < 0) {
2852                 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", peer->name, dst);
2853                 return -1;
2854         }
2855
2856         /* Set up translation from the peer to the chan */
2857         src = peer->nativeformats;
2858         dst = chan->nativeformats;
2859         if (ast_translator_best_choice(&dst, &src) < 0) {
2860                 ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", peer->name, src, chan->name, dst);
2861                 return -1;
2862         }
2863         /* if the best path is not 'pass through', then
2864            transcoding is needed; if desired, force transcode path
2865            to use SLINEAR between channels */
2866         if ((src != dst) && ast_opt_transcode_via_slin)
2867                 dst = AST_FORMAT_SLINEAR;
2868         if (ast_set_read_format(peer, dst) < 0) {
2869                 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", peer->name, dst);
2870                 return -1;
2871         }
2872         if (ast_set_write_format(chan, dst) < 0) {
2873                 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", chan->name, dst);
2874                 return -1;
2875         }
2876         return 0;
2877 }
2878
2879 int ast_channel_masquerade(struct ast_channel *original, struct ast_channel *clone)
2880 {
2881         struct ast_frame null = { AST_FRAME_NULL, };
2882         int res = -1;
2883
2884         if (original == clone) {
2885                 ast_log(LOG_WARNING, "Can't masquerade channel '%s' into itself!\n", original->name);
2886                 return -1;
2887         }
2888         ast_mutex_lock(&original->lock);
2889         while(ast_mutex_trylock(&clone->lock)) {
2890                 ast_mutex_unlock(&original->lock);
2891                 usleep(1);
2892                 ast_mutex_lock(&original->lock);
2893         }
2894         ast_log(LOG_DEBUG, "Planning to masquerade channel %s into the structure of %s\n",
2895                 clone->name, original->name);
2896         if (original->masq) {
2897                 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
2898                         original->masq->name, original->name);
2899         } else if (clone->masqr) {
2900                 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
2901                         clone->name, clone->masqr->name);
2902         } else {
2903                 original->masq = clone;
2904                 clone->masqr = original;
2905                 ast_queue_frame(original, &null);
2906                 ast_queue_frame(clone, &null);
2907                 ast_log(LOG_DEBUG, "Done planning to masquerade channel %s into the structure of %s\n", clone->name, original->name);
2908                 res = 0;
2909         }
2910         ast_mutex_unlock(&clone->lock);
2911         ast_mutex_unlock(&original->lock);
2912         return res;
2913 }
2914
2915 void ast_change_name(struct ast_channel *chan, char *newname)
2916 {
2917         manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan->name, newname, chan->uniqueid);
2918         ast_string_field_set(chan, name, newname);
2919 }
2920
2921 void ast_channel_inherit_variables(const struct ast_channel *parent, struct ast_channel *child)
2922 {
2923         struct ast_var_t *current, *newvar;
2924         const char *varname;
2925
2926         AST_LIST_TRAVERSE(&parent->varshead, current, entries) {
2927                 int vartype = 0;
2928
2929                 varname = ast_var_full_name(current);
2930                 if (!varname)
2931                         continue;
2932
2933                 if (varname[0] == '_') {
2934                         vartype = 1;
2935                         if (varname[1] == '_')
2936                                 vartype = 2;
2937                 }
2938
2939                 switch (vartype) {
2940                 case 1:
2941                         newvar = ast_var_assign(&varname[1], ast_var_value(current));
2942                         if (newvar) {
2943                                 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
2944                                 if (option_debug)
2945                                         ast_log(LOG_DEBUG, "Copying soft-transferable variable %s.\n", ast_var_name(newvar));
2946                         }
2947                         break;
2948                 case 2:
2949                         newvar = ast_var_assign(ast_var_full_name(current), ast_var_value(current));
2950                         if (newvar) {
2951                                 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
2952                                 if (option_debug)
2953                                         ast_log(LOG_DEBUG, "Copying hard-transferable variable %s.\n", ast_var_name(newvar));
2954                         }
2955                         break;
2956                 default:
2957                         if (option_debug)
2958                                 ast_log(LOG_DEBUG, "Not copying variable %s.\n", ast_var_name(current));
2959                         break;
2960                 }
2961         }
2962 }
2963
2964 /*!
2965   \brief Clone channel variables from 'clone' channel into 'original' channel
2966
2967   All variables except those related to app_groupcount are cloned.
2968   Variables are actually _removed_ from 'clone' channel, presumably
2969   because it will subsequently be destroyed.
2970
2971   \note Assumes locks will be in place on both channels when called.
2972 */
2973 static void clone_variables(struct ast_channel *original, struct ast_channel *clone)
2974 {
2975         struct ast_var_t *varptr;
2976
2977         /* we need to remove all app_groupcount related variables from the original
2978            channel before merging in the clone's variables; any groups assigned to the
2979            original channel should be released, only those assigned to the clone
2980            should remain
2981         */
2982
2983         AST_LIST_TRAVERSE_SAFE_BEGIN(&original->varshead, varptr, entries) {
2984                 if (!strncmp(ast_var_name(varptr), GROUP_CATEGORY_PREFIX, strlen(GROUP_CATEGORY_PREFIX))) {
2985                         AST_LIST_REMOVE(&original->varshead, varptr, entries);
2986                         ast_var_delete(varptr);
2987                 }
2988         }
2989         AST_LIST_TRAVERSE_SAFE_END;
2990
2991         /* Append variables from clone channel into original channel */
2992         /* XXX Is this always correct?  We have to in order to keep MACROS working XXX */
2993         if (AST_LIST_FIRST(&clone->varshead))
2994                 AST_LIST_INSERT_TAIL(&original->varshead, AST_LIST_FIRST(&clone->varshead), entries);
2995 }
2996
2997 /*!
2998   \brief Masquerade a channel
2999
3000   \note Assumes channel will be locked when called
3001 */
3002 int ast_do_masquerade(struct ast_channel *original)
3003 {
3004         int x,i;
3005         int res=0;
3006         int origstate;
3007         struct ast_frame *cur, *prev;
3008         const struct ast_channel_tech *t;
3009         void *t_pvt;
3010         struct ast_callerid tmpcid;
3011         struct ast_channel *clone = original->masq;
3012         int rformat = original->readformat;
3013         int wformat = original->writeformat;
3014         char newn[100];
3015         char orig[100];
3016         char masqn[100];
3017         char zombn[100];
3018
3019         if (option_debug > 3)
3020                 ast_log(LOG_DEBUG, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
3021                         clone->name, clone->_state, original->name, original->_state);
3022
3023         /* XXX This is a seriously wacked out operation.  We're essentially putting the guts of
3024            the clone channel into the original channel.  Start by killing off the original
3025            channel's backend.   I'm not sure we're going to keep this function, because
3026            while the features are nice, the cost is very high in terms of pure nastiness. XXX */
3027
3028         /* We need the clone's lock, too */
3029         ast_mutex_lock(&clone->lock);
3030
3031         ast_log(LOG_DEBUG, "Got clone lock for masquerade on '%s' at %p\n", clone->name, &clone->lock);
3032
3033         /* Having remembered the original read/write formats, we turn off any translation on either
3034            one */
3035         free_translation(clone);
3036         free_translation(original);
3037
3038
3039         /* Unlink the masquerade */
3040         original->masq = NULL;
3041         clone->masqr = NULL;
3042
3043         /* Save the original name */
3044         ast_copy_string(orig, original->name, sizeof(orig));
3045         /* Save the new name */
3046         ast_copy_string(newn, clone->name, sizeof(newn));
3047         /* Create the masq name */
3048         snprintf(masqn, sizeof(masqn), "%s<MASQ>", newn);
3049
3050         /* Copy the name from the clone channel */
3051         ast_string_field_set(original, name, newn);
3052
3053         /* Mangle the name of the clone channel */
3054         ast_string_field_set(clone, name, masqn);
3055
3056         /* Notify any managers of the change, first the masq then the other */
3057         manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", newn, masqn, clone->uniqueid);
3058         manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", orig, newn, original->uniqueid);
3059
3060         /* Swap the technologies */
3061         t = original->tech;
3062         original->tech = clone->tech;
3063         clone->tech = t;
3064
3065         t_pvt = original->tech_pvt;
3066         original->tech_pvt = clone->tech_pvt;
3067         clone->tech_pvt = t_pvt;
3068
3069         /* Swap the readq's */
3070         cur = original->readq;
3071         original->readq = clone->readq;
3072         clone->readq = cur;
3073
3074         /* Swap the alertpipes */
3075         for (i = 0; i < 2; i++) {
3076                 x = original->alertpipe[i];
3077                 original->alertpipe[i] = clone->alertpipe[i];
3078                 clone->alertpipe[i] = x;
3079         }
3080
3081         /* Swap the raw formats */
3082         x = original->rawreadformat;
3083         original->rawreadformat = clone->rawreadformat;
3084         clone->rawreadformat = x;
3085         x = original->rawwriteformat;
3086         original->rawwriteformat = clone->rawwriteformat;
3087         clone->rawwriteformat = x;
3088
3089         /* Save any pending frames on both sides.  Start by counting
3090          * how many we're going to need... */
3091         prev = NULL;
3092         x = 0;
3093         for (cur = clone->readq; cur; cur = cur->next) {
3094                 x++;
3095                 prev = cur;
3096         }
3097         /* If we had any, prepend them to the ones already in the queue, and
3098          * load up the alertpipe */
3099         if (prev) {
3100                 prev->next = original->readq;
3101                 original->readq = clone->readq;
3102                 clone->readq = NULL;
3103                 if (original->alertpipe[1] > -1) {
3104                         for (i = 0; i < x; i++)
3105                                 write(original->alertpipe[1], &x, sizeof(x));
3106                 }
3107         }
3108         clone->_softhangup = AST_SOFTHANGUP_DEV;
3109
3110
3111         /* And of course, so does our current state.  Note we need not
3112            call ast_setstate since the event manager doesn't really consider
3113            these separate.  We do this early so that the clone has the proper
3114            state of the original channel. */
3115         origstate = original->_state;
3116         original->_state = clone->_state;
3117         clone->_state = origstate;
3118
3119         if (clone->tech->fixup){
3120                 res = clone->tech->fixup(original, clone);
3121                 if (res)
3122                         ast_log(LOG_WARNING, "Fixup failed on channel %s, strange things may happen.\n", clone->name);
3123         }
3124
3125         /* Start by disconnecting the original's physical side */
3126         if (clone->tech->hangup)
3127                 res = clone->tech->hangup(clone);
3128         if (res) {
3129                 ast_log(LOG_WARNING, "Hangup failed!  Strange things may happen!\n");
3130                 ast_mutex_unlock(&clone->lock);
3131                 return -1;
3132         }
3133
3134         snprintf(zombn, sizeof(zombn), "%s<ZOMBIE>", orig);
3135         /* Mangle the name of the clone channel */
3136         ast_string_field_set(clone, name, zombn);
3137         manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", masqn, zombn, clone->uniqueid);
3138
3139         /* Update the type. */
3140         t_pvt = original->monitor;
3141         original->monitor = clone->monitor;
3142         clone->monitor = t_pvt;
3143
3144         /* Keep the same language.  */
3145         ast_string_field_set(original, language, clone->language);
3146         /* Copy the FD's other than the generator fd */
3147         for (x = 0; x < AST_MAX_FDS; x++) {
3148                 if (x != AST_GENERATOR_FD)
3149                         original->fds[x] = clone->fds[x];
3150         }
3151         /* Move data stores over */
3152         if (AST_LIST_FIRST(&clone->datastores))
3153                 AST_LIST_INSERT_TAIL(&original->datastores, AST_LIST_FIRST(&clone->datastores), entry);
3154         AST_LIST_HEAD_INIT_NOLOCK(&clone->datastores);
3155
3156         clone_variables(original, clone);
3157         AST_LIST_HEAD_INIT_NOLOCK(&clone->varshead);
3158         /* Presense of ADSI capable CPE follows clone */
3159         original->adsicpe = clone->adsicpe;
3160         /* Bridge remains the same */
3161         /* CDR fields remain the same */
3162         /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */
3163         /* Application and data remain the same */
3164         /* Clone exception  becomes real one, as with fdno */
3165         ast_copy_flags(original, clone, AST_FLAG_EXCEPTION);
3166         original->fdno = clone->fdno;
3167         /* Schedule context remains the same */
3168         /* Stream stuff stays the same */
3169         /* Keep the original state.  The fixup code will need to work with it most likely */
3170
3171         /* Just swap the whole structures, nevermind the allocations, they'll work themselves
3172            out. */
3173         tmpcid = original->cid;
3174         original->cid = clone->cid;
3175         clone->cid = tmpcid;
3176
3177         /* Restore original timing file descriptor */
3178         original->fds[AST_TIMING_FD] = original->timingfd;
3179
3180         /* Our native formats are different now */
3181         original->nativeformats = clone->nativeformats;
3182
3183         /* Context, extension, priority, app data, jump table,  remain the same */
3184         /* pvt switches.  pbx stays the same, as does next */
3185
3186         /* Set the write format */
3187         ast_set_write_format(original, wformat);
3188
3189         /* Set the read format */
3190         ast_set_read_format(original, rformat);
3191
3192         /* Copy the music class */
3193         ast_string_field_set(original, musicclass, clone->musicclass);
3194
3195         ast_log(LOG_DEBUG, "Putting channel %s in %d/%d formats\n", original->name, wformat, rformat);
3196
3197         /* Okay.  Last thing is to let the channel driver know about all this mess, so he
3198            can fix up everything as best as possible */
3199         if (original->tech->fixup) {
3200                 res = original->tech->fixup(clone, original);
3201                 if (res) {
3202                         ast_log(LOG_WARNING, "Channel for type '%s' could not fixup channel %s\n",
3203                                 original->tech->type, original->name);
3204                         ast_mutex_unlock(&clone->lock);
3205                         return -1;
3206                 }
3207         } else
3208                 ast_log(LOG_WARNING, "Channel type '%s' does not have a fixup routine (for %s)!  Bad things may happen.\n",
3209                         original->tech->type, original->name);
3210
3211         /* Now, at this point, the "clone" channel is totally F'd up.  We mark it as
3212            a zombie so nothing tries to touch it.  If it's already been marked as a
3213            zombie, then free it now (since it already is considered invalid). */
3214         if (ast_test_flag(clone, AST_FLAG_ZOMBIE)) {
3215                 ast_log(LOG_DEBUG, "Destroying channel clone '%s'\n", clone->name);
3216                 ast_mutex_unlock(&clone->lock);
3217                 manager_event(EVENT_FLAG_CALL, "Hangup",
3218                         "Channel: %s\r\n"
3219                         "Uniqueid: %s\r\n"
3220                         "Cause: %d\r\n"
3221                         "Cause-txt: %s\r\n",
3222                         clone->name,
3223                         clone->uniqueid,
3224                         clone->hangupcause,
3225                         ast_cause2str(clone->hangupcause)
3226                         );
3227                 ast_channel_free(clone);
3228         } else {
3229                 ast_log(LOG_DEBUG, "Released clone lock on '%s'\n", clone->name);
3230                 ast_set_flag(clone, AST_FLAG_ZOMBIE);
3231                 ast_queue_frame(clone, &ast_null_frame);
3232                 ast_mutex_unlock(&clone->lock);
3233         }
3234
3235         /* Signal any blocker */
3236         if (ast_test_flag(original, AST_FLAG_BLOCKING))
3237                 pthread_kill(original->blocker, SIGURG);
3238         ast_log(LOG_DEBUG, "Done Masquerading %s (%d)\n", original->name, original->_state);
3239         return 0;
3240 }
3241
3242 void ast_set_callerid(struct ast_channel *chan, const char *callerid, const char *calleridname, const char *ani)
3243 {
3244         if (callerid) {
3245                 if (chan->cid.cid_num)
3246                         free(chan->cid.cid_num);
3247                 if (ast_strlen_zero(callerid))
3248                         chan->cid.cid_num = NULL;
3249                 else
3250                         chan->cid.cid_num = strdup(callerid);
3251         }
3252         if (calleridname) {
3253                 if (chan->cid.cid_name)
3254                         free(chan->cid.cid_name);
3255                 if (ast_strlen_zero(calleridname))
3256                         chan->cid.cid_name = NULL;
3257                 else
3258                         chan->cid.cid_name = strdup(calleridname);
3259         }
3260         if (ani) {
3261                 if (chan->cid.cid_ani)
3262                         free(chan->cid.cid_ani);
3263                 if (ast_strlen_zero(ani))
3264                         chan->cid.cid_ani = NULL;
3265                 else
3266                         chan->cid.cid_ani = strdup(ani);
3267         }
3268         if (chan->cdr)
3269                 ast_cdr_setcid(chan->cdr, chan);
3270         manager_event(EVENT_FLAG_CALL, "Newcallerid",
3271                                 "Channel: %s\r\n"
3272                                 "CallerID: %s\r\n"
3273                                 "CallerIDName: %s\r\n"
3274                                 "Uniqueid: %s\r\n"
3275                                 "CID-CallingPres: %d (%s)\r\n",
3276                                 chan->name, chan->cid.cid_num ?
3277                                         chan->cid.cid_num : "<Unknown>",
3278                                 chan->cid.cid_name ?
3279                                 chan->cid.cid_name : "<Unknown>",
3280                                 chan->uniqueid,
3281                                 chan->cid.cid_pres,
3282                                 ast_describe_caller_presentation(chan->cid.cid_pres)
3283                                 );
3284 }
3285
3286 int ast_setstate(struct ast_channel *chan, int state)
3287 {
3288         int oldstate = chan->_state;
3289
3290         if (oldstate == state)
3291                 return 0;
3292
3293         chan->_state = state;
3294         ast_device_state_changed_literal(chan->name);
3295         manager_event(EVENT_FLAG_CALL,
3296                       (oldstate == AST_STATE_DOWN) ? "Newchannel" : "Newstate",
3297                       "Channel: %s\r\n"
3298                       "State: %s\r\n"
3299                       "CallerID: %s\r\n"
3300                       "CallerIDName: %s\r\n"
3301                       "Uniqueid: %s\r\n",
3302                       chan->name, ast_state2str(chan->_state),
3303                       chan->cid.cid_num ? chan->cid.cid_num : "<unknown>",
3304                       chan->cid.cid_name ? chan->cid.cid_name : "<unknown>",
3305                       chan->uniqueid);
3306
3307         return 0;
3308 }
3309
3310 /*! \brief Find bridged channel */
3311 struct ast_channel *ast_bridged_channel(struct ast_channel *chan)
3312 {
3313         struct ast_channel *bridged;
3314         bridged = chan->_bridge;
3315         if (bridged && bridged->tech->bridged_channel)
3316                 bridged = bridged->tech->bridged_channel(chan, bridged);
3317         return bridged;
3318 }
3319
3320 static void bridge_playfile(struct ast_channel *chan, struct ast_channel *peer, const char *sound, int remain)
3321 {
3322         int min = 0, sec = 0, check;
3323
3324         check = ast_autoservice_start(peer);
3325         if (check)
3326                 return;
3327
3328         if (remain > 0) {
3329                 if (remain / 60 > 1) {
3330                         min = remain / 60;
3331                         sec = remain % 60;
3332                 } else {
3333                         sec = remain;
3334                 }
3335         }
3336
3337         if (!strcmp(sound,"timeleft")) {        /* Queue support */
3338                 ast_streamfile(chan, "vm-youhave", chan->language);
3339                 ast_waitstream(chan, "");
3340                 if (min) {
3341                         ast_say_number(chan, min, AST_DIGIT_ANY, chan->language, (char *) NULL);
3342                         ast_streamfile(chan, "queue-minutes", chan->language);
3343                         ast_waitstream(chan, "");
3344                 }
3345                 if (sec) {
3346                         ast_say_number(chan, sec, AST_DIGIT_ANY, chan->language, (char *) NULL);
3347                         ast_streamfile(chan, "queue-seconds", chan->language);
3348                         ast_waitstream(chan, "");
3349                 }
3350         } else {
3351                 ast_streamfile(chan, sound, chan->language);
3352                 ast_waitstream(chan, "");
3353         }
3354
3355         check = ast_autoservice_stop(peer);
3356 }
3357
3358 static enum ast_bridge_result ast_generic_bridge(struct ast_channel *c0, struct ast_channel *c1,
3359                                                  struct ast_bridge_config *config, struct ast_frame **fo,
3360                                                  struct ast_channel **rc, struct timeval bridge_end)
3361 {
3362         /* Copy voice back and forth between the two channels. */
3363         struct ast_channel *cs[3];
3364         struct ast_frame *f;
3365         struct ast_channel *who = NULL;
3366         enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
3367         int o0nativeformats;
3368         int o1nativeformats;
3369         int watch_c0_dtmf;
3370         int watch_c1_dtmf;
3371         void *pvt0, *pvt1;
3372         int to;
3373
3374         cs[0] = c0;
3375         cs[1] = c1;
3376         pvt0 = c0->tech_pvt;
3377         pvt1 = c1->tech_pvt;
3378         o0nativeformats = c0->nativeformats;
3379         o1nativeformats = c1->nativeformats;
3380         watch_c0_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_0;
3381         watch_c1_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_1;
3382
3383         for (;;) {
3384                 if ((c0->tech_pvt != pvt0) || (c1->tech_pvt != pvt1) ||
3385                     (o0nativeformats != c0->nativeformats) ||
3386                     (o1nativeformats != c1->nativeformats)) {
3387                         /* Check for Masquerade, codec changes, etc */
3388                         res = AST_BRIDGE_RETRY;
3389                         break;
3390                 }
3391                 if (bridge_end.tv_sec) {
3392                         to = ast_tvdiff_ms(bridge_end, ast_tvnow());
3393                         if (to <= 0) {
3394                                 res = AST_BRIDGE_RETRY;
3395                                 break;
3396                         }
3397                 } else
3398                         to = -1;
3399                 who = ast_waitfor_n(cs, 2, &to);
3400                 if (!who) {
3401                         ast_log(LOG_DEBUG, "Nobody there, continuing...\n");
3402                         if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
3403                                 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
3404                                         c0->_softhangup = 0;
3405                                 if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
3406                                         c1->_softhangup = 0;
3407                                 c0->_bridge = c1;
3408                                 c1->_bridge = c0;
3409                         }
3410                         continue;
3411                 }
3412                 f = ast_read(who);
3413                 if (!f) {
3414                         *fo = NULL;
3415                         *rc = who;
3416                         res = AST_BRIDGE_COMPLETE;
3417                         ast_log(LOG_DEBUG, "Didn't get a frame from channel: %s\n",who->name);
3418                         break;
3419                 }
3420
3421                 if ((f->frametype == AST_FRAME_CONTROL) && !(config->flags & AST_BRIDGE_IGNORE_SIGS)) {
3422                         if ((f->subclass == AST_CONTROL_HOLD) || (f->subclass == AST_CONTROL_UNHOLD) ||
3423                             (f->subclass == AST_CONTROL_VIDUPDATE)) {
3424                                 ast_indicate(who == c0 ? c1 : c0, f->subclass);
3425                         } else {
3426                                 *fo = f;
3427                                 *rc = who;
3428                                 res =  AST_BRIDGE_COMPLETE;
3429                                 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
3430                                 break;
3431                         }
3432                 }
3433                 if ((f->frametype == AST_FRAME_VOICE) ||
3434                     (f->frametype == AST_FRAME_DTMF) ||
3435                     (f->frametype == AST_FRAME_VIDEO) ||
3436                     (f->frametype == AST_FRAME_IMAGE) ||
3437                     (f->frametype == AST_FRAME_HTML) ||
3438 #if defined(T38_SUPPORT)
3439                     (f->frametype == AST_FRAME_MODEM) ||
3440 #endif
3441                     (f->frametype == AST_FRAME_TEXT)) {
3442                         if (f->frametype == AST_FRAME_DTMF) {
3443                                 if (((who == c0) && watch_c0_dtmf) ||
3444                                     ((who == c1) && watch_c1_dtmf)) {
3445                                         *rc = who;
3446                                         *fo = f;
3447                                         res = AST_BRIDGE_COMPLETE;
3448                                         ast_log(LOG_DEBUG, "Got DTMF on channel (%s)\n", who->name);
3449                                         break;
3450                                 } else {
3451                                         goto tackygoto;
3452                                 }
3453                         } else {
3454 #if 0
3455                                 ast_log(LOG_DEBUG, "Read from %s\n", who->name);
3456                                 if (who == last)
3457                                         ast_log(LOG_DEBUG, "Servicing channel %s twice in a row?\n", last->name);
3458                                 last = who;
3459 #endif
3460 tackygoto:
3461                                 ast_write((who == c0) ? c1 : c0, f);
3462                         }
3463                 }
3464                 ast_frfree(f);
3465
3466                 /* Swap who gets priority */
3467                 cs[2] = cs[0];
3468                 cs[0] = cs[1];
3469                 cs[1] = cs[2];
3470         }
3471         return res;
3472 }
3473
3474 /*! \brief Bridge two channels together */
3475 enum ast_bridge_result ast_channel_bridge(struct ast_channel *c0, struct ast_channel *c1,
3476                                           struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc)
3477 {
3478         struct ast_channel *who = NULL;
3479         enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
3480         int nativefailed=0;
3481         int firstpass;
3482         int o0nativeformats;
3483         int o1nativeformats;
3484         long time_left_ms=0;
3485         struct timeval nexteventts = { 0, };
3486         char caller_warning = 0;
3487         char callee_warning = 0;
3488         int to;
3489
3490         if (c0->_bridge) {
3491                 ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
3492                         c0->name, c0->_bridge->name);
3493                 return -1;
3494         }
3495         if (c1->_bridge) {
3496                 ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
3497                         c1->name, c1->_bridge->name);
3498                 return -1;
3499         }
3500
3501         /* Stop if we're a zombie or need a soft hangup */
3502         if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
3503             ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1))
3504                 return -1;
3505
3506         *fo = NULL;
3507         firstpass = config->firstpass;
3508         config->firstpass = 0;
3509
3510         if (ast_tvzero(config->start_time))
3511                 config->start_time = ast_tvnow();
3512         time_left_ms = config->timelimit;
3513
3514         caller_warning = ast_test_flag(&config->features_caller, AST_FEATURE_PLAY_WARNING);
3515         callee_warning = ast_test_flag(&config->features_callee, AST_FEATURE_PLAY_WARNING);
3516
3517         if (config->start_sound && firstpass) {
3518                 if (caller_warning)
3519                         bridge_playfile(c0, c1, config->start_sound, time_left_ms / 1000);
3520                 if (callee_warning)
3521                         bridge_playfile(c1, c0, config->start_sound, time_left_ms / 1000);
3522         }
3523
3524         /* Keep track of bridge */
3525         c0->_bridge = c1;
3526         c1->_bridge = c0;
3527
3528         manager_event(EVENT_FLAG_CALL, "Link",
3529                       "Channel1: %s\r\n"
3530                       "Channel2: %s\r\n"
3531                       "Uniqueid1: %s\r\n"
3532                       "Uniqueid2: %s\r\n"
3533                       "CallerID1: %s\r\n"
3534                       "CallerID2: %s\r\n",
3535                       c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
3536
3537         o0nativeformats = c0->nativeformats;
3538         o1nativeformats = c1->nativeformats;
3539
3540         if (config->timelimit) {
3541                 nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
3542                 if (caller_warning || callee_warning)
3543                         nexteventts = ast_tvsub(nexteventts, ast_samp2tv(config->play_warning, 1000));
3544         }
3545
3546         for (/* ever */;;) {
3547                 to = -1;
3548                 if (config->timelimit) {
3549                         struct timeval now;
3550                         now = ast_tvnow();
3551                         to = ast_tvdiff_ms(nexteventts, now);
3552                         if (to < 0)
3553                                 to = 0;
3554                         time_left_ms = config->timelimit - ast_tvdiff_ms(now, config->start_time);
3555                         if (time_left_ms < to)
3556                                 to = time_left_ms;
3557
3558                         if (time_left_ms <= 0) {
3559                                 if (caller_warning && config->end_sound)
3560                                         bridge_playfile(c0, c1, config->end_sound, 0);
3561                                 if (callee_warning && config->end_sound)
3562                                         bridge_playfile(c1, c0, config->end_sound, 0);
3563                                 *fo = NULL;
3564                                 if (who)
3565                                         *rc = who;
3566                                 res = 0;
3567                                 break;
3568                         }
3569
3570                         if (!to) {
3571                                 if (time_left_ms >= 5000) {
3572                                         /* force the time left to round up if appropriate */
3573                                         if (caller_warning && config->warning_sound && config->play_warning)
3574                                                 bridge_playfile(c0, c1, config->warning_sound,
3575                                                                 (time_left_ms + 500) / 1000);
3576                                         if (callee_warning && config->warning_sound && config->play_warning)
3577                                                 bridge_playfile(c1, c0, config->warning_sound,
3578                                                                 (time_left_ms + 500) / 1000);
3579                                 }
3580                                 if (config->warning_freq) {
3581                                         nexteventts = ast_tvadd(nexteventts, ast_samp2tv(config->warning_freq, 1000));
3582                                 } else
3583                                         nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
3584                         }
3585                 }
3586
3587                 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
3588                         if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
3589                                 c0->_softhangup = 0;
3590   &nbs