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