main/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 "asterisk.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <stdarg.h>
  33 #include <string.h>
  34 #include <sys/time.h>
  35 #include <signal.h>
  36 #include <errno.h>
  37 #include <unistd.h>
  38 #include <math.h>
  39
  40 #include "asterisk/zapata.h"
  41
  42 #include "asterisk/pbx.h"
  43 #include "asterisk/frame.h"
  44 #include "asterisk/sched.h"
  45 #include "asterisk/options.h"
  46 #include "asterisk/channel.h"
  47 #include "asterisk/musiconhold.h"
  48 #include "asterisk/logger.h"
  49 #include "asterisk/say.h"
  50 #include "asterisk/file.h"
  51 #include "asterisk/cli.h"
  52 #include "asterisk/translate.h"
  53 #include "asterisk/manager.h"
  54 #include "asterisk/chanvars.h"
  55 #include "asterisk/linkedlists.h"
  56 #include "asterisk/indications.h"
  57 #include "asterisk/monitor.h"
  58 #include "asterisk/causes.h"
  59 #include "asterisk/callerid.h"
  60 #include "asterisk/utils.h"
  61 #include "asterisk/lock.h"
  62 #include "asterisk/app.h"
  63 #include "asterisk/transcap.h"
  64 #include "asterisk/devicestate.h"
  65 #include "asterisk/sha1.h"
  66 #include "asterisk/threadstorage.h"
  67 #include "asterisk/slinfactory.h"
  68 #include "asterisk/audiohook.h"
  69
  70 #ifdef HAVE_EPOLL
  71 #include <sys/epoll.h>
  72 #endif
  73
  74 struct ast_epoll_data {
  75         struct ast_channel *chan;
  76         int which;
  77 };
  78
  79 /* uncomment if you have problems with 'monitoring' synchronized files */
  80 #if 0
  81 #define MONITOR_CONSTANT_DELAY
  82 #define MONITOR_DELAY   150 * 8         /*!< 150 ms of MONITORING DELAY */
  83 #endif
  84
  85 /*! \brief Prevent new channel allocation if shutting down. */
  86 static int shutting_down;
  87
  88 static int uniqueint;
  89
  90 unsigned long global_fin, global_fout;
  91
  92 AST_THREADSTORAGE(state2str_threadbuf);
  93 #define STATE2STR_BUFSIZE   32
  94
  95 /*! Default amount of time to use when emulating a digit as a begin and end
  96  *  100ms */
  97 #define AST_DEFAULT_EMULATE_DTMF_DURATION 100
  98
  99 /*! Minimum allowed digit length - 80ms */
 100 #define AST_MIN_DTMF_DURATION 80
 101
 102 /*! Minimum amount of time between the end of the last digit and the beginning
 103  *  of a new one - 45ms */
 104 #define AST_MIN_DTMF_GAP 45
 105
 106 /*! \brief List of channel drivers */
 107 struct chanlist {
 108         const struct ast_channel_tech *tech;
 109         AST_LIST_ENTRY(chanlist) list;
 110 };
 111
 112 /*! \brief the list of registered channel types */
 113 static AST_LIST_HEAD_NOLOCK_STATIC(backends, chanlist);
 114
 115 /*! \brief the list of channels we have. Note that the lock for this list is used for
 116     both the channels list and the backends list.  */
 117 static AST_RWLIST_HEAD_STATIC(channels, ast_channel);
 118
 119 /*! \brief map AST_CAUSE's to readable string representations
 120  *
 121  * \ref causes.h
 122 */
 123 const struct ast_cause {
 124         int cause;
 125         const char *name;
 126         const char *desc;
 127 } causes[] = {
 128         { AST_CAUSE_UNALLOCATED, "UNALLOCATED", "Unallocated (unassigned) number" },
 129         { AST_CAUSE_NO_ROUTE_TRANSIT_NET, "NO_ROUTE_TRANSIT_NET", "No route to specified transmit network" },
 130         { AST_CAUSE_NO_ROUTE_DESTINATION, "NO_ROUTE_DESTINATION", "No route to destination" },
 131         { AST_CAUSE_CHANNEL_UNACCEPTABLE, "CHANNEL_UNACCEPTABLE", "Channel unacceptable" },
 132         { AST_CAUSE_CALL_AWARDED_DELIVERED, "CALL_AWARDED_DELIVERED", "Call awarded and being delivered in an established channel" },
 133         { AST_CAUSE_NORMAL_CLEARING, "NORMAL_CLEARING", "Normal Clearing" },
 134         { AST_CAUSE_USER_BUSY, "USER_BUSY", "User busy" },
 135         { AST_CAUSE_NO_USER_RESPONSE, "NO_USER_RESPONSE", "No user responding" },
 136         { AST_CAUSE_NO_ANSWER, "NO_ANSWER", "User alerting, no answer" },
 137         { AST_CAUSE_CALL_REJECTED, "CALL_REJECTED", "Call Rejected" },
 138         { AST_CAUSE_NUMBER_CHANGED, "NUMBER_CHANGED", "Number changed" },
 139         { AST_CAUSE_DESTINATION_OUT_OF_ORDER, "DESTINATION_OUT_OF_ORDER", "Destination out of order" },
 140         { AST_CAUSE_INVALID_NUMBER_FORMAT, "INVALID_NUMBER_FORMAT", "Invalid number format" },
 141         { AST_CAUSE_FACILITY_REJECTED, "FACILITY_REJECTED", "Facility rejected" },
 142         { AST_CAUSE_RESPONSE_TO_STATUS_ENQUIRY, "RESPONSE_TO_STATUS_ENQUIRY", "Response to STATus ENQuiry" },
 143         { AST_CAUSE_NORMAL_UNSPECIFIED, "NORMAL_UNSPECIFIED", "Normal, unspecified" },
 144         { AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, "NORMAL_CIRCUIT_CONGESTION", "Circuit/channel congestion" },
 145         { AST_CAUSE_NETWORK_OUT_OF_ORDER, "NETWORK_OUT_OF_ORDER", "Network out of order" },
 146         { AST_CAUSE_NORMAL_TEMPORARY_FAILURE, "NORMAL_TEMPORARY_FAILURE", "Temporary failure" },
 147         { AST_CAUSE_SWITCH_CONGESTION, "SWITCH_CONGESTION", "Switching equipment congestion" },
 148         { AST_CAUSE_ACCESS_INFO_DISCARDED, "ACCESS_INFO_DISCARDED", "Access information discarded" },
 149         { AST_CAUSE_REQUESTED_CHAN_UNAVAIL, "REQUESTED_CHAN_UNAVAIL", "Requested channel not available" },
 150         { AST_CAUSE_PRE_EMPTED, "PRE_EMPTED", "Pre-empted" },
 151         { AST_CAUSE_FACILITY_NOT_SUBSCRIBED, "FACILITY_NOT_SUBSCRIBED", "Facility not subscribed" },
 152         { AST_CAUSE_OUTGOING_CALL_BARRED, "OUTGOING_CALL_BARRED", "Outgoing call barred" },
 153         { AST_CAUSE_INCOMING_CALL_BARRED, "INCOMING_CALL_BARRED", "Incoming call barred" },
 154         { AST_CAUSE_BEARERCAPABILITY_NOTAUTH, "BEARERCAPABILITY_NOTAUTH", "Bearer capability not authorized" },
 155         { AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, "BEARERCAPABILITY_NOTAVAIL", "Bearer capability not available" },
 156         { AST_CAUSE_BEARERCAPABILITY_NOTIMPL, "BEARERCAPABILITY_NOTIMPL", "Bearer capability not implemented" },
 157         { AST_CAUSE_CHAN_NOT_IMPLEMENTED, "CHAN_NOT_IMPLEMENTED", "Channel not implemented" },
 158         { AST_CAUSE_FACILITY_NOT_IMPLEMENTED, "FACILITY_NOT_IMPLEMENTED", "Facility not implemented" },
 159         { AST_CAUSE_INVALID_CALL_REFERENCE, "INVALID_CALL_REFERENCE", "Invalid call reference value" },
 160         { AST_CAUSE_INCOMPATIBLE_DESTINATION, "INCOMPATIBLE_DESTINATION", "Incompatible destination" },
 161         { AST_CAUSE_INVALID_MSG_UNSPECIFIED, "INVALID_MSG_UNSPECIFIED", "Invalid message unspecified" },
 162         { AST_CAUSE_MANDATORY_IE_MISSING, "MANDATORY_IE_MISSING", "Mandatory information element is missing" },
 163         { AST_CAUSE_MESSAGE_TYPE_NONEXIST, "MESSAGE_TYPE_NONEXIST", "Message type nonexist." },
 164         { AST_CAUSE_WRONG_MESSAGE, "WRONG_MESSAGE", "Wrong message" },
 165         { AST_CAUSE_IE_NONEXIST, "IE_NONEXIST", "Info. element nonexist or not implemented" },
 166         { AST_CAUSE_INVALID_IE_CONTENTS, "INVALID_IE_CONTENTS", "Invalid information element contents" },
 167         { AST_CAUSE_WRONG_CALL_STATE, "WRONG_CALL_STATE", "Message not compatible with call state" },
 168         { AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, "RECOVERY_ON_TIMER_EXPIRE", "Recover on timer expiry" },
 169         { AST_CAUSE_MANDATORY_IE_LENGTH_ERROR, "MANDATORY_IE_LENGTH_ERROR", "Mandatory IE length error" },
 170         { AST_CAUSE_PROTOCOL_ERROR, "PROTOCOL_ERROR", "Protocol error, unspecified" },
 171         { AST_CAUSE_INTERWORKING, "INTERWORKING", "Interworking, unspecified" },
 172 };
 173
 174 struct ast_variable *ast_channeltype_list(void)
 175 {
 176         struct chanlist *cl;
 177         struct ast_variable *var=NULL, *prev = NULL;
 178         AST_LIST_TRAVERSE(&backends, cl, list) {
 179                 if (prev)  {
 180                         if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description, "")))
 181                                 prev = prev->next;
 182                 } else {
 183                         var = ast_variable_new(cl->tech->type, cl->tech->description, "");
 184                         prev = var;
 185                 }
 186         }
 187         return var;
 188 }
 189
 190 /*! \brief Show channel types - CLI command */
 191 static char *handle_cli_core_show_channeltypes(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 192 {
 193 #define FORMAT  "%-10.10s  %-40.40s %-12.12s %-12.12s %-12.12s\n"
 194         struct chanlist *cl;
 195         int count_chan = 0;
 196
 197         switch (cmd) {
 198         case CLI_INIT:
 199                 e->command = "core show channeltypes";
 200                 e->usage =
 201                         "Usage: core show channeltypes\n"
 202                         "       Lists available channel types registered in your\n"
 203                         "       Asterisk server.\n";
 204                 return NULL;
 205         case CLI_GENERATE:
 206                 return NULL;
 207         }
 208
 209         if (a->argc != 3)
 210                 return CLI_SHOWUSAGE;
 211
 212         ast_cli(a->fd, FORMAT, "Type", "Description",       "Devicestate", "Indications", "Transfer");
 213         ast_cli(a->fd, FORMAT, "----------", "-----------", "-----------", "-----------", "--------");
 214         if (AST_RWLIST_RDLOCK(&channels)) {
 215                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
 216                 return CLI_FAILURE;
 217         }
 218         AST_LIST_TRAVERSE(&backends, cl, list) {
 219                 ast_cli(a->fd, FORMAT, cl->tech->type, cl->tech->description,
 220                         (cl->tech->devicestate) ? "yes" : "no",
 221                         (cl->tech->indicate) ? "yes" : "no",
 222                         (cl->tech->transfer) ? "yes" : "no");
 223                 count_chan++;
 224         }
 225         AST_RWLIST_UNLOCK(&channels);
 226         ast_cli(a->fd, "----------\n%d channel drivers registered.\n", count_chan);
 227         return CLI_SUCCESS;
 228
 229 #undef FORMAT
 230 }
 231
 232 static char *complete_channeltypes(struct ast_cli_args *a)
 233 {
 234         struct chanlist *cl;
 235         int which = 0;
 236         int wordlen;
 237         char *ret = NULL;
 238
 239         if (a->pos != 3)
 240                 return NULL;
 241
 242         wordlen = strlen(a->word);
 243
 244         AST_LIST_TRAVERSE(&backends, cl, list) {
 245                 if (!strncasecmp(a->word, cl->tech->type, wordlen) && ++which > a->n) {
 246                         ret = ast_strdup(cl->tech->type);
 247                         break;
 248                 }
 249         }
 250
 251         return ret;
 252 }
 253
 254 /*! \brief Show details about a channel driver - CLI command */
 255 static char *handle_cli_core_show_channeltype(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 256 {
 257         struct chanlist *cl = NULL;
 258
 259         switch (cmd) {
 260         case CLI_INIT:
 261                 e->command = "core show channeltype";
 262                 e->usage =
 263                         "Usage: core show channeltype <name>\n"
 264                         "       Show details about the specified channel type, <name>.\n";
 265                 return NULL;
 266         case CLI_GENERATE:
 267                 return complete_channeltypes(a);
 268         }
 269
 270         if (a->argc != 4)
 271                 return CLI_SHOWUSAGE;
 272
 273         if (AST_RWLIST_RDLOCK(&channels)) {
 274                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
 275                 return CLI_FAILURE;
 276         }
 277
 278         AST_LIST_TRAVERSE(&backends, cl, list) {
 279                 if (!strncasecmp(cl->tech->type, a->argv[3], strlen(cl->tech->type)))
 280                         break;
 281         }
 282
 283
 284         if (!cl) {
 285                 ast_cli(a->fd, "\n%s is not a registered channel driver.\n", a->argv[3]);
 286                 AST_RWLIST_UNLOCK(&channels);
 287                 return CLI_FAILURE;
 288         }
 289
 290         ast_cli(a->fd,
 291                 "-- Info about channel driver: %s --\n"
 292                 "  Device State: %s\n"
 293                 "    Indication: %s\n"
 294                 "     Transfer : %s\n"
 295                 "  Capabilities: %d\n"
 296                 "   Digit Begin: %s\n"
 297                 "     Digit End: %s\n"
 298                 "    Send HTML : %s\n"
 299                 " Image Support: %s\n"
 300                 "  Text Support: %s\n",
 301                 cl->tech->type,
 302                 (cl->tech->devicestate) ? "yes" : "no",
 303                 (cl->tech->indicate) ? "yes" : "no",
 304                 (cl->tech->transfer) ? "yes" : "no",
 305                 (cl->tech->capabilities) ? cl->tech->capabilities : -1,
 306                 (cl->tech->send_digit_begin) ? "yes" : "no",
 307                 (cl->tech->send_digit_end) ? "yes" : "no",
 308                 (cl->tech->send_html) ? "yes" : "no",
 309                 (cl->tech->send_image) ? "yes" : "no",
 310                 (cl->tech->send_text) ? "yes" : "no"
 311
 312         );
 313
 314         AST_RWLIST_UNLOCK(&channels);
 315         return CLI_SUCCESS;
 316 }
 317
 318 static struct ast_cli_entry cli_channel[] = {
 319         AST_CLI_DEFINE(handle_cli_core_show_channeltypes, "List available channel types"),
 320         AST_CLI_DEFINE(handle_cli_core_show_channeltype,  "Give more details on that channel type")
 321 };
 322
 323 /*! \brief Checks to see if a channel is needing hang up */
 324 int ast_check_hangup(struct ast_channel *chan)
 325 {
 326         if (chan->_softhangup)          /* yes if soft hangup flag set */
 327                 return 1;
 328         if (!chan->tech_pvt)            /* yes if no technology private data */
 329                 return 1;
 330         if (!chan->whentohangup)        /* no if no hangup scheduled */
 331                 return 0;
 332         if (chan->whentohangup > time(NULL))    /* no if hangup time has not come yet. */
 333                 return 0;
 334         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;    /* record event */
 335         return 1;
 336 }
 337
 338 static int ast_check_hangup_locked(struct ast_channel *chan)
 339 {
 340         int res;
 341         ast_channel_lock(chan);
 342         res = ast_check_hangup(chan);
 343         ast_channel_unlock(chan);
 344         return res;
 345 }
 346
 347 /*! \brief Initiate system shutdown */
 348 void ast_begin_shutdown(int hangup)
 349 {
 350         struct ast_channel *c;
 351         shutting_down = 1;
 352         if (hangup) {
 353                 AST_RWLIST_RDLOCK(&channels);
 354                 AST_RWLIST_TRAVERSE(&channels, c, chan_list)
 355                         ast_softhangup(c, AST_SOFTHANGUP_SHUTDOWN);
 356                 AST_RWLIST_UNLOCK(&channels);
 357         }
 358 }
 359
 360 /*! \brief returns number of active/allocated channels */
 361 int ast_active_channels(void)
 362 {
 363         struct ast_channel *c;
 364         int cnt = 0;
 365         AST_RWLIST_RDLOCK(&channels);
 366         AST_RWLIST_TRAVERSE(&channels, c, chan_list)
 367                 cnt++;
 368         AST_RWLIST_UNLOCK(&channels);
 369         return cnt;
 370 }
 371
 372 /*! \brief Cancel a shutdown in progress */
 373 void ast_cancel_shutdown(void)
 374 {
 375         shutting_down = 0;
 376 }
 377
 378 /*! \brief Returns non-zero if Asterisk is being shut down */
 379 int ast_shutting_down(void)
 380 {
 381         return shutting_down;
 382 }
 383
 384 /*! \brief Set when to hangup channel */
 385 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset)
 386 {
 387         chan->whentohangup = offset ? time(NULL) + offset : 0;
 388         ast_queue_frame(chan, &ast_null_frame);
 389         return;
 390 }
 391
 392 /*! \brief Compare a offset with when to hangup channel */
 393 int ast_channel_cmpwhentohangup(struct ast_channel *chan, time_t offset)
 394 {
 395         time_t whentohangup;
 396
 397         if (!chan->whentohangup)
 398                 return (offset == 0) ? 0 : -1;
 399
 400         if (!offset) /* XXX why is this special? */
 401                 return 1;
 402
 403         whentohangup = offset + time(NULL);
 404
 405         if (chan->whentohangup < whentohangup)
 406                 return 1;
 407         else if (chan->whentohangup == whentohangup)
 408                 return 0;
 409         else
 410                 return -1;
 411 }
 412
 413 /*! \brief Register a new telephony channel in Asterisk */
 414 int ast_channel_register(const struct ast_channel_tech *tech)
 415 {
 416         struct chanlist *chan;
 417
 418         AST_RWLIST_WRLOCK(&channels);
 419
 420         AST_LIST_TRAVERSE(&backends, chan, list) {
 421                 if (!strcasecmp(tech->type, chan->tech->type)) {
 422                         ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
 423                         AST_RWLIST_UNLOCK(&channels);
 424                         return -1;
 425                 }
 426         }
 427
 428         if (!(chan = ast_calloc(1, sizeof(*chan)))) {
 429                 AST_RWLIST_UNLOCK(&channels);
 430                 return -1;
 431         }
 432         chan->tech = tech;
 433         AST_LIST_INSERT_HEAD(&backends, chan, list);
 434
 435         ast_debug(1, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);
 436
 437         ast_verb(2, "Registered channel type '%s' (%s)\n", chan->tech->type, chan->tech->description);
 438
 439         AST_RWLIST_UNLOCK(&channels);
 440         return 0;
 441 }
 442
 443 /*! \brief Unregister channel driver */
 444 void ast_channel_unregister(const struct ast_channel_tech *tech)
 445 {
 446         struct chanlist *chan;
 447
 448         ast_debug(1, "Unregistering channel type '%s'\n", tech->type);
 449
 450         AST_RWLIST_WRLOCK(&channels);
 451
 452         AST_LIST_TRAVERSE_SAFE_BEGIN(&backends, chan, list) {
 453                 if (chan->tech == tech) {
 454                         AST_LIST_REMOVE_CURRENT(list);
 455                         ast_free(chan);
 456                         ast_verb(2, "Unregistered channel type '%s'\n", tech->type);
 457                         break;
 458                 }
 459         }
 460         AST_LIST_TRAVERSE_SAFE_END;
 461
 462         AST_RWLIST_UNLOCK(&channels);
 463 }
 464
 465 /*! \brief Get handle to channel driver based on name */
 466 const struct ast_channel_tech *ast_get_channel_tech(const char *name)
 467 {
 468         struct chanlist *chanls;
 469         const struct ast_channel_tech *ret = NULL;
 470
 471         if (AST_RWLIST_RDLOCK(&channels)) {
 472                 ast_log(LOG_WARNING, "Unable to lock channel tech list\n");
 473                 return NULL;
 474         }
 475
 476         AST_LIST_TRAVERSE(&backends, chanls, list) {
 477                 if (!strcasecmp(name, chanls->tech->type)) {
 478                         ret = chanls->tech;
 479                         break;
 480                 }
 481         }
 482
 483         AST_RWLIST_UNLOCK(&channels);
 484
 485         return ret;
 486 }
 487
 488 /*! \brief Gives the string form of a given hangup cause */
 489 const char *ast_cause2str(int cause)
 490 {
 491         int x;
 492
 493         for (x=0; x < sizeof(causes) / sizeof(causes[0]); x++) {
 494                 if (causes[x].cause == cause)
 495                         return causes[x].desc;
 496         }
 497
 498         return "Unknown";
 499 }
 500
 501 /*! \brief Convert a symbolic hangup cause to number */
 502 int ast_str2cause(const char *name)
 503 {
 504         int x;
 505
 506         for (x = 0; x < sizeof(causes) / sizeof(causes[0]); x++)
 507                 if (strncasecmp(causes[x].name, name, strlen(causes[x].name)) == 0)
 508                         return causes[x].cause;
 509
 510         return -1;
 511 }
 512
 513 /*! \brief Gives the string form of a given channel state.
 514         \note This function is not reentrant.
 515  */
 516 const char *ast_state2str(enum ast_channel_state state)
 517 {
 518         char *buf;
 519
 520         switch (state) {
 521         case AST_STATE_DOWN:
 522                 return "Down";
 523         case AST_STATE_RESERVED:
 524                 return "Rsrvd";
 525         case AST_STATE_OFFHOOK:
 526                 return "OffHook";
 527         case AST_STATE_DIALING:
 528                 return "Dialing";
 529         case AST_STATE_RING:
 530                 return "Ring";
 531         case AST_STATE_RINGING:
 532                 return "Ringing";
 533         case AST_STATE_UP:
 534                 return "Up";
 535         case AST_STATE_BUSY:
 536                 return "Busy";
 537         case AST_STATE_DIALING_OFFHOOK:
 538                 return "Dialing Offhook";
 539         case AST_STATE_PRERING:
 540                 return "Pre-ring";
 541         default:
 542                 if (!(buf = ast_threadstorage_get(&state2str_threadbuf, STATE2STR_BUFSIZE)))
 543                         return "Unknown";
 544                 snprintf(buf, STATE2STR_BUFSIZE, "Unknown (%d)", state);
 545                 return buf;
 546         }
 547 }
 548
 549 /*! \brief Gives the string form of a given transfer capability */
 550 char *ast_transfercapability2str(int transfercapability)
 551 {
 552         switch (transfercapability) {
 553         case AST_TRANS_CAP_SPEECH:
 554                 return "SPEECH";
 555         case AST_TRANS_CAP_DIGITAL:
 556                 return "DIGITAL";
 557         case AST_TRANS_CAP_RESTRICTED_DIGITAL:
 558                 return "RESTRICTED_DIGITAL";
 559         case AST_TRANS_CAP_3_1K_AUDIO:
 560                 return "3K1AUDIO";
 561         case AST_TRANS_CAP_DIGITAL_W_TONES:
 562                 return "DIGITAL_W_TONES";
 563         case AST_TRANS_CAP_VIDEO:
 564                 return "VIDEO";
 565         default:
 566                 return "UNKNOWN";
 567         }
 568 }
 569
 570 /*! \brief Pick the best audio codec */
 571 int ast_best_codec(int fmts)
 572 {
 573         /* This just our opinion, expressed in code.  We are asked to choose
 574            the best codec to use, given no information */
 575         int x;
 576         static const int prefs[] =
 577         {
 578                 /*! Okay, ulaw is used by all telephony equipment, so start with it */
 579                 AST_FORMAT_ULAW,
 580                 /*! Unless of course, you're a silly European, so then prefer ALAW */
 581                 AST_FORMAT_ALAW,
 582                 /*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */
 583                 AST_FORMAT_G722,
 584                 /*! Okay, well, signed linear is easy to translate into other stuff */
 585                 AST_FORMAT_SLINEAR,
 586                 /*! G.726 is standard ADPCM, in RFC3551 packing order */
 587                 AST_FORMAT_G726,
 588                 /*! G.726 is standard ADPCM, in AAL2 packing order */
 589                 AST_FORMAT_G726_AAL2,
 590                 /*! ADPCM has great sound quality and is still pretty easy to translate */
 591                 AST_FORMAT_ADPCM,
 592                 /*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
 593                     translate and sounds pretty good */
 594                 AST_FORMAT_GSM,
 595                 /*! iLBC is not too bad */
 596                 AST_FORMAT_ILBC,
 597                 /*! Speex is free, but computationally more expensive than GSM */
 598                 AST_FORMAT_SPEEX,
 599                 /*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
 600                     to use it */
 601                 AST_FORMAT_LPC10,
 602                 /*! G.729a is faster than 723 and slightly less expensive */
 603                 AST_FORMAT_G729A,
 604                 /*! Down to G.723.1 which is proprietary but at least designed for voice */
 605                 AST_FORMAT_G723_1,
 606         };
 607
 608         /* Strip out video */
 609         fmts &= AST_FORMAT_AUDIO_MASK;
 610
 611         /* Find the first preferred codec in the format given */
 612         for (x=0; x < (sizeof(prefs) / sizeof(prefs[0]) ); x++)
 613                 if (fmts & prefs[x])
 614                         return prefs[x];
 615         ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts);
 616         return 0;
 617 }
 618
 619 static const struct ast_channel_tech null_tech = {
 620         .type = "NULL",
 621         .description = "Null channel (should not see this)",
 622 };
 623
 624 /*! \brief Create a new channel structure */
 625 struct ast_channel *ast_channel_alloc(int needqueue, int state, const char *cid_num, const char *cid_name, const char *acctcode, const char *exten, const char *context, const int amaflag, const char *name_fmt, ...)
 626 {
 627         struct ast_channel *tmp;
 628         int x;
 629         int flags;
 630         struct varshead *headp;
 631         va_list ap1, ap2;
 632
 633         /* If shutting down, don't allocate any new channels */
 634         if (shutting_down) {
 635                 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
 636                 return NULL;
 637         }
 638
 639         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
 640                 return NULL;
 641
 642         if (!(tmp->sched = sched_context_create())) {
 643                 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
 644                 ast_free(tmp);
 645                 return NULL;
 646         }
 647
 648         if ((ast_string_field_init(tmp, 128))) {
 649                 sched_context_destroy(tmp->sched);
 650                 ast_free(tmp);
 651                 return NULL;
 652         }
 653
 654 #ifdef HAVE_EPOLL
 655         tmp->epfd = epoll_create(25);
 656 #endif
 657
 658         for (x = 0; x < AST_MAX_FDS; x++) {
 659                 tmp->fds[x] = -1;
 660 #ifdef HAVE_EPOLL
 661                 tmp->epfd_data[x] = NULL;
 662 #endif
 663         }
 664
 665 #ifdef HAVE_ZAPTEL
 666         tmp->timingfd = open("/dev/zap/timer", O_RDWR);
 667         if (tmp->timingfd > -1) {
 668                 /* Check if timing interface supports new
 669                    ping/pong scheme */
 670                 flags = 1;
 671                 if (!ioctl(tmp->timingfd, ZT_TIMERPONG, &flags))
 672                         needqueue = 0;
 673         }
 674 #else
 675         tmp->timingfd = -1;
 676 #endif
 677
 678         if (needqueue) {
 679                 if (pipe(tmp->alertpipe)) {
 680                         ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
 681                         ast_string_field_free_memory(tmp);
 682                         ast_free(tmp);
 683                         return NULL;
 684                 } else {
 685                         flags = fcntl(tmp->alertpipe[0], F_GETFL);
 686                         fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK);
 687                         flags = fcntl(tmp->alertpipe[1], F_GETFL);
 688                         fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK);
 689                 }
 690         } else  /* Make sure we've got it done right if they don't */
 691                 tmp->alertpipe[0] = tmp->alertpipe[1] = -1;
 692
 693         /* Always watch the alertpipe */
 694         ast_channel_set_fd(tmp, AST_ALERT_FD, tmp->alertpipe[0]);
 695         /* And timing pipe */
 696         ast_channel_set_fd(tmp, AST_TIMING_FD, tmp->timingfd);
 697         ast_string_field_set(tmp, name, "**Unknown**");
 698
 699         /* Initial state */
 700         tmp->_state = state;
 701
 702         tmp->streamid = -1;
 703
 704         tmp->fin = global_fin;
 705         tmp->fout = global_fout;
 706
 707         if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
 708                 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL),
 709                                        ast_atomic_fetchadd_int(&uniqueint, 1));
 710         } else {
 711                 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME,
 712                                        (long) time(NULL), ast_atomic_fetchadd_int(&uniqueint, 1));
 713         }
 714
 715         tmp->cid.cid_name = ast_strdup(cid_name);
 716         tmp->cid.cid_num = ast_strdup(cid_num);
 717
 718         if (!ast_strlen_zero(name_fmt)) {
 719                 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
 720                  * And they all use slightly different formats for their name string.
 721                  * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
 722                  * This means, that the stringfields must have a routine that takes the va_lists directly, and
 723                  * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
 724                  * This new function was written so this can be accomplished.
 725                  */
 726                 va_start(ap1, name_fmt);
 727                 va_start(ap2, name_fmt);
 728                 ast_string_field_build_va(tmp, name, name_fmt, ap1, ap2);
 729                 va_end(ap1);
 730                 va_end(ap2);
 731
 732                 /* and now, since the channel structure is built, and has its name, let's call the
 733                  * manager event generator with this Newchannel event. This is the proper and correct
 734                  * place to make this call, but you sure do have to pass a lot of data into this func
 735                  * to do it here!
 736                  */
 737                 manager_event(EVENT_FLAG_CALL, "Newchannel",
 738                               "Channel: %s\r\n"
 739                               "State: %s\r\n"
 740                               "CallerIDNum: %s\r\n"
 741                               "CallerIDName: %s\r\n"
 742                               "Uniqueid: %s\r\n",
 743                               tmp->name, ast_state2str(state),
 744                               S_OR(cid_num, "<unknown>"),
 745                               S_OR(cid_name, "<unknown>"),
 746                               tmp->uniqueid);
 747         }
 748
 749         /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */
 750
 751         /* These 4 variables need to be set up for the cdr_init() to work right */
 752         if (amaflag)
 753                 tmp->amaflags = amaflag;
 754         else
 755                 tmp->amaflags = ast_default_amaflags;
 756
 757         if (!ast_strlen_zero(acctcode))
 758                 ast_string_field_set(tmp, accountcode, acctcode);
 759         else
 760                 ast_string_field_set(tmp, accountcode, ast_default_accountcode);
 761
 762         if (!ast_strlen_zero(context))
 763                 ast_copy_string(tmp->context, context, sizeof(tmp->context));
 764         else
 765                 strcpy(tmp->context, "default");
 766
 767         if (!ast_strlen_zero(exten))
 768                 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten));
 769         else
 770                 strcpy(tmp->exten, "s");
 771
 772         tmp->priority = 1;
 773
 774         tmp->cdr = ast_cdr_alloc();
 775         ast_cdr_init(tmp->cdr, tmp);
 776         ast_cdr_start(tmp->cdr);
 777
 778         headp = &tmp->varshead;
 779         AST_LIST_HEAD_INIT_NOLOCK(headp);
 780
 781         ast_mutex_init(&tmp->lock);
 782
 783         AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores);
 784
 785         ast_string_field_set(tmp, language, defaultlanguage);
 786
 787         tmp->tech = &null_tech;
 788
 789         AST_RWLIST_WRLOCK(&channels);
 790         AST_RWLIST_INSERT_HEAD(&channels, tmp, chan_list);
 791         AST_RWLIST_UNLOCK(&channels);
 792
 793         return tmp;
 794 }
 795
 796 /*! \brief Queue an outgoing media frame */
 797 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
 798 {
 799         struct ast_frame *f;
 800         struct ast_frame *cur;
 801         int blah = 1;
 802         int qlen = 0;
 803
 804         /* Build us a copy and free the original one */
 805         if (!(f = ast_frdup(fin))) {
 806                 ast_log(LOG_WARNING, "Unable to duplicate frame\n");
 807                 return -1;
 808         }
 809         ast_channel_lock(chan);
 810
 811         /* See if the last frame on the queue is a hangup, if so don't queue anything */
 812         if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
 813                 ast_frfree(f);
 814                 ast_channel_unlock(chan);
 815                 return 0;
 816         }
 817
 818         /* Count how many frames exist on the queue */
 819         AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
 820                 qlen++;
 821         }
 822
 823         /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
 824         if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen  > 128)) {
 825                 if (fin->frametype != AST_FRAME_VOICE) {
 826                         ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name);
 827                         CRASH;
 828                 } else {
 829                         ast_debug(1, "Dropping voice to exceptionally long queue on %s\n", chan->name);
 830                         ast_frfree(f);
 831                         ast_channel_unlock(chan);
 832                         return 0;
 833                 }
 834         }
 835         AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
 836         if (chan->alertpipe[1] > -1) {
 837                 if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
 838                         ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
 839                                 chan->name, f->frametype, f->subclass, qlen, strerror(errno));
 840 #ifdef HAVE_ZAPTEL
 841         } else if (chan->timingfd > -1) {
 842                 ioctl(chan->timingfd, ZT_TIMERPING, &blah);
 843 #endif
 844         } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
 845                 pthread_kill(chan->blocker, SIGURG);
 846         }
 847         ast_channel_unlock(chan);
 848         return 0;
 849 }
 850
 851 /*! \brief Queue a hangup frame for channel */
 852 int ast_queue_hangup(struct ast_channel *chan)
 853 {
 854         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
 855         /* Yeah, let's not change a lock-critical value without locking */
 856         if (!ast_channel_trylock(chan)) {
 857                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
 858                 ast_channel_unlock(chan);
 859         }
 860         return ast_queue_frame(chan, &f);
 861 }
 862
 863 /*! \brief Queue a control frame */
 864 int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
 865 {
 866         struct ast_frame f = { AST_FRAME_CONTROL, };
 867
 868         f.subclass = control;
 869
 870         return ast_queue_frame(chan, &f);
 871 }
 872
 873 /*! \brief Queue a control frame with payload */
 874 int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control,
 875                            const void *data, size_t datalen)
 876 {
 877         struct ast_frame f = { AST_FRAME_CONTROL, };
 878
 879         f.subclass = control;
 880         f.data = (void *) data;
 881         f.datalen = datalen;
 882
 883         return ast_queue_frame(chan, &f);
 884 }
 885
 886 /*! \brief Set defer DTMF flag on channel */
 887 int ast_channel_defer_dtmf(struct ast_channel *chan)
 888 {
 889         int pre = 0;
 890
 891         if (chan) {
 892                 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
 893                 ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
 894         }
 895         return pre;
 896 }
 897
 898 /*! \brief Unset defer DTMF flag on channel */
 899 void ast_channel_undefer_dtmf(struct ast_channel *chan)
 900 {
 901         if (chan)
 902                 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
 903 }
 904
 905 /*!
 906  * \brief Helper function to find channels.
 907  *
 908  * It supports these modes:
 909  *
 910  * prev != NULL : get channel next in list after prev
 911  * name != NULL : get channel with matching name
 912  * name != NULL && namelen != 0 : get channel whose name starts with prefix
 913  * exten != NULL : get channel whose exten or macroexten matches
 914  * context != NULL && exten != NULL : get channel whose context or macrocontext
 915  *
 916  * It returns with the channel's lock held. If getting the individual lock fails,
 917  * unlock and retry quickly up to 10 times, then give up.
 918  *
 919  * \note XXX Note that this code has cost O(N) because of the need to verify
 920  * that the object is still on the global list.
 921  *
 922  * \note XXX also note that accessing fields (e.g. c->name in ast_log())
 923  * can only be done with the lock held or someone could delete the
 924  * object while we work on it. This causes some ugliness in the code.
 925  * Note that removing the first ast_log() may be harmful, as it would
 926  * shorten the retry period and possibly cause failures.
 927  * We should definitely go for a better scheme that is deadlock-free.
 928  */
 929 static struct ast_channel *channel_find_locked(const struct ast_channel *prev,
 930                                                const char *name, const int namelen,
 931                                                const char *context, const char *exten)
 932 {
 933         const char *msg = prev ? "deadlock" : "initial deadlock";
 934         int retries;
 935         struct ast_channel *c;
 936         const struct ast_channel *_prev = prev;
 937
 938         for (retries = 0; retries < 10; retries++) {
 939                 int done;
 940                 AST_RWLIST_RDLOCK(&channels);
 941                 AST_RWLIST_TRAVERSE(&channels, c, chan_list) {
 942                         prev = _prev;
 943                         if (prev) {     /* look for next item */
 944                                 if (c != prev)  /* not this one */
 945                                         continue;
 946                                 /* found, prepare to return c->next */
 947                                 if ((c = AST_RWLIST_NEXT(c, chan_list)) == NULL) break;
 948                                 /* If prev was the last item on the channel list, then we just
 949                                  * want to return NULL, instead of trying to deref NULL in the
 950                                  * next section.
 951                                  */
 952                                 prev = NULL;
 953                                 /* We want prev to be NULL in case we end up doing more searching through
 954                                  * the channel list to find the channel (ie: name searching). If we didn't
 955                                  * set this to NULL the logic would just blow up
 956                                  * XXX Need a better explanation for this ...
 957                                  */
 958                         }
 959                         if (name) { /* want match by name */
 960                                 if ((!namelen && strcasecmp(c->name, name)) ||
 961                                     (namelen && strncasecmp(c->name, name, namelen)))
 962                                         continue;       /* name match failed */
 963                         } else if (exten) {
 964                                 if (context && strcasecmp(c->context, context) &&
 965                                     strcasecmp(c->macrocontext, context))
 966                                         continue;       /* context match failed */
 967                                 if (strcasecmp(c->exten, exten) &&
 968                                     strcasecmp(c->macroexten, exten))
 969                                         continue;       /* exten match failed */
 970                         }
 971                         /* if we get here, c points to the desired record */
 972                         break;
 973                 }
 974                 /* exit if chan not found or mutex acquired successfully */
 975                 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
 976                 done = c == NULL || ast_channel_trylock(c) == 0;
 977                 if (!done) {
 978                         ast_debug(1, "Avoiding %s for channel '%p'\n", msg, c);
 979                         if (retries == 9) {
 980                                 /* We are about to fail due to a deadlock, so report this
 981                                  * while we still have the list lock.
 982                                  */
 983                                 ast_debug(1, "Failure, could not lock '%p' after %d retries!\n", c, retries);
 984                                 /* As we have deadlocked, we will skip this channel and
 985                                  * see if there is another match.
 986                                  * NOTE: No point doing this for a full-name match,
 987                                  * as there can be no more matches.
 988                                  */
 989                                 if (!(name && !namelen)) {
 990                                         prev = c;
 991                                         retries = -1;
 992                                 }
 993                         }
 994                 }
 995                 AST_RWLIST_UNLOCK(&channels);
 996                 if (done)
 997                         return c;
 998                 /* If we reach this point we basically tried to lock a channel and failed. Instead of
 999                  * starting from the beginning of the list we can restore our saved pointer to the previous
1000                  * channel and start from there.
1001                  */
1002                 prev = _prev;
1003                 usleep(1);      /* give other threads a chance before retrying */
1004         }
1005
1006         return NULL;
1007 }
1008
1009 /*! \brief Browse channels in use */
1010 struct ast_channel *ast_channel_walk_locked(const struct ast_channel *prev)
1011 {
1012         return channel_find_locked(prev, NULL, 0, NULL, NULL);
1013 }
1014
1015 /*! \brief Get channel by name and lock it */
1016 struct ast_channel *ast_get_channel_by_name_locked(const char *name)
1017 {
1018         return channel_find_locked(NULL, name, 0, NULL, NULL);
1019 }
1020
1021 /*! \brief Get channel by name prefix and lock it */
1022 struct ast_channel *ast_get_channel_by_name_prefix_locked(const char *name, const int namelen)
1023 {
1024         return channel_find_locked(NULL, name, namelen, NULL, NULL);
1025 }
1026
1027 /*! \brief Get next channel by name prefix and lock it */
1028 struct ast_channel *ast_walk_channel_by_name_prefix_locked(const struct ast_channel *chan, const char *name,
1029                                                            const int namelen)
1030 {
1031         return channel_find_locked(chan, name, namelen, NULL, NULL);
1032 }
1033
1034 /*! \brief Get channel by exten (and optionally context) and lock it */
1035 struct ast_channel *ast_get_channel_by_exten_locked(const char *exten, const char *context)
1036 {
1037         return channel_find_locked(NULL, NULL, 0, context, exten);
1038 }
1039
1040 /*! \brief Get next channel by exten (and optionally context) and lock it */
1041 struct ast_channel *ast_walk_channel_by_exten_locked(const struct ast_channel *chan, const char *exten,
1042                                                      const char *context)
1043 {
1044         return channel_find_locked(chan, NULL, 0, context, exten);
1045 }
1046
1047 /*! \brief Wait, look for hangups and condition arg */
1048 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data)
1049 {
1050         struct ast_frame *f;
1051
1052         while (ms > 0) {
1053                 if (cond && ((*cond)(data) == 0))
1054                         return 0;
1055                 ms = ast_waitfor(chan, ms);
1056                 if (ms < 0)
1057                         return -1;
1058                 if (ms > 0) {
1059                         f = ast_read(chan);
1060                         if (!f)
1061                                 return -1;
1062                         ast_frfree(f);
1063                 }
1064         }
1065         return 0;
1066 }
1067
1068 /*! \brief Wait, look for hangups */
1069 int ast_safe_sleep(struct ast_channel *chan, int ms)
1070 {
1071         return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
1072 }
1073
1074 static void free_cid(struct ast_callerid *cid)
1075 {
1076         if (cid->cid_dnid)
1077                 ast_free(cid->cid_dnid);
1078         if (cid->cid_num)
1079                 ast_free(cid->cid_num);
1080         if (cid->cid_name)
1081                 ast_free(cid->cid_name);
1082         if (cid->cid_ani)
1083                 ast_free(cid->cid_ani);
1084         if (cid->cid_rdnis)
1085                 ast_free(cid->cid_rdnis);
1086         cid->cid_dnid = cid->cid_num = cid->cid_name = cid->cid_ani = cid->cid_rdnis = NULL;
1087 }
1088
1089 /*! \brief Free a channel structure */
1090 void ast_channel_free(struct ast_channel *chan)
1091 {
1092         int fd;
1093 #ifdef HAVE_EPOLL
1094         int i;
1095 #endif
1096         struct ast_var_t *vardata;
1097         struct ast_frame *f;
1098         struct varshead *headp;
1099         struct ast_datastore *datastore = NULL;
1100         char name[AST_CHANNEL_NAME];
1101
1102         headp=&chan->varshead;
1103
1104         AST_RWLIST_WRLOCK(&channels);
1105         if (!AST_RWLIST_REMOVE(&channels, chan, chan_list)) {
1106                 AST_RWLIST_UNLOCK(&channels);
1107                 ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
1108         }
1109         /* Lock and unlock the channel just to be sure nobody
1110            has it locked still */
1111         ast_channel_lock(chan);
1112         ast_channel_unlock(chan);
1113         if (chan->tech_pvt) {
1114                 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
1115                 ast_free(chan->tech_pvt);
1116         }
1117
1118         if (chan->sched)
1119                 sched_context_destroy(chan->sched);
1120
1121         ast_copy_string(name, chan->name, sizeof(name));
1122
1123         /* Stop monitoring */
1124         if (chan->monitor)
1125                 chan->monitor->stop( chan, 0 );
1126
1127         /* If there is native format music-on-hold state, free it */
1128         if (chan->music_state)
1129                 ast_moh_cleanup(chan);
1130
1131         /* Free translators */
1132         if (chan->readtrans)
1133                 ast_translator_free_path(chan->readtrans);
1134         if (chan->writetrans)
1135                 ast_translator_free_path(chan->writetrans);
1136         if (chan->pbx)
1137                 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
1138         free_cid(&chan->cid);
1139         ast_mutex_destroy(&chan->lock);
1140         /* Close pipes if appropriate */
1141         if ((fd = chan->alertpipe[0]) > -1)
1142                 close(fd);
1143         if ((fd = chan->alertpipe[1]) > -1)
1144                 close(fd);
1145         if ((fd = chan->timingfd) > -1)
1146                 close(fd);
1147 #ifdef HAVE_EPOLL
1148         for (i = 0; i < AST_MAX_FDS; i++) {
1149                 if (chan->epfd_data[i])
1150                         free(chan->epfd_data[i]);
1151         }
1152         close(chan->epfd);
1153 #endif
1154         while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
1155                 ast_frfree(f);
1156
1157         /* Get rid of each of the data stores on the channel */
1158         while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
1159                 /* Free the data store */
1160                 ast_channel_datastore_free(datastore);
1161         AST_LIST_HEAD_INIT_NOLOCK(&chan->datastores);
1162
1163         /* loop over the variables list, freeing all data and deleting list items */
1164         /* no need to lock the list, as the channel is already locked */
1165
1166         while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
1167                 ast_var_delete(vardata);
1168
1169         ast_app_group_discard(chan);
1170
1171         /* Destroy the jitterbuffer */
1172         ast_jb_destroy(chan);
1173
1174         ast_string_field_free_memory(chan);
1175         ast_free(chan);
1176         AST_RWLIST_UNLOCK(&channels);
1177
1178         ast_device_state_changed_literal(name);
1179 }
1180
1181 struct ast_datastore *ast_channel_datastore_alloc(const struct ast_datastore_info *info, const char *uid)
1182 {
1183         struct ast_datastore *datastore = NULL;
1184
1185         /* Make sure we at least have type so we can identify this */
1186         if (!info) {
1187                 return NULL;
1188         }
1189
1190         /* Allocate memory for datastore and clear it */
1191         datastore = ast_calloc(1, sizeof(*datastore));
1192         if (!datastore) {
1193                 return NULL;
1194         }
1195
1196         datastore->info = info;
1197
1198         datastore->uid = ast_strdup(uid);
1199
1200         return datastore;
1201 }
1202
1203 int ast_channel_datastore_free(struct ast_datastore *datastore)
1204 {
1205         int res = 0;
1206
1207         /* Using the destroy function (if present) destroy the data */
1208         if (datastore->info->destroy != NULL && datastore->data != NULL) {
1209                 datastore->info->destroy(datastore->data);
1210                 datastore->data = NULL;
1211         }
1212
1213         /* Free allocated UID memory */
1214         if (datastore->uid != NULL) {
1215                 ast_free((void *) datastore->uid);
1216                 datastore->uid = NULL;
1217         }
1218
1219         /* Finally free memory used by ourselves */
1220         ast_free(datastore);
1221
1222         return res;
1223 }
1224
1225 int ast_channel_datastore_inherit(struct ast_channel *from, struct ast_channel *to)
1226 {
1227         struct ast_datastore *datastore = NULL, *datastore2;
1228
1229         AST_LIST_TRAVERSE(&from->datastores, datastore, entry) {
1230                 if (datastore->inheritance > 0) {
1231                         datastore2 = ast_channel_datastore_alloc(datastore->info, datastore->uid);
1232                         if (datastore2) {
1233                                 datastore2->data = datastore->info->duplicate(datastore->data);
1234                                 datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
1235                                 AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry);
1236                         }
1237                 }
1238         }
1239         return 0;
1240 }
1241
1242 int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
1243 {
1244         int res = 0;
1245
1246         AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
1247
1248         return res;
1249 }
1250
1251 int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
1252 {
1253         return AST_LIST_REMOVE(&chan->datastores, datastore, entry) ? 0 : -1;
1254 }
1255
1256 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
1257 {
1258         struct ast_datastore *datastore = NULL;
1259
1260         if (info == NULL)
1261                 return NULL;
1262
1263         AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
1264                 if (datastore->info == info) {
1265                         if (uid != NULL && datastore->uid != NULL) {
1266                                 if (!strcasecmp(uid, datastore->uid)) {
1267                                         /* Matched by type AND uid */
1268                                         break;
1269                                 }
1270                         } else {
1271                                 /* Matched by type at least */
1272                                 break;
1273                         }
1274                 }
1275         }
1276         AST_LIST_TRAVERSE_SAFE_END
1277
1278         return datastore;
1279 }
1280
1281 /*! Set the file descriptor on the channel */
1282 void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
1283 {
1284 #ifdef HAVE_EPOLL
1285         struct epoll_event ev;
1286         struct ast_epoll_data *aed = NULL;
1287
1288         if (chan->fds[which] > -1) {
1289                 epoll_ctl(chan->epfd, EPOLL_CTL_DEL, chan->fds[which], &ev);
1290                 aed = chan->epfd_data[which];
1291         }
1292
1293         /* If this new fd is valid, add it to the epoll */
1294         if (fd > -1) {
1295                 if (!aed && (!(aed = ast_calloc(1, sizeof(*aed)))))
1296                         return;
1297
1298                 chan->epfd_data[which] = aed;
1299                 aed->chan = chan;
1300                 aed->which = which;
1301
1302                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1303                 ev.data.ptr = aed;
1304                 epoll_ctl(chan->epfd, EPOLL_CTL_ADD, fd, &ev);
1305         } else if (aed) {
1306                 /* We don't have to keep around this epoll data structure now */
1307                 free(aed);
1308                 chan->epfd_data[which] = NULL;
1309         }
1310 #endif
1311         chan->fds[which] = fd;
1312         return;
1313 }
1314
1315 /*! Add a channel to an optimized waitfor */
1316 void ast_poll_channel_add(struct ast_channel *chan0, struct ast_channel *chan1)
1317 {
1318 #ifdef HAVE_EPOLL
1319         struct epoll_event ev;
1320         int i = 0;
1321
1322         if (chan0->epfd == -1)
1323                 return;
1324
1325         /* Iterate through the file descriptors on chan1, adding them to chan0 */
1326         for (i = 0; i < AST_MAX_FDS; i++) {
1327                 if (chan1->fds[i] == -1)
1328                         continue;
1329                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1330                 ev.data.ptr = chan1->epfd_data[i];
1331                 epoll_ctl(chan0->epfd, EPOLL_CTL_ADD, chan1->fds[i], &ev);
1332         }
1333
1334 #endif
1335         return;
1336 }
1337
1338 /*! Delete a channel from an optimized waitfor */
1339 void ast_poll_channel_del(struct ast_channel *chan0, struct ast_channel *chan1)
1340 {
1341 #ifdef HAVE_EPOLL
1342         struct epoll_event ev;
1343         int i = 0;
1344
1345         if (chan0->epfd == -1)
1346                 return;
1347
1348         for (i = 0; i < AST_MAX_FDS; i++) {
1349                 if (chan1->fds[i] == -1)
1350                         continue;
1351                 epoll_ctl(chan0->epfd, EPOLL_CTL_DEL, chan1->fds[i], &ev);
1352         }
1353
1354 #endif
1355         return;
1356 }
1357
1358 /*! \brief Softly hangup a channel, don't lock */
1359 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
1360 {
1361         ast_debug(1, "Soft-Hanging up channel '%s'\n", chan->name);
1362         /* Inform channel driver that we need to be hung up, if it cares */
1363         chan->_softhangup |= cause;
1364         ast_queue_frame(chan, &ast_null_frame);
1365         /* Interrupt any poll call or such */
1366         if (ast_test_flag(chan, AST_FLAG_BLOCKING))
1367                 pthread_kill(chan->blocker, SIGURG);
1368         return 0;
1369 }
1370
1371 /*! \brief Softly hangup a channel, lock */
1372 int ast_softhangup(struct ast_channel *chan, int cause)
1373 {
1374         int res;
1375         ast_channel_lock(chan);
1376         res = ast_softhangup_nolock(chan, cause);
1377         ast_channel_unlock(chan);
1378         return res;
1379 }
1380
1381 static void free_translation(struct ast_channel *clone)
1382 {
1383         if (clone->writetrans)
1384                 ast_translator_free_path(clone->writetrans);
1385         if (clone->readtrans)
1386                 ast_translator_free_path(clone->readtrans);
1387         clone->writetrans = NULL;
1388         clone->readtrans = NULL;
1389         clone->rawwriteformat = clone->nativeformats;
1390         clone->rawreadformat = clone->nativeformats;
1391 }
1392
1393 /*! \brief Hangup a channel */
1394 int ast_hangup(struct ast_channel *chan)
1395 {
1396         int res = 0;
1397         struct ast_cdr *cdr = NULL;
1398
1399         /* Don't actually hang up a channel that will masquerade as someone else, or
1400            if someone is going to masquerade as us */
1401         ast_channel_lock(chan);
1402
1403         if (chan->audiohooks) {
1404                 ast_audiohook_detach_list(chan->audiohooks);
1405                 chan->audiohooks = NULL;
1406         }
1407
1408         ast_autoservice_stop(chan);
1409
1410         if (chan->masq) {
1411                 if (ast_do_masquerade(chan))
1412                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1413         }
1414
1415         if (chan->masq) {
1416                 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
1417                 ast_channel_unlock(chan);
1418                 return 0;
1419         }
1420         /* If this channel is one which will be masqueraded into something,
1421            mark it as a zombie already, so we know to free it later */
1422         if (chan->masqr) {
1423                 ast_set_flag(chan, AST_FLAG_ZOMBIE);
1424                 ast_channel_unlock(chan);
1425                 return 0;
1426         }
1427         free_translation(chan);
1428         /* Close audio stream */
1429         if (chan->stream) {
1430                 ast_closestream(chan->stream);
1431                 chan->stream = NULL;
1432         }
1433         /* Close video stream */
1434         if (chan->vstream) {
1435                 ast_closestream(chan->vstream);
1436                 chan->vstream = NULL;
1437         }
1438         if (chan->sched) {
1439                 sched_context_destroy(chan->sched);
1440                 chan->sched = NULL;
1441         }
1442
1443         if (chan->generatordata)        /* Clear any tone stuff remaining */
1444                 if (chan->generator && chan->generator->release)
1445                         chan->generator->release(chan, chan->generatordata);
1446         chan->generatordata = NULL;
1447         chan->generator = NULL;
1448         if (chan->cdr) {                /* End the CDR if it hasn't already */
1449                 ast_cdr_end(chan->cdr);
1450                 cdr = chan->cdr;
1451                 chan->cdr = NULL;
1452         }
1453         if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1454                 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
1455                                         "is blocked by thread %ld in procedure %s!  Expect a failure\n",
1456                                         (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
1457                 CRASH;
1458         }
1459         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
1460                 ast_debug(1, "Hanging up channel '%s'\n", chan->name);
1461                 if (chan->tech->hangup)
1462                         res = chan->tech->hangup(chan);
1463         } else {
1464                 ast_debug(1, "Hanging up zombie '%s'\n", chan->name);
1465         }
1466
1467         ast_channel_unlock(chan);
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
1480         if (cdr)
1481                 ast_cdr_detach(cdr);
1482
1483         return res;
1484 }
1485
1486 int __ast_answer(struct ast_channel *chan, unsigned int delay)
1487 {
1488         int res = 0;
1489
1490         ast_channel_lock(chan);
1491
1492         /* You can't answer an outbound call */
1493         if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
1494                 ast_channel_unlock(chan);
1495                 return 0;
1496         }
1497
1498         /* Stop if we're a zombie or need a soft hangup */
1499         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1500                 ast_channel_unlock(chan);
1501                 return -1;
1502         }
1503
1504         switch (chan->_state) {
1505         case AST_STATE_RINGING:
1506         case AST_STATE_RING:
1507                 if (chan->tech->answer)
1508                         res = chan->tech->answer(chan);
1509                 ast_setstate(chan, AST_STATE_UP);
1510                 ast_cdr_answer(chan->cdr);
1511                 ast_channel_unlock(chan);
1512                 if (delay)
1513                         ast_safe_sleep(chan, delay);
1514                 return res;
1515                 break;
1516         case AST_STATE_UP:
1517                 ast_cdr_answer(chan->cdr);
1518                 break;
1519         default:
1520                 break;
1521         }
1522
1523         ast_channel_unlock(chan);
1524
1525         return res;
1526 }
1527
1528 int ast_answer(struct ast_channel *chan)
1529 {
1530         return __ast_answer(chan, 500);
1531 }
1532
1533 void ast_deactivate_generator(struct ast_channel *chan)
1534 {
1535         ast_channel_lock(chan);
1536         if (chan->generatordata) {
1537                 if (chan->generator && chan->generator->release)
1538                         chan->generator->release(chan, chan->generatordata);
1539                 chan->generatordata = NULL;
1540                 chan->generator = NULL;
1541                 ast_channel_set_fd(chan, AST_GENERATOR_FD, -1);
1542                 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1543                 ast_settimeout(chan, 0, NULL, NULL);
1544         }
1545         ast_channel_unlock(chan);
1546 }
1547
1548 static int generator_force(const void *data)
1549 {
1550         /* Called if generator doesn't have data */
1551         void *tmp;
1552         int res;
1553         int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
1554         struct ast_channel *chan = (struct ast_channel *)data;
1555         tmp = chan->generatordata;
1556         chan->generatordata = NULL;
1557         generate = chan->generator->generate;
1558         res = generate(chan, tmp, 0, 160);
1559         chan->generatordata = tmp;
1560         if (res) {
1561                 ast_debug(1, "Auto-deactivating generator\n");
1562                 ast_deactivate_generator(chan);
1563         }
1564         return 0;
1565 }
1566
1567 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1568 {
1569         int res = 0;
1570
1571         ast_channel_lock(chan);
1572
1573         if (chan->generatordata) {
1574                 if (chan->generator && chan->generator->release)
1575                         chan->generator->release(chan, chan->generatordata);
1576                 chan->generatordata = NULL;
1577         }
1578
1579         ast_prod(chan);
1580         if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1581                 res = -1;
1582         }
1583
1584         if (!res) {
1585                 ast_settimeout(chan, 160, generator_force, chan);
1586                 chan->generator = gen;
1587         }
1588
1589         ast_channel_unlock(chan);
1590
1591         return res;
1592 }
1593
1594 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1595 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1596 {
1597         int winner = -1;
1598         ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1599         return winner;
1600 }
1601
1602 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1603 #ifdef HAVE_EPOLL
1604 static struct ast_channel *ast_waitfor_nandfds_classic(struct ast_channel **c, int n, int *fds, int nfds,
1605                                         int *exception, int *outfd, int *ms)
1606 #else
1607 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1608                                         int *exception, int *outfd, int *ms)
1609 #endif
1610 {
1611         struct timeval start = { 0 , 0 };
1612         struct pollfd *pfds;
1613         int res;
1614         long rms;
1615         int x, y, max;
1616         int sz;
1617         time_t now = 0;
1618         long whentohangup = 0, diff;
1619         struct ast_channel *winner = NULL;
1620         struct fdmap {
1621                 int chan;
1622                 int fdno;
1623         } *fdmap;
1624
1625         sz = n * AST_MAX_FDS + nfds;
1626         pfds = alloca(sizeof(*pfds) * sz);
1627         fdmap = alloca(sizeof(*fdmap) * sz);
1628
1629         if (outfd)
1630                 *outfd = -99999;
1631         if (exception)
1632                 *exception = 0;
1633
1634         /* Perform any pending masquerades */
1635         for (x = 0; x < n; x++) {
1636                 ast_channel_lock(c[x]);
1637                 if (c[x]->masq && ast_do_masquerade(c[x])) {
1638                         ast_log(LOG_WARNING, "Masquerade failed\n");
1639                         *ms = -1;
1640                         ast_channel_unlock(c[x]);
1641                         return NULL;
1642                 }
1643                 if (c[x]->whentohangup) {
1644                         if (!whentohangup)
1645                                 time(&now);
1646                         diff = c[x]->whentohangup - now;
1647                         if (diff < 1) {
1648                                 /* Should already be hungup */
1649                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1650                                 ast_channel_unlock(c[x]);
1651                                 return c[x];
1652                         }
1653                         if (!whentohangup || (diff < whentohangup))
1654                                 whentohangup = diff;
1655                 }
1656                 ast_channel_unlock(c[x]);
1657         }
1658         /* Wait full interval */
1659         rms = *ms;
1660         if (whentohangup) {
1661                 rms = whentohangup * 1000;              /* timeout in milliseconds */
1662                 if (*ms >= 0 && *ms < rms)              /* original *ms still smaller */
1663                         rms =  *ms;
1664         }
1665         /*
1666          * Build the pollfd array, putting the channels' fds first,
1667          * followed by individual fds. Order is important because
1668          * individual fd's must have priority over channel fds.
1669          */
1670         max = 0;
1671         for (x = 0; x < n; x++) {
1672                 for (y = 0; y < AST_MAX_FDS; y++) {
1673                         fdmap[max].fdno = y;  /* fd y is linked to this pfds */
1674                         fdmap[max].chan = x;  /* channel x is linked to this pfds */
1675                         max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1676                 }
1677                 CHECK_BLOCKING(c[x]);
1678         }
1679         /* Add the individual fds */
1680         for (x = 0; x < nfds; x++) {
1681                 fdmap[max].chan = -1;
1682                 max += ast_add_fd(&pfds[max], fds[x]);
1683         }
1684
1685         if (*ms > 0)
1686                 start = ast_tvnow();
1687
1688         if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1689                 do {
1690                         int kbrms = rms;
1691                         if (kbrms > 600000)
1692                                 kbrms = 600000;
1693                         res = poll(pfds, max, kbrms);
1694                         if (!res)
1695                                 rms -= kbrms;
1696                 } while (!res && (rms > 0));
1697         } else {
1698                 res = poll(pfds, max, rms);
1699         }
1700         for (x = 0; x < n; x++)
1701                 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1702         if (res < 0) { /* Simulate a timeout if we were interrupted */
1703                 if (errno != EINTR)
1704                         *ms = -1;
1705                 return NULL;
1706         }
1707         if (whentohangup) {   /* if we have a timeout, check who expired */
1708                 time(&now);
1709                 for (x = 0; x < n; x++) {
1710                         if (c[x]->whentohangup && now >= c[x]->whentohangup) {
1711                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1712                                 if (winner == NULL)
1713                                         winner = c[x];
1714                         }
1715                 }
1716         }
1717         if (res == 0) { /* no fd ready, reset timeout and done */
1718                 *ms = 0;        /* XXX use 0 since we may not have an exact timeout. */
1719                 return winner;
1720         }
1721         /*
1722          * Then check if any channel or fd has a pending event.
1723          * Remember to check channels first and fds last, as they
1724          * must have priority on setting 'winner'
1725          */
1726         for (x = 0; x < max; x++) {
1727                 res = pfds[x].revents;
1728                 if (res == 0)
1729                         continue;
1730                 if (fdmap[x].chan >= 0) {       /* this is a channel */
1731                         winner = c[fdmap[x].chan];      /* override previous winners */
1732                         if (res & POLLPRI)
1733                                 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1734                         else
1735                                 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1736                         winner->fdno = fdmap[x].fdno;
1737                 } else {                        /* this is an fd */
1738                         if (outfd)
1739                                 *outfd = pfds[x].fd;
1740                         if (exception)
1741                                 *exception = (res & POLLPRI) ? -1 : 0;
1742                         winner = NULL;
1743                 }
1744         }
1745         if (*ms > 0) {
1746                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1747                 if (*ms < 0)
1748                         *ms = 0;
1749         }
1750         return winner;
1751 }
1752
1753 #ifdef HAVE_EPOLL
1754 static struct ast_channel *ast_waitfor_nandfds_simple(struct ast_channel *chan, int *ms)
1755 {
1756         struct timeval start = { 0 , 0 };
1757         int res = 0;
1758         struct epoll_event ev[1];
1759         long whentohangup = 0, rms = *ms;
1760         time_t now;
1761         struct ast_channel *winner = NULL;
1762         struct ast_epoll_data *aed = NULL;
1763
1764         ast_channel_lock(chan);
1765
1766         /* See if this channel needs to be masqueraded */
1767         if (chan->masq && ast_do_masquerade(chan)) {
1768                 ast_log(LOG_WARNING, "Failed to perform masquerade on %s\n", chan->name);
1769                 *ms = -1;
1770                 ast_channel_unlock(chan);
1771                 return NULL;
1772         }
1773
1774         /* Figure out their timeout */
1775         if (chan->whentohangup) {
1776                 time(&now);
1777                 if ((whentohangup = chan->whentohangup - now) < 1) {
1778                         /* They should already be hungup! */
1779                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1780                         ast_channel_unlock(chan);
1781                         return NULL;
1782                 }
1783                 /* If this value is smaller then the current one... make it priority */
1784                 whentohangup *= 1000;
1785                 if (rms > whentohangup)
1786                         rms = whentohangup;
1787         }
1788
1789         ast_channel_unlock(chan);
1790
1791         /* Time to make this channel block... */
1792         CHECK_BLOCKING(chan);
1793
1794         if (*ms > 0)
1795                 start = ast_tvnow();
1796
1797         /* We don't have to add any file descriptors... they are already added, we just have to wait! */
1798         res = epoll_wait(chan->epfd, ev, 1, rms);
1799
1800         /* Stop blocking */
1801         ast_clear_flag(chan, AST_FLAG_BLOCKING);
1802
1803         /* Simulate a timeout if we were interrupted */
1804         if (res < 0) {
1805                 if (errno != EINTR)
1806                         *ms = -1;
1807                 return NULL;
1808         }
1809
1810         /* If this channel has a timeout see if it expired */
1811         if (chan->whentohangup) {
1812                 time(&now);
1813                 if (now >= chan->whentohangup) {
1814                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1815                         winner = chan;
1816                 }
1817         }
1818
1819         /* No fd ready, reset timeout and be done for now */
1820         if (!res) {
1821                 *ms = 0;
1822                 return winner;
1823         }
1824
1825         /* See what events are pending */
1826         aed = ev[0].data.ptr;
1827         chan->fdno = aed->which;
1828         if (ev[0].events & EPOLLPRI)
1829                 ast_set_flag(chan, AST_FLAG_EXCEPTION);
1830         else
1831                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
1832
1833         if (*ms > 0) {
1834                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1835                 if (*ms < 0)
1836                         *ms = 0;
1837         }
1838
1839         return chan;
1840 }
1841
1842 static struct ast_channel *ast_waitfor_nandfds_complex(struct ast_channel **c, int n, int *ms)
1843 {
1844         struct timeval start = { 0 , 0 };
1845         int res = 0, i;
1846         struct epoll_event ev[25] = { { 0, } };
1847         long whentohangup = 0, diff, rms = *ms;
1848         time_t now;
1849         struct ast_channel *winner = NULL;
1850
1851         for (i = 0; i < n; i++) {
1852                 ast_channel_lock(c[i]);
1853                 if (c[i]->masq && ast_do_masquerade(c[i])) {
1854                         ast_log(LOG_WARNING, "Masquerade failed\n");
1855                         *ms = -1;
1856                         ast_channel_unlock(c[i]);
1857                         return NULL;
1858                 }
1859                 if (c[i]->whentohangup) {
1860                         if (!whentohangup)
1861                                 time(&now);
1862                         if ((diff = c[i]->whentohangup - now) < 1) {
1863                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1864                                 ast_channel_unlock(c[i]);
1865                                 return c[i];
1866                         }
1867                         if (!whentohangup || (diff < whentohangup))
1868                                 whentohangup = diff;
1869                 }
1870                 ast_channel_unlock(c[i]);
1871                 CHECK_BLOCKING(c[i]);
1872         }
1873
1874         rms = *ms;
1875         if (whentohangup) {
1876                 rms = whentohangup * 1000;
1877                 if (*ms >= 0 && *ms < rms)
1878                         rms = *ms;
1879         }
1880
1881         if (*ms > 0)
1882                 start = ast_tvnow();
1883
1884         res = epoll_wait(c[0]->epfd, ev, 25, rms);
1885
1886         for (i = 0; i < n; i++)
1887                 ast_clear_flag(c[i], AST_FLAG_BLOCKING);
1888
1889         if (res < 0) {
1890                 if (errno != EINTR)
1891                         *ms = -1;
1892                 return NULL;
1893         }
1894
1895         if (whentohangup) {
1896                 time(&now);
1897                 for (i = 0; i < n; i++) {
1898                         if (c[i]->whentohangup && now >= c[i]->whentohangup) {
1899                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1900                                 if (!winner)
1901                                         winner = c[i];
1902                         }
1903                 }
1904         }
1905
1906         if (!res) {
1907                 *ms = 0;
1908                 return winner;
1909         }
1910
1911         for (i = 0; i < 25; i++) {
1912                 struct ast_epoll_data *aed = ev[i].data.ptr;
1913
1914                 if (!ev[i].events || !aed)
1915                         continue;
1916
1917                 winner = aed->chan;
1918                 if (ev[i].events & EPOLLPRI)
1919                         ast_set_flag(winner, AST_FLAG_EXCEPTION);
1920                 else
1921                         ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1922                 winner->fdno = aed->which;
1923         }
1924
1925         if (*ms > 0) {
1926                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1927                 if (*ms < 0)
1928                         *ms = 0;
1929         }
1930
1931         return winner;
1932 }
1933
1934 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1935                                         int *exception, int *outfd, int *ms)
1936 {
1937         /* Clear all provided values in one place. */
1938         if (outfd)
1939                 *outfd = -99999;
1940         if (exception)
1941                 *exception = 0;
1942
1943         /* If no epoll file descriptor is available resort to classic nandfds */
1944         if (!n || nfds || c[0]->epfd == -1)
1945                 return ast_waitfor_nandfds_classic(c, n, fds, nfds, exception, outfd, ms);
1946         else if (!nfds && n == 1)
1947                 return ast_waitfor_nandfds_simple(c[0], ms);
1948         else
1949                 return ast_waitfor_nandfds_complex(c, n, ms);
1950 }
1951 #endif
1952
1953 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
1954 {
1955         return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
1956 }
1957
1958 int ast_waitfor(struct ast_channel *c, int ms)
1959 {
1960         int oldms = ms; /* -1 if no timeout */
1961
1962         ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
1963         if ((ms < 0) && (oldms < 0))
1964                 ms = 0;
1965         return ms;
1966 }
1967
1968 /* XXX never to be called with ms = -1 */
1969 int ast_waitfordigit(struct ast_channel *c, int ms)
1970 {
1971         return ast_waitfordigit_full(c, ms, -1, -1);
1972 }
1973
1974 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(const void *data), void *data)
1975 {
1976         int res = -1;
1977 #ifdef HAVE_ZAPTEL
1978         if (c->timingfd > -1) {
1979                 if (!func) {
1980                         samples = 0;
1981                         data = 0;
1982                 }
1983                 ast_debug(1, "Scheduling timer at %d sample intervals\n", samples);
1984                 res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
1985                 c->timingfunc = func;
1986                 c->timingdata = data;
1987         }
1988 #endif
1989         return res;
1990 }
1991
1992 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
1993 {
1994         /* Stop if we're a zombie or need a soft hangup */
1995         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
1996                 return -1;
1997
1998         /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
1999         ast_set_flag(c, AST_FLAG_END_DTMF_ONLY);
2000
2001         /* Wait for a digit, no more than ms milliseconds total. */
2002
2003         while (ms) {
2004                 struct ast_channel *rchan;
2005                 int outfd=-1;
2006
2007                 errno = 0;
2008                 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
2009
2010                 if (!rchan && outfd < 0 && ms) {
2011                         if (errno == 0 || errno == EINTR)
2012                                 continue;
2013                         ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
2014                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2015                         return -1;
2016                 } else if (outfd > -1) {
2017                         /* The FD we were watching has something waiting */
2018                         ast_log(LOG_WARNING, "The FD we were waiting for has something waiting. Waitfordigit returning numeric 1\n");
2019                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2020                         return 1;
2021                 } else if (rchan) {
2022                         int res;
2023                         struct ast_frame *f = ast_read(c);
2024                         if (!f)
2025                                 return -1;
2026
2027                         switch (f->frametype) {
2028                         case AST_FRAME_DTMF_BEGIN:
2029                                 break;
2030                         case AST_FRAME_DTMF_END:
2031                                 res = f->subclass;
2032                                 ast_frfree(f);
2033                                 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2034                                 return res;
2035                         case AST_FRAME_CONTROL:
2036                                 switch (f->subclass) {
2037                                 case AST_CONTROL_HANGUP:
2038                                         ast_frfree(f);
2039                                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2040                                         return -1;
2041                                 case AST_CONTROL_RINGING:
2042                                 case AST_CONTROL_ANSWER:
2043                                         /* Unimportant */
2044                                         break;
2045                                 default:
2046                                         ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
2047                                         break;
2048                                 }
2049                                 break;
2050                         case AST_FRAME_VOICE:
2051                                 /* Write audio if appropriate */
2052                                 if (audiofd > -1)
2053                                         write(audiofd, f->data, f->datalen);
2054                         default:
2055                                 /* Ignore */
2056                                 break;
2057                         }
2058                         ast_frfree(f);
2059                 }
2060         }
2061
2062         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2063
2064         return 0; /* Time is up */
2065 }
2066
2067 static void send_dtmf_event(const struct ast_channel *chan, const char *direction, const char digit, const char *begin, const char *end)
2068 {
2069         manager_event(EVENT_FLAG_DTMF,
2070                         "DTMF",
2071                         "Channel: %s\r\n"
2072                         "Uniqueid: %s\r\n"
2073                         "Digit: %c\r\n"
2074                         "Direction: %s\r\n"
2075                         "Begin: %s\r\n"
2076                         "End: %s\r\n",
2077                         chan->name, chan->uniqueid, digit, direction, begin, end);
2078 }
2079
2080 static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
2081 {
2082         if (chan->generatordata &&  !ast_internal_timing_enabled(chan)) {
2083                 void *tmp = chan->generatordata;
2084                 int res;
2085
2086                 if (chan->timingfunc) {
2087                         if (option_debug > 1)
2088                                 ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n");
2089                         ast_settimeout(chan, 0, NULL, NULL);
2090                 }
2091
2092                 chan->generatordata = NULL;     /* reset, to let writes go through */
2093                 res = chan->generator->generate(chan, tmp, f->datalen, f->samples);
2094                 chan->generatordata = tmp;
2095                 if (res) {
2096                         if (option_debug > 1)
2097                                 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
2098                         ast_deactivate_generator(chan);
2099                 }
2100
2101         } else if (f->frametype == AST_FRAME_CNG) {
2102                 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
2103                         if (option_debug > 1)
2104                                 ast_log(LOG_DEBUG, "Generator got CNG, switching to timed mode\n");
2105                         ast_settimeout(chan, 160, generator_force, chan);
2106                 }
2107         }
2108 }
2109
2110 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
2111 {
2112         struct ast_frame *f = NULL;     /* the return value */
2113         int blah;
2114         int prestate;
2115         int count = 0;
2116
2117         /* this function is very long so make sure there is only one return
2118          * point at the end (there are only two exceptions to this).
2119          */
2120         while(ast_channel_trylock(chan)) {
2121                 if(count++ > 10)
2122                         /*cannot goto done since the channel is not locked*/
2123                         return &ast_null_frame;
2124                 usleep(1);
2125         }
2126
2127         if (chan->masq) {
2128                 if (ast_do_masquerade(chan))
2129                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2130                 else
2131                         f =  &ast_null_frame;
2132                 goto done;
2133         }
2134
2135         /* Stop if we're a zombie or need a soft hangup */
2136         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2137                 if (chan->generator)
2138                         ast_deactivate_generator(chan);
2139                 goto done;
2140         }
2141         prestate = chan->_state;
2142
2143         if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) &&
2144             !ast_strlen_zero(chan->dtmfq) &&
2145                 (ast_tvzero(chan->dtmf_tv) || ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) > AST_MIN_DTMF_GAP) ) {
2146                 /* We have DTMF that has been deferred.  Return it now */
2147                 chan->dtmff.subclass = chan->dtmfq[0];
2148                 /* Drop first digit from the buffer */
2149                 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
2150                 f = &chan->dtmff;
2151                 if (ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
2152                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2153                         chan->dtmff.frametype = AST_FRAME_DTMF_END;
2154                 } else {
2155                         ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %d queued on %s\n", f->subclass, AST_DEFAULT_EMULATE_DTMF_DURATION, chan->name);
2156                         chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
2157                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2158                         chan->emulate_dtmf_digit = f->subclass;
2159                         chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2160                 }
2161                 chan->dtmf_tv = ast_tvnow();
2162                 goto done;
2163         }
2164
2165         /* Read and ignore anything on the alertpipe, but read only
2166            one sizeof(blah) per frame that we send from it */
2167         if (chan->alertpipe[0] > -1)
2168                 read(chan->alertpipe[0], &blah, sizeof(blah));
2169
2170 #ifdef HAVE_ZAPTEL
2171         if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2172                 int res;
2173
2174                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2175                 blah = -1;
2176                 /* IF we can't get event, assume it's an expired as-per the old interface */
2177                 res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
2178                 if (res)
2179                         blah = ZT_EVENT_TIMER_EXPIRED;
2180
2181                 if (blah == ZT_EVENT_TIMER_PING) {
2182                         if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
2183                                 /* Acknowledge PONG unless we need it again */
2184                                 if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
2185                                         ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
2186                                 }
2187                         }
2188                 } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
2189                         ioctl(chan->timingfd, ZT_TIMERACK, &blah);
2190                         if (chan->timingfunc) {
2191                                 chan->timingfunc(chan->timingdata);
2192                         } else {
2193                                 blah = 0;
2194                                 ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
2195                                 chan->timingdata = NULL;
2196                         }
2197                         ast_channel_unlock(chan);
2198                         /* cannot 'goto done' because the channel is already unlocked */
2199                         return &ast_null_frame;
2200                 } else
2201                         ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
2202         } else
2203 #endif
2204         if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
2205                 /* if the AST_GENERATOR_FD is set, call the generator with args
2206                  * set to -1 so it can do whatever it needs to.
2207                  */
2208                 void *tmp = chan->generatordata;
2209                 chan->generatordata = NULL;     /* reset to let ast_write get through */
2210                 chan->generator->generate(chan, tmp, -1, -1);
2211                 chan->generatordata = tmp;
2212                 f = &ast_null_frame;
2213                 goto done;
2214         }
2215
2216         /* Check for pending read queue */
2217         if (!AST_LIST_EMPTY(&chan->readq)) {
2218                 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
2219                 /* Interpret hangup and return NULL */
2220                 /* XXX why not the same for frames from the channel ? */
2221                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
2222                         ast_frfree(f);
2223                         f = NULL;
2224                 }
2225         } else {
2226                 chan->blocker = pthread_self();
2227                 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2228                         if (chan->tech->exception)
2229                                 f = chan->tech->exception(chan);
2230                         else {
2231                                 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
2232                                 f = &ast_null_frame;
2233                         }
2234                         /* Clear the exception flag */
2235                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2236                 } else if (chan->tech->read)
2237                         f = chan->tech->read(chan);
2238                 else
2239                         ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
2240         }
2241
2242         if (f) {
2243                 /* if the channel driver returned more than one frame, stuff the excess
2244                    into the readq for the next ast_read call (note that we can safely assume
2245                    that the readq is empty, because otherwise we would not have called into
2246                    the channel driver and f would be only a single frame)
2247                 */
2248                 if (AST_LIST_NEXT(f, frame_list)) {
2249                         AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
2250                         AST_LIST_NEXT(f, frame_list) = NULL;
2251                 }
2252
2253                 switch (f->frametype) {
2254                 case AST_FRAME_CONTROL:
2255                         if (f->subclass == AST_CONTROL_ANSWER) {
2256                                 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
2257                                         ast_debug(1, "Ignoring answer on an inbound call!\n");
2258                                         ast_frfree(f);
2259                                         f = &ast_null_frame;
2260                                 } else if (prestate == AST_STATE_UP) {
2261                                         ast_debug(1, "Dropping duplicate answer!\n");
2262                                         ast_frfree(f);
2263                                         f = &ast_null_frame;
2264                                 } else {
2265                                         /* Answer the CDR */
2266                                         ast_setstate(chan, AST_STATE_UP);
2267                                         if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
2268                                                                                  to keep from throwing off the basic order of the universe,
2269                                                                                  we will try to keep this cdr from getting posted. */
2270                                                 chan->cdr = ast_cdr_alloc();
2271                                                 ast_cdr_init(chan->cdr, chan);
2272                                                 ast_cdr_start(chan->cdr);
2273                                         }
2274
2275                                         ast_cdr_answer(chan->cdr);
2276                                 }
2277                         }
2278                         break;
2279                 case AST_FRAME_DTMF_END:
2280                         send_dtmf_event(chan, "Received", f->subclass, "No", "Yes");
2281                         ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass, chan->name, f->len);
2282                         /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2283                          * However, only let emulation be forced if the other end cares about BEGIN frames */
2284                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF) ||
2285                                 (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) ) {
2286                                 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2287                                         ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2288                                         chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2289                                 } else
2290                                         ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2291                                 ast_frfree(f);
2292                                 f = &ast_null_frame;
2293                         } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) {
2294                                 if (!ast_tvzero(chan->dtmf_tv) &&
2295                                     ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) {
2296                                         /* If it hasn't been long enough, defer this digit */
2297                                         if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2298                                                 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2299                                                 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2300                                         } else
2301                                                 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2302                                         ast_frfree(f);
2303                                         f = &ast_null_frame;
2304                                 } else {
2305                                         /* There was no begin, turn this into a begin and send the end later */
2306                                         f->frametype = AST_FRAME_DTMF_BEGIN;
2307                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2308                                         chan->emulate_dtmf_digit = f->subclass;
2309                                         chan->dtmf_tv = ast_tvnow();
2310                                         if (f->len) {
2311                                                 if (f->len > AST_MIN_DTMF_DURATION)
2312                                                         chan->emulate_dtmf_duration = f->len;
2313                                                 else
2314                                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION;
2315                                         } else
2316                                                 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2317                                         ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass, chan->emulate_dtmf_duration, chan->name);
2318                                 }
2319                                 if (chan->audiohooks) {
2320                                         struct ast_frame *old_frame = f;
2321                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2322                                         if (old_frame != f)
2323                                                 ast_frfree(old_frame);
2324                                 }
2325                         } else {
2326                                 struct timeval now = ast_tvnow();
2327                                 if (ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2328                                         ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass, chan->name);
2329                                         ast_clear_flag(chan, AST_FLAG_IN_DTMF);
2330                                         if (!f->len)
2331                                                 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2332                                 } else if (!f->len) {
2333                                         ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass, chan->name);
2334                                         f->len = AST_MIN_DTMF_DURATION;
2335                                 }
2336                                 if (f->len < AST_MIN_DTMF_DURATION) {
2337                                         ast_log(LOG_DTMF, "DTMF end '%c' has duration %ld but want minimum %d, emulating on %s\n", f->subclass, f->len, AST_MIN_DTMF_DURATION, chan->name);
2338                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2339                                         chan->emulate_dtmf_digit = f->subclass;
2340                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len;
2341                                         ast_frfree(f);
2342                                         f = &ast_null_frame;
2343                                 } else {
2344                                         ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass, chan->name);
2345                                         chan->dtmf_tv = now;
2346                                 }
2347                                 if (chan->audiohooks) {
2348                                         struct ast_frame *old_frame = f;
2349                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2350                                         if (old_frame != f)
2351                                                 ast_frfree(old_frame);
2352                                 }
2353                         }
2354                         break;
2355                 case AST_FRAME_DTMF_BEGIN:
2356                         send_dtmf_event(chan, "Received", f->subclass, "Yes", "No");
2357                         ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2358                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY) ||
2359                             (!ast_tvzero(chan->dtmf_tv) &&
2360                               ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) {
2361                                 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass, chan->name);
2362                                 ast_frfree(f);
2363                                 f = &ast_null_frame;
2364                         } else {
2365                                 ast_set_flag(chan, AST_FLAG_IN_DTMF);
2366                                 chan->dtmf_tv = ast_tvnow();
2367                                 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass, chan->name);
2368                         }
2369                         break;
2370                 case AST_FRAME_NULL:
2371                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2372                                 struct timeval now = ast_tvnow();
2373                                 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2374                                         chan->emulate_dtmf_duration = 0;
2375                                         ast_frfree(f);
2376                                         f = &chan->dtmff;
2377                                         f->frametype = AST_FRAME_DTMF_END;
2378                                         f->subclass = chan->emulate_dtmf_digit;
2379                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2380                                         chan->dtmf_tv = now;
2381                                         ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2382                                         chan->emulate_dtmf_digit = 0;
2383                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2384                                 }
2385                         }
2386                         break;
2387                 case AST_FRAME_VOICE:
2388                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2389                          * is reached , because we want to make sure we pass at least one
2390                          * voice frame through before starting the next digit, to ensure a gap
2391                          * between DTMF digits. */
2392                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) {
2393                                 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2394                                 chan->emulate_dtmf_digit = 0;
2395                         }
2396
2397                         if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2398                                 if (dropaudio)
2399                                         ast_read_generator_actions(chan, f);
2400                                 ast_frfree(f);
2401                                 f = &ast_null_frame;
2402                         }
2403
2404                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2405                                 struct timeval now = ast_tvnow();
2406                                 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2407                                         chan->emulate_dtmf_duration = 0;
2408                                         ast_frfree(f);
2409                                         f = &chan->dtmff;
2410                                         f->frametype = AST_FRAME_DTMF_END;
2411                                         f->subclass = chan->emulate_dtmf_digit;
2412                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2413                                         chan->dtmf_tv = now;
2414                                         if (chan->audiohooks) {
2415                                                 struct ast_frame *old_frame = f;
2416                                                 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2417                                                 if (old_frame != f)
2418                                                         ast_frfree(old_frame);
2419                                         }
2420                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2421                                 } else {
2422                                         /* Drop voice frames while we're still in the middle of the digit */
2423                                         ast_frfree(f);
2424                                         f = &ast_null_frame;
2425                                 }
2426                         } else if ((f->frametype == AST_FRAME_VOICE) && !(f->subclass & chan->nativeformats)) {
2427                                 /* This frame can't be from the current native formats -- drop it on the
2428                                    floor */
2429                                 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2430                                         chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
2431                                 ast_frfree(f);
2432                                 f = &ast_null_frame;
2433                         } else if ((f->frametype == AST_FRAME_VOICE)) {
2434                                 /* Send frame to audiohooks if present */
2435                                 if (chan->audiohooks) {
2436                                         struct ast_frame *old_frame = f;
2437                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2438                                         if (old_frame != f)
2439                                                 ast_frfree(old_frame);
2440                                 }
2441                                 if (chan->monitor && chan->monitor->read_stream ) {
2442                                         /* XXX what does this do ? */
2443 #ifndef MONITOR_CONSTANT_DELAY
2444                                         int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2445                                         if (jump >= 0) {
2446                                                 jump = chan->outsmpl - chan->insmpl;
2447                                                 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1)
2448                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2449                                                 chan->insmpl += jump + f->samples;
2450                                         } else
2451                                                 chan->insmpl+= f->samples;
2452 #else
2453                                         int jump = chan->outsmpl - chan->insmpl;
2454                                         if (jump - MONITOR_DELAY >= 0) {
2455                                                 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2456                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2457                                                 chan->insmpl += jump;
2458                                         } else
2459                                                 chan->insmpl += f->samples;
2460 #endif
2461                                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2462                                                 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2463                                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2464                                         }
2465                                 }
2466
2467                                 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
2468                                         f = &ast_null_frame;
2469                                 else
2470                                         /* Run generator sitting on the line if timing device not available
2471                                          * and synchronous generation of outgoing frames is necessary       */
2472                                         ast_read_generator_actions(chan, f);
2473                         }
2474                 default:
2475                         /* Just pass it on! */
2476                         break;
2477                 }
2478         } else {
2479                 /* Make sure we always return NULL in the future */
2480                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2481                 if (chan->generator)
2482                         ast_deactivate_generator(chan);
2483                 /* End the CDR if appropriate */
2484                 if (chan->cdr)
2485                         ast_cdr_end(chan->cdr);
2486         }
2487
2488         /* High bit prints debugging */
2489         if (chan->fin & DEBUGCHAN_FLAG)
2490                 ast_frame_dump(chan->name, f, "<<");
2491         chan->fin = FRAMECOUNT_INC(chan->fin);
2492
2493 done:
2494         if (chan->music_state && chan->generator && chan->generator->digit && f && f->frametype == AST_FRAME_DTMF_END)
2495                 chan->generator->digit(chan, f->subclass);
2496
2497         ast_channel_unlock(chan);
2498         return f;
2499 }
2500
2501 int ast_internal_timing_enabled(struct ast_channel *chan)
2502 {
2503         int ret = ast_opt_internal_timing && chan->timingfd > -1;
2504         ast_debug(5, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
2505         return ret;
2506 }
2507
2508 struct ast_frame *ast_read(struct ast_channel *chan)
2509 {
2510         return __ast_read(chan, 0);
2511 }
2512
2513 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2514 {
2515         return __ast_read(chan, 1);
2516 }
2517
2518 int ast_indicate(struct ast_channel *chan, int condition)
2519 {
2520         return ast_indicate_data(chan, condition, NULL, 0);
2521 }
2522
2523 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
2524 {
2525         int res = -1;
2526
2527         ast_channel_lock(chan);
2528         /* Stop if we're a zombie or need a soft hangup */
2529         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2530                 ast_channel_unlock(chan);
2531                 return -1;
2532         }
2533         if (chan->tech->indicate)
2534                 res = chan->tech->indicate(chan, condition, data, datalen);
2535         ast_channel_unlock(chan);
2536         if (!chan->tech->indicate || res) {
2537                 /*
2538                  * Device does not support (that) indication, lets fake
2539                  * it by doing our own tone generation. (PM2002)
2540                  */
2541                 if (condition < 0)
2542                         ast_playtones_stop(chan);
2543                 else {
2544                         const struct ind_tone_zone_sound *ts = NULL;
2545                         switch (condition) {
2546                         case AST_CONTROL_RINGING:
2547                                 ts = ast_get_indication_tone(chan->zone, "ring");
2548                                 break;
2549                         case AST_CONTROL_BUSY:
2550                                 ts = ast_get_indication_tone(chan->zone, "busy");
2551                                 break;
2552                         case AST_CONTROL_CONGESTION:
2553                                 ts = ast_get_indication_tone(chan->zone, "congestion");
2554                                 break;
2555                         }
2556                         if (ts && ts->data[0]) {
2557                                 ast_debug(1, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2558                                 ast_playtones_start(chan,0,ts->data, 1);
2559                                 res = 0;
2560                         } else if (condition == AST_CONTROL_PROGRESS) {
2561                                 /* ast_playtones_stop(chan); */
2562                         } else if (condition == AST_CONTROL_PROCEEDING) {
2563                                 /* Do nothing, really */
2564                         } else if (condition == AST_CONTROL_HOLD) {
2565                                 /* Do nothing.... */
2566                         } else if (condition == AST_CONTROL_UNHOLD) {
2567                                 /* Do nothing.... */
2568                         } else if (condition == AST_CONTROL_VIDUPDATE) {
2569                                 /* Do nothing.... */
2570                         } else {
2571                                 /* not handled */
2572                                 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2573                                 res = -1;
2574                         }
2575                 }
2576         }
2577         return res;
2578 }
2579
2580 int ast_recvchar(struct ast_channel *chan, int timeout)
2581 {
2582         int c;
2583         char *buf = ast_recvtext(chan, timeout);
2584         if (buf == NULL)
2585                 return -1;      /* error or timeout */
2586         c = *(unsigned char *)buf;
2587         ast_free(buf);
2588         return c;
2589 }
2590
2591 char *ast_recvtext(struct ast_channel *chan, int timeout)
2592 {
2593         int res, done = 0;
2594         char *buf = NULL;
2595
2596         while (!done) {
2597                 struct ast_frame *f;
2598                 if (ast_check_hangup(chan))
2599                         break;
2600                 res = ast_waitfor(chan, timeout);
2601                 if (res <= 0) /* timeout or error */
2602                         break;
2603                 timeout = res;  /* update timeout */
2604                 f = ast_read(chan);
2605                 if (f == NULL)
2606                         break; /* no frame */
2607                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2608                         done = 1;       /* force a break */
2609                 else if (f->frametype == AST_FRAME_TEXT) {              /* what we want */
2610                         buf = ast_strndup((char *) f->data, f->datalen);        /* dup and break */
2611                         done = 1;
2612                 }
2613                 ast_frfree(f);
2614         }
2615         return buf;
2616 }
2617
2618 int ast_sendtext(struct ast_channel *chan, const char *text)
2619 {
2620         int res = 0;
2621         /* Stop if we're a zombie or need a soft hangup */
2622         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2623                 return -1;
2624         CHECK_BLOCKING(chan);
2625         if (chan->tech->send_text)
2626                 res = chan->tech->send_text(chan, text);
2627         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2628         return res;
2629 }
2630
2631 int ast_senddigit_begin(struct ast_channel *chan, char digit)
2632 {
2633         /* Device does not support DTMF tones, lets fake
2634          * it by doing our own generation. */
2635         static const char* dtmf_tones[] = {
2636                 "941+1336", /* 0 */
2637                 "697+1209", /* 1 */
2638                 "697+1336", /* 2 */
2639                 "697+1477", /* 3 */
2640                 "770+1209", /* 4 */
2641                 "770+1336", /* 5 */
2642                 "770+1477", /* 6 */
2643                 "852+1209", /* 7 */
2644                 "852+1336", /* 8 */
2645                 "852+1477", /* 9 */
2646                 "697+1633", /* A */
2647                 "770+1633", /* B */
2648                 "852+1633", /* C */
2649                 "941+1633", /* D */
2650                 "941+1209", /* * */
2651                 "941+1477"  /* # */
2652         };
2653
2654         if (!chan->tech->send_digit_begin)
2655                 return 0;
2656
2657         if (!chan->tech->send_digit_begin(chan, digit))
2658                 return 0;
2659
2660         if (digit >= '0' && digit <='9')
2661                 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2662         else if (digit >= 'A' && digit <= 'D')
2663                 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2664         else if (digit == '*')
2665                 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2666         else if (digit == '#')
2667                 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2668         else {
2669                 /* not handled */
2670                 ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2671         }
2672
2673         return 0;
2674 }
2675
2676 int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
2677 {
2678         int res = -1;
2679
2680         if (chan->tech->send_digit_end)
2681                 res = chan->tech->send_digit_end(chan, digit, duration);
2682
2683         if (res && chan->generator)
2684                 ast_playtones_stop(chan);
2685
2686         return 0;
2687 }
2688
2689 int ast_senddigit(struct ast_channel *chan, char digit, unsigned int duration)
2690 {
2691         if (chan->tech->send_digit_begin) {
2692                 ast_senddigit_begin(chan, digit);
2693                 ast_safe_sleep(chan, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2694         }
2695
2696         return ast_senddigit_end(chan, digit, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2697 }
2698
2699 int ast_prod(struct ast_channel *chan)
2700 {
2701         struct ast_frame a = { AST_FRAME_VOICE };
2702         char nothing[128];
2703
2704         /* Send an empty audio frame to get things moving */
2705         if (chan->_state != AST_STATE_UP) {
2706                 ast_debug(1, "Prodding channel '%s'\n", chan->name);
2707                 a.subclass = chan->rawwriteformat;
2708                 a.data = nothing + AST_FRIENDLY_OFFSET;
2709                 a.src = "ast_prod";
2710                 if (ast_write(chan, &a))
2711                         ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2712         }
2713         return 0;
2714 }
2715
2716 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2717 {
2718         int res;
2719         if (!chan->tech->write_video)
2720                 return 0;
2721         res = ast_write(chan, fr);
2722         if (!res)
2723                 res = 1;
2724         return res;
2725 }
2726
2727 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2728 {
2729         int res = -1;
2730         struct ast_frame *f = NULL, *f2 = NULL;
2731
2732         /* Stop if we're a zombie or need a soft hangup */
2733         ast_channel_lock(chan);
2734         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2735                 goto done;
2736
2737         /* Handle any pending masquerades */
2738         if (chan->masq && ast_do_masquerade(chan)) {
2739                 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2740                 goto done;
2741         }
2742         if (chan->masqr) {
2743                 res = 0;        /* XXX explain, why 0 ? */
2744                 goto done;
2745         }
2746         if (chan->generatordata) {
2747                 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
2748                         ast_deactivate_generator(chan);
2749                 else {
2750                         if (fr->frametype == AST_FRAME_DTMF_END) {
2751                                 /* There is a generator running while we're in the middle of a digit.
2752                                  * It's probably inband DTMF, so go ahead and pass it so it can
2753                                  * stop the generator */
2754                                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2755                                 ast_channel_unlock(chan);
2756                                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
2757                                 ast_channel_lock(chan);
2758                                 CHECK_BLOCKING(chan);
2759                         } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
2760                                 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
2761                                 res = (chan->tech->indicate == NULL) ? 0 :
2762                                         chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2763                         }
2764                         res = 0;        /* XXX explain, why 0 ? */
2765                         goto done;
2766                 }
2767         }
2768         /* High bit prints debugging */
2769         if (chan->fout & DEBUGCHAN_FLAG)
2770                 ast_frame_dump(chan->name, fr, ">>");
2771         CHECK_BLOCKING(chan);
2772         switch (fr->frametype) {
2773         case AST_FRAME_CONTROL:
2774                 res = (chan->tech->indicate == NULL) ? 0 :
2775                         chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2776                 break;
2777         case AST_FRAME_DTMF_BEGIN:
2778                 if (chan->audiohooks) {
2779                         struct ast_frame *old_frame = fr;
2780                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2781                         if (old_frame != fr)
2782                                 f = fr;
2783                 }
2784                 send_dtmf_event(chan, "Sent", fr->subclass, "Yes", "No");
2785                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2786                 ast_channel_unlock(chan);
2787                 res = ast_senddigit_begin(chan, fr->subclass);
2788                 ast_channel_lock(chan);
2789                 CHECK_BLOCKING(chan);
2790                 break;
2791         case AST_FRAME_DTMF_END:
2792                 if (chan->audiohooks) {
2793                         struct ast_frame *old_frame = fr;
2794                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2795                         if (old_frame != fr)
2796                                 f = fr;
2797                 }
2798                 send_dtmf_event(chan, "Sent", fr->subclass, "No", "Yes");
2799                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2800                 ast_channel_unlock(chan);
2801                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
2802                 ast_channel_lock(chan);
2803                 CHECK_BLOCKING(chan);
2804                 break;
2805         case AST_FRAME_TEXT:
2806                 if (fr->subclass == AST_FORMAT_T140) {
2807                         res = (chan->tech->write_text == NULL) ? 0 :
2808                                 chan->tech->write_text(chan, fr);
2809                 } else {
2810                         res = (chan->tech->send_text == NULL) ? 0 :
2811                                 chan->tech->send_text(chan, (char *) fr->data);
2812                 }
2813                 break;
2814         case AST_FRAME_HTML:
2815                 res = (chan->tech->send_html == NULL) ? 0 :
2816                         chan->tech->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen);
2817                 break;
2818         case AST_FRAME_VIDEO:
2819                 /* XXX Handle translation of video codecs one day XXX */
2820                 res = (chan->tech->write_video == NULL) ? 0 :
2821                         chan->tech->write_video(chan, fr);
2822                 break;
2823         case AST_FRAME_MODEM:
2824                 res = (chan->tech->write == NULL) ? 0 :
2825                         chan->tech->write(chan, fr);
2826                 break;
2827         case AST_FRAME_VOICE:
2828                 if (chan->tech->write == NULL)
2829                         break;  /*! \todo XXX should return 0 maybe ? */
2830
2831                 /* If audiohooks are present, write the frame out */
2832                 if (chan->audiohooks) {
2833                         struct ast_frame *old_frame = fr;
2834                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2835                         if (old_frame != fr)
2836                                 f2 = fr;
2837                 }
2838
2839                 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
2840                 if (fr->subclass == chan->rawwriteformat)
2841                         f = fr;
2842                 else
2843                         f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
2844
2845                 if (!f) {
2846                         res = 0;
2847                         break;
2848                 }
2849
2850                 /* If Monitor is running on this channel, then we have to write frames out there too */
2851                 if (chan->monitor && chan->monitor->write_stream) {
2852                         /* XXX must explain this code */
2853 #ifndef MONITOR_CONSTANT_DELAY
2854                         int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
2855                         if (jump >= 0) {
2856                                 jump = chan->insmpl - chan->outsmpl;
2857                                 if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
2858                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2859                                 chan->outsmpl += jump + f->samples;
2860                         } else
2861                                 chan->outsmpl += f->samples;
2862 #else
2863                         int jump = chan->insmpl - chan->outsmpl;
2864                         if (jump - MONITOR_DELAY >= 0) {
2865                                 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2866                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2867                                 chan->outsmpl += jump;
2868                         } else
2869                                 chan->outsmpl += f->samples;
2870 #endif
2871                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2872                                 if (ast_writestream(chan->monitor->write_stream, f) < 0)
2873                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
2874                         }
2875                 }
2876
2877                 if (f) {
2878                         struct ast_channel *base = NULL;
2879                         if (!chan->tech->get_base_channel || chan == chan->tech->get_base_channel(chan))
2880                                 res = chan->tech->write(chan, f);
2881                         else {
2882                                 while (chan->tech->get_base_channel && (((base = chan->tech->get_base_channel(chan)) && ast_mutex_trylock(&base->lock)) || base == NULL)) {
2883                                         ast_mutex_unlock(&chan->lock);
2884                                         usleep(1);
2885                                         ast_mutex_lock(&chan->lock);
2886                                 }
2887                                 res = base->tech->write(base, f);
2888                                 ast_mutex_unlock(&base->lock);
2889                         }
2890                 } else
2891                         res = 0;
2892                 break;
2893         case AST_FRAME_NULL:
2894         case AST_FRAME_IAX:
2895                 /* Ignore these */
2896                 res = 0;
2897                 break;
2898         default:
2899                 /* At this point, fr is the incoming frame and f is NULL.  Channels do
2900                  * not expect to get NULL as a frame pointer and will segfault.  Hence,
2901                  * we output the original frame passed in. */
2902                 res = chan->tech->write(chan, fr);
2903                 break;
2904         }
2905
2906         if (f && f != fr)
2907                 ast_frfree(f);
2908         if (f2)
2909                 ast_frfree(f2);
2910         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2911         /* Consider a write failure to force a soft hangup */
2912         if (res < 0)
2913                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2914         else {
2915                 chan->fout = FRAMECOUNT_INC(chan->fout);
2916         }
2917 done:
2918         ast_channel_unlock(chan);
2919         return res;
2920 }
2921
2922 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
2923                       struct ast_trans_pvt **trans, const int direction)
2924 {
2925         int native;
2926         int res;
2927
2928         /* Make sure we only consider audio */
2929         fmt &= AST_FORMAT_AUDIO_MASK;
2930
2931         native = chan->nativeformats;
2932         /* Find a translation path from the native format to one of the desired formats */
2933         if (!direction)
2934                 /* reading */
2935                 res = ast_translator_best_choice(&fmt, &native);
2936         else
2937                 /* writing */
2938                 res = ast_translator_best_choice(&native, &fmt);
2939
2940         if (res < 0) {
2941                 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
2942                         ast_getformatname(native), ast_getformatname(fmt));
2943                 return -1;
2944         }
2945
2946         /* Now we have a good choice for both. */
2947         ast_channel_lock(chan);
2948
2949         if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
2950                 /* the channel is already in these formats, so nothing to do */
2951                 ast_channel_unlock(chan);
2952                 return 0;
2953         }
2954
2955         *rawformat = native;
2956         /* User perspective is fmt */
2957         *format = fmt;
2958         /* Free any read translation we have right now */
2959         if (*trans)
2960                 ast_translator_free_path(*trans);
2961         /* Build a translation path from the raw format to the desired format */
2962         if (!direction)
2963                 /* reading */
2964                 *trans = ast_translator_build_path(*format, *rawformat);
2965         else
2966                 /* writing */
2967                 *trans = ast_translator_build_path(*rawformat, *format);
2968         ast_channel_unlock(chan);
2969         ast_debug(1, "Set channel %s to %s format %s\n", chan->name,
2970                 direction ? "write" : "read", ast_getformatname(fmt));
2971         return 0;
2972 }
2973
2974 int ast_set_read_format(struct ast_channel *chan, int fmt)
2975 {
2976         return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
2977                           &chan->readtrans, 0);
2978 }
2979
2980 int ast_set_write_format(struct ast_channel *chan, int fmt)
2981 {
2982         return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
2983                           &chan->writetrans, 1);
2984 }
2985
2986 const char *ast_channel_reason2str(int reason)
2987 {
2988         switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */
2989         {
2990         case 0:
2991                 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
2992         case AST_CONTROL_HANGUP:
2993                 return "Hangup";
2994         case AST_CONTROL_RING:
2995                 return "Local Ring";
2996         case AST_CONTROL_RINGING:
2997                 return "Remote end Ringing";
2998         case AST_CONTROL_ANSWER:
2999                 return "Remote end has Answered";
3000         case AST_CONTROL_BUSY:
3001                 return "Remote end is Busy";
3002         case AST_CONTROL_CONGESTION:
3003                 return "Congestion (circuits busy)";
3004         default:
3005                 return "Unknown Reason!!";
3006         }
3007 }
3008
3009 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)
3010 {
3011         int dummy_outstate;
3012         int cause = 0;
3013         struct ast_channel *chan;
3014         int res = 0;
3015
3016         if (outstate)
3017                 *outstate = 0;
3018         else
3019                 outstate = &dummy_outstate;     /* make outstate always a valid pointer */
3020
3021         chan = ast_request(type, format, data, &cause);
3022         if (!chan) {
3023                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
3024                 /* compute error and return */
3025                 if (cause == AST_CAUSE_BUSY)
3026                         *outstate = AST_CONTROL_BUSY;
3027                 else if (cause == AST_CAUSE_CONGESTION)
3028                         *outstate = AST_CONTROL_CONGESTION;
3029                 return NULL;
3030         }
3031
3032         if (oh) {
3033                 if (oh->vars)
3034                         ast_set_variables(chan, oh->vars);
3035                 /* XXX why is this necessary, for the parent_channel perhaps ? */
3036                 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
3037                         ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
3038                 if (oh->parent_channel) {
3039                         ast_channel_inherit_variables(oh->parent_channel, chan);
3040                         ast_channel_datastore_inherit(oh->parent_channel, chan);
3041                 }
3042                 if (oh->account)
3043                         ast_cdr_setaccount(chan, oh->account);
3044         }
3045         ast_set_callerid(chan, cid_num, cid_name, cid_num);
3046
3047
3048
3049         if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
3050                                 to keep from throwing off the basic order of the universe,
3051                                 we will try to keep this cdr from getting posted. */
3052                 chan->cdr = ast_cdr_alloc();
3053                 ast_cdr_init(chan->cdr, chan);
3054                 ast_cdr_start(chan->cdr);
3055         }
3056         if (ast_call(chan, data, 0)) {  /* ast_call failed... */
3057                 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
3058         } else {
3059                 res = 1;        /* mark success in case chan->_state is already AST_STATE_UP */
3060                 while (timeout && chan->_state != AST_STATE_UP) {
3061                         struct ast_frame *f;
3062                         res = ast_waitfor(chan, timeout);
3063                         if (res <= 0) /* error, timeout, or done */
3064                                 break;
3065                         if (timeout > -1)
3066                                 timeout = res;
3067                         f = ast_read(chan);
3068                         if (!f) {
3069                                 *outstate = AST_CONTROL_HANGUP;
3070                                 res = 0;
3071                                 break;
3072                         }
3073                         if (f->frametype == AST_FRAME_CONTROL) {
3074                                 switch (f->subclass) {
3075                                 case AST_CONTROL_RINGING:       /* record but keep going */
3076                                         *outstate = f->subclass;