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 #include "asterisk/zapata.h"
  38
  39 #include "asterisk/pbx.h"
  40 #include "asterisk/frame.h"
  41 #include "asterisk/sched.h"
  42 #include "asterisk/channel.h"
  43 #include "asterisk/musiconhold.h"
  44 #include "asterisk/say.h"
  45 #include "asterisk/file.h"
  46 #include "asterisk/cli.h"
  47 #include "asterisk/translate.h"
  48 #include "asterisk/manager.h"
  49 #include "asterisk/chanvars.h"
  50 #include "asterisk/linkedlists.h"
  51 #include "asterisk/indications.h"
  52 #include "asterisk/monitor.h"
  53 #include "asterisk/causes.h"
  54 #include "asterisk/callerid.h"
  55 #include "asterisk/utils.h"
  56 #include "asterisk/lock.h"
  57 #include "asterisk/app.h"
  58 #include "asterisk/transcap.h"
  59 #include "asterisk/devicestate.h"
  60 #include "asterisk/sha1.h"
  61 #include "asterisk/threadstorage.h"
  62 #include "asterisk/slinfactory.h"
  63 #include "asterisk/audiohook.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_channel_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_channel_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 tv = { offset, };
 533         ast_channel_setwhentohangup_tv(chan, tv);
 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 tv = { offset, };
 555         return ast_channel_cmpwhentohangup_tv(chan, tv);
 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 < (sizeof(prefs) / sizeof(prefs[0]) ); 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 #ifdef HAVE_ZAPTEL
 812         tmp->timingfd = open("/dev/zap/timer", O_RDWR);
 813         if (tmp->timingfd > -1) {
 814                 /* Check if timing interface supports new
 815                    ping/pong scheme */
 816                 flags = 1;
 817                 if (!ioctl(tmp->timingfd, ZT_TIMERPONG, &flags))
 818                         needqueue = 0;
 819         }
 820 #else
 821         tmp->timingfd = -1;
 822 #endif
 823
 824         if (needqueue) {
 825                 if (pipe(tmp->alertpipe)) {
 826                         ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
 827 #ifdef HAVE_ZAPTEL
 828                         if (tmp->timingfd > -1)
 829                                 close(tmp->timingfd);
 830 #endif
 831                         sched_context_destroy(tmp->sched);
 832                         ast_string_field_free_memory(tmp);
 833                         ast_free(tmp);
 834                         return NULL;
 835                 } else {
 836                         flags = fcntl(tmp->alertpipe[0], F_GETFL);
 837                         fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK);
 838                         flags = fcntl(tmp->alertpipe[1], F_GETFL);
 839                         fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK);
 840                 }
 841         } else  /* Make sure we've got it done right if they don't */
 842                 tmp->alertpipe[0] = tmp->alertpipe[1] = -1;
 843
 844         /* Always watch the alertpipe */
 845         ast_channel_set_fd(tmp, AST_ALERT_FD, tmp->alertpipe[0]);
 846         /* And timing pipe */
 847         ast_channel_set_fd(tmp, AST_TIMING_FD, tmp->timingfd);
 848         ast_string_field_set(tmp, name, "**Unknown**");
 849
 850         /* Initial state */
 851         tmp->_state = state;
 852
 853         tmp->streamid = -1;
 854
 855         tmp->fin = global_fin;
 856         tmp->fout = global_fout;
 857
 858         if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
 859                 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL),
 860                                        ast_atomic_fetchadd_int(&uniqueint, 1));
 861         } else {
 862                 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME,
 863                                        (long) time(NULL), ast_atomic_fetchadd_int(&uniqueint, 1));
 864         }
 865
 866         tmp->cid.cid_name = ast_strdup(cid_name);
 867         tmp->cid.cid_num = ast_strdup(cid_num);
 868
 869         if (!ast_strlen_zero(name_fmt)) {
 870                 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
 871                  * And they all use slightly different formats for their name string.
 872                  * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
 873                  * This means, that the stringfields must have a routine that takes the va_lists directly, and
 874                  * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
 875                  * This new function was written so this can be accomplished.
 876                  */
 877                 va_start(ap1, name_fmt);
 878                 va_start(ap2, name_fmt);
 879                 ast_string_field_build_va(tmp, name, name_fmt, ap1, ap2);
 880                 va_end(ap1);
 881                 va_end(ap2);
 882         }
 883
 884         /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */
 885
 886         /* These 4 variables need to be set up for the cdr_init() to work right */
 887         if (amaflag)
 888                 tmp->amaflags = amaflag;
 889         else
 890                 tmp->amaflags = ast_default_amaflags;
 891
 892         if (!ast_strlen_zero(acctcode))
 893                 ast_string_field_set(tmp, accountcode, acctcode);
 894         else
 895                 ast_string_field_set(tmp, accountcode, ast_default_accountcode);
 896
 897         if (!ast_strlen_zero(context))
 898                 ast_copy_string(tmp->context, context, sizeof(tmp->context));
 899         else
 900                 strcpy(tmp->context, "default");
 901
 902         if (!ast_strlen_zero(exten))
 903                 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten));
 904         else
 905                 strcpy(tmp->exten, "s");
 906
 907         tmp->priority = 1;
 908
 909         tmp->cdr = ast_cdr_alloc();
 910         ast_cdr_init(tmp->cdr, tmp);
 911         ast_cdr_start(tmp->cdr);
 912
 913         headp = &tmp->varshead;
 914         AST_LIST_HEAD_INIT_NOLOCK(headp);
 915
 916         ast_mutex_init(&tmp->lock_dont_use);
 917
 918         AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores);
 919
 920         ast_string_field_set(tmp, language, defaultlanguage);
 921
 922         tmp->tech = &null_tech;
 923
 924         AST_RWLIST_WRLOCK(&channels);
 925         AST_RWLIST_INSERT_HEAD(&channels, tmp, chan_list);
 926         AST_RWLIST_UNLOCK(&channels);
 927
 928         /*\!note
 929          * and now, since the channel structure is built, and has its name, let's
 930          * call the manager event generator with this Newchannel event. This is the
 931          * proper and correct place to make this call, but you sure do have to pass
 932          * a lot of data into this func to do it here!
 933          */
 934         if (!ast_strlen_zero(name_fmt)) {
 935                 manager_event(EVENT_FLAG_CALL, "Newchannel",
 936                         "Channel: %s\r\n"
 937                         "ChannelState: %d\r\n"
 938                         "ChannelStateDesc: %s\r\n"
 939                         "CallerIDNum: %s\r\n"
 940                         "CallerIDName: %s\r\n"
 941                         "AccountCode: %s\r\n"
 942                         "Uniqueid: %s\r\n",
 943                         tmp->name,
 944                         state,
 945                         ast_state2str(state),
 946                         S_OR(cid_num, ""),
 947                         S_OR(cid_name, ""),
 948                         tmp->accountcode,
 949                         tmp->uniqueid);
 950         }
 951
 952         return tmp;
 953 }
 954
 955 /*! \brief Queue an outgoing media frame */
 956 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
 957 {
 958         struct ast_frame *f;
 959         struct ast_frame *cur;
 960         int blah = 1;
 961         int qlen = 0;
 962
 963         /* Build us a copy and free the original one */
 964         if (!(f = ast_frdup(fin))) {
 965                 ast_log(LOG_WARNING, "Unable to duplicate frame\n");
 966                 return -1;
 967         }
 968         ast_channel_lock(chan);
 969
 970         /* See if the last frame on the queue is a hangup, if so don't queue anything */
 971         if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
 972                 ast_frfree(f);
 973                 ast_channel_unlock(chan);
 974                 return 0;
 975         }
 976
 977         /* Count how many frames exist on the queue */
 978         AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
 979                 qlen++;
 980         }
 981
 982         /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
 983         if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen  > 128)) {
 984                 if (fin->frametype != AST_FRAME_VOICE) {
 985                         ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name);
 986                         ast_assert(0);
 987                 } else {
 988                         ast_debug(1, "Dropping voice to exceptionally long queue on %s\n", chan->name);
 989                         ast_frfree(f);
 990                         ast_channel_unlock(chan);
 991                         return 0;
 992                 }
 993         }
 994         AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
 995         if (chan->alertpipe[1] > -1) {
 996                 if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
 997                         ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
 998                                 chan->name, f->frametype, f->subclass, qlen, strerror(errno));
 999 #ifdef HAVE_ZAPTEL
1000         } else if (chan->timingfd > -1) {
1001                 ioctl(chan->timingfd, ZT_TIMERPING, &blah);
1002 #endif
1003         } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1004                 pthread_kill(chan->blocker, SIGURG);
1005         }
1006         ast_channel_unlock(chan);
1007         return 0;
1008 }
1009
1010 /*! \brief Queue a hangup frame for channel */
1011 int ast_queue_hangup(struct ast_channel *chan)
1012 {
1013         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
1014         /* Yeah, let's not change a lock-critical value without locking */
1015         if (!ast_channel_trylock(chan)) {
1016                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
1017                 ast_channel_unlock(chan);
1018         }
1019         return ast_queue_frame(chan, &f);
1020 }
1021
1022 /*! \brief Queue a hangup frame for channel */
1023 int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
1024 {
1025         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
1026
1027         if (cause >= 0)
1028                 f.data.uint32 = cause;
1029
1030         /* Yeah, let's not change a lock-critical value without locking */
1031         if (!ast_channel_trylock(chan)) {
1032                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
1033                 if (cause < 0)
1034                         f.data.uint32 = chan->hangupcause;
1035
1036                 ast_channel_unlock(chan);
1037         }
1038         return ast_queue_frame(chan, &f);
1039 }
1040
1041 /*! \brief Queue a control frame */
1042 int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
1043 {
1044         struct ast_frame f = { AST_FRAME_CONTROL, };
1045
1046         f.subclass = control;
1047
1048         return ast_queue_frame(chan, &f);
1049 }
1050
1051 /*! \brief Queue a control frame with payload */
1052 int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control,
1053                            const void *data, size_t datalen)
1054 {
1055         struct ast_frame f = { AST_FRAME_CONTROL, };
1056
1057         f.subclass = control;
1058         f.data.ptr = (void *) data;
1059         f.datalen = datalen;
1060
1061         return ast_queue_frame(chan, &f);
1062 }
1063
1064 /*! \brief Set defer DTMF flag on channel */
1065 int ast_channel_defer_dtmf(struct ast_channel *chan)
1066 {
1067         int pre = 0;
1068
1069         if (chan) {
1070                 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
1071                 ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
1072         }
1073         return pre;
1074 }
1075
1076 /*! \brief Unset defer DTMF flag on channel */
1077 void ast_channel_undefer_dtmf(struct ast_channel *chan)
1078 {
1079         if (chan)
1080                 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
1081 }
1082
1083 /*!
1084  * \brief Helper function to find channels.
1085  *
1086  * It supports these modes:
1087  *
1088  * prev != NULL : get channel next in list after prev
1089  * name != NULL : get channel with matching name
1090  * name != NULL && namelen != 0 : get channel whose name starts with prefix
1091  * exten != NULL : get channel whose exten or macroexten matches
1092  * context != NULL && exten != NULL : get channel whose context or macrocontext
1093  *
1094  * It returns with the channel's lock held. If getting the individual lock fails,
1095  * unlock and retry quickly up to 10 times, then give up.
1096  *
1097  * \note XXX Note that this code has cost O(N) because of the need to verify
1098  * that the object is still on the global list.
1099  *
1100  * \note XXX also note that accessing fields (e.g. c->name in ast_log())
1101  * can only be done with the lock held or someone could delete the
1102  * object while we work on it. This causes some ugliness in the code.
1103  * Note that removing the first ast_log() may be harmful, as it would
1104  * shorten the retry period and possibly cause failures.
1105  * We should definitely go for a better scheme that is deadlock-free.
1106  */
1107 static struct ast_channel *channel_find_locked(const struct ast_channel *prev,
1108                                                const char *name, const int namelen,
1109                                                const char *context, const char *exten)
1110 {
1111         const char *msg = prev ? "deadlock" : "initial deadlock";
1112         int retries;
1113         struct ast_channel *c;
1114         const struct ast_channel *_prev = prev;
1115
1116         for (retries = 0; retries < 200; retries++) {
1117                 int done;
1118                 AST_RWLIST_RDLOCK(&channels);
1119                 AST_RWLIST_TRAVERSE(&channels, c, chan_list) {
1120                         prev = _prev;
1121                         if (prev) {     /* look for next item */
1122                                 if (c != prev)  /* not this one */
1123                                         continue;
1124                                 /* found, prepare to return c->next */
1125                                 if ((c = AST_RWLIST_NEXT(c, chan_list)) == NULL) break;
1126                                 /* If prev was the last item on the channel list, then we just
1127                                  * want to return NULL, instead of trying to deref NULL in the
1128                                  * next section.
1129                                  */
1130                                 prev = NULL;
1131                                 /* We want prev to be NULL in case we end up doing more searching through
1132                                  * the channel list to find the channel (ie: name searching). If we didn't
1133                                  * set this to NULL the logic would just blow up
1134                                  * XXX Need a better explanation for this ...
1135                                  */
1136                         }
1137                         if (name) { /* want match by name */
1138                                 if ((!namelen && strcasecmp(c->name, name) && strcmp(c->uniqueid, name)) ||
1139                                     (namelen && strncasecmp(c->name, name, namelen)))
1140                                         continue;       /* name match failed */
1141                         } else if (exten) {
1142                                 if (context && strcasecmp(c->context, context) &&
1143                                     strcasecmp(c->macrocontext, context))
1144                                         continue;       /* context match failed */
1145                                 if (strcasecmp(c->exten, exten) &&
1146                                     strcasecmp(c->macroexten, exten))
1147                                         continue;       /* exten match failed */
1148                         }
1149                         /* if we get here, c points to the desired record */
1150                         break;
1151                 }
1152                 /* exit if chan not found or mutex acquired successfully */
1153                 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
1154                 done = c == NULL || ast_channel_trylock(c) == 0;
1155                 if (!done) {
1156                         ast_debug(1, "Avoiding %s for channel '%p'\n", msg, c);
1157                         if (retries == 199) {
1158                                 /* We are about to fail due to a deadlock, so report this
1159                                  * while we still have the list lock.
1160                                  */
1161                                 ast_debug(1, "Failure, could not lock '%p' after %d retries!\n", c, retries);
1162                                 /* As we have deadlocked, we will skip this channel and
1163                                  * see if there is another match.
1164                                  * NOTE: No point doing this for a full-name match,
1165                                  * as there can be no more matches.
1166                                  */
1167                                 if (!(name && !namelen)) {
1168                                         prev = c;
1169                                         retries = -1;
1170                                 }
1171                         }
1172                 }
1173                 AST_RWLIST_UNLOCK(&channels);
1174                 if (done)
1175                         return c;
1176                 /* If we reach this point we basically tried to lock a channel and failed. Instead of
1177                  * starting from the beginning of the list we can restore our saved pointer to the previous
1178                  * channel and start from there.
1179                  */
1180                 prev = _prev;
1181                 usleep(1);      /* give other threads a chance before retrying */
1182         }
1183
1184         return NULL;
1185 }
1186
1187 /*! \brief Browse channels in use */
1188 struct ast_channel *ast_channel_walk_locked(const struct ast_channel *prev)
1189 {
1190         return channel_find_locked(prev, NULL, 0, NULL, NULL);
1191 }
1192
1193 /*! \brief Get channel by name and lock it */
1194 struct ast_channel *ast_get_channel_by_name_locked(const char *name)
1195 {
1196         return channel_find_locked(NULL, name, 0, NULL, NULL);
1197 }
1198
1199 /*! \brief Get channel by name prefix and lock it */
1200 struct ast_channel *ast_get_channel_by_name_prefix_locked(const char *name, const int namelen)
1201 {
1202         return channel_find_locked(NULL, name, namelen, NULL, NULL);
1203 }
1204
1205 /*! \brief Get next channel by name prefix and lock it */
1206 struct ast_channel *ast_walk_channel_by_name_prefix_locked(const struct ast_channel *chan, const char *name,
1207                                                            const int namelen)
1208 {
1209         return channel_find_locked(chan, name, namelen, NULL, NULL);
1210 }
1211
1212 /*! \brief Get channel by exten (and optionally context) and lock it */
1213 struct ast_channel *ast_get_channel_by_exten_locked(const char *exten, const char *context)
1214 {
1215         return channel_find_locked(NULL, NULL, 0, context, exten);
1216 }
1217
1218 /*! \brief Get next channel by exten (and optionally context) and lock it */
1219 struct ast_channel *ast_walk_channel_by_exten_locked(const struct ast_channel *chan, const char *exten,
1220                                                      const char *context)
1221 {
1222         return channel_find_locked(chan, NULL, 0, context, exten);
1223 }
1224
1225 /*! \brief Wait, look for hangups and condition arg */
1226 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data)
1227 {
1228         struct ast_frame *f;
1229
1230         while (ms > 0) {
1231                 if (cond && ((*cond)(data) == 0))
1232                         return 0;
1233                 ms = ast_waitfor(chan, ms);
1234                 if (ms < 0)
1235                         return -1;
1236                 if (ms > 0) {
1237                         f = ast_read(chan);
1238                         if (!f)
1239                                 return -1;
1240                         ast_frfree(f);
1241                 }
1242         }
1243         return 0;
1244 }
1245
1246 /*! \brief Wait, look for hangups */
1247 int ast_safe_sleep(struct ast_channel *chan, int ms)
1248 {
1249         return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
1250 }
1251
1252 static void free_cid(struct ast_callerid *cid)
1253 {
1254         if (cid->cid_dnid)
1255                 ast_free(cid->cid_dnid);
1256         if (cid->cid_num)
1257                 ast_free(cid->cid_num);
1258         if (cid->cid_name)
1259                 ast_free(cid->cid_name);
1260         if (cid->cid_ani)
1261                 ast_free(cid->cid_ani);
1262         if (cid->cid_rdnis)
1263                 ast_free(cid->cid_rdnis);
1264         cid->cid_dnid = cid->cid_num = cid->cid_name = cid->cid_ani = cid->cid_rdnis = NULL;
1265 }
1266
1267 /*! \brief Free a channel structure */
1268 void ast_channel_free(struct ast_channel *chan)
1269 {
1270         int fd;
1271 #ifdef HAVE_EPOLL
1272         int i;
1273 #endif
1274         struct ast_var_t *vardata;
1275         struct ast_frame *f;
1276         struct varshead *headp;
1277         struct ast_datastore *datastore = NULL;
1278         char name[AST_CHANNEL_NAME];
1279
1280         headp=&chan->varshead;
1281
1282         AST_RWLIST_WRLOCK(&channels);
1283         if (!AST_RWLIST_REMOVE(&channels, chan, chan_list)) {
1284                 AST_RWLIST_UNLOCK(&channels);
1285                 ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
1286         }
1287         /* Lock and unlock the channel just to be sure nobody has it locked still
1288            due to a reference retrieved from the channel list. */
1289         ast_channel_lock(chan);
1290         ast_channel_unlock(chan);
1291
1292         /* Get rid of each of the data stores on the channel */
1293         while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
1294                 /* Free the data store */
1295                 ast_channel_datastore_free(datastore);
1296
1297         /* Lock and unlock the channel just to be sure nobody has it locked still
1298            due to a reference that was stored in a datastore. (i.e. app_chanspy) */
1299         ast_channel_lock(chan);
1300         ast_channel_unlock(chan);
1301
1302         if (chan->tech_pvt) {
1303                 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
1304                 ast_free(chan->tech_pvt);
1305         }
1306
1307         if (chan->sched)
1308                 sched_context_destroy(chan->sched);
1309
1310         ast_copy_string(name, chan->name, sizeof(name));
1311
1312         /* Stop monitoring */
1313         if (chan->monitor)
1314                 chan->monitor->stop( chan, 0 );
1315
1316         /* If there is native format music-on-hold state, free it */
1317         if (chan->music_state)
1318                 ast_moh_cleanup(chan);
1319
1320         /* Free translators */
1321         if (chan->readtrans)
1322                 ast_translator_free_path(chan->readtrans);
1323         if (chan->writetrans)
1324                 ast_translator_free_path(chan->writetrans);
1325         if (chan->pbx)
1326                 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
1327         free_cid(&chan->cid);
1328         /* Close pipes if appropriate */
1329         if ((fd = chan->alertpipe[0]) > -1)
1330                 close(fd);
1331         if ((fd = chan->alertpipe[1]) > -1)
1332                 close(fd);
1333         if ((fd = chan->timingfd) > -1)
1334                 close(fd);
1335 #ifdef HAVE_EPOLL
1336         for (i = 0; i < AST_MAX_FDS; i++) {
1337                 if (chan->epfd_data[i])
1338                         free(chan->epfd_data[i]);
1339         }
1340         close(chan->epfd);
1341 #endif
1342         while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
1343                 ast_frfree(f);
1344
1345         /* loop over the variables list, freeing all data and deleting list items */
1346         /* no need to lock the list, as the channel is already locked */
1347
1348         while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
1349                 ast_var_delete(vardata);
1350
1351         ast_app_group_discard(chan);
1352
1353         /* Destroy the jitterbuffer */
1354         ast_jb_destroy(chan);
1355
1356         ast_mutex_destroy(&chan->lock_dont_use);
1357
1358         ast_string_field_free_memory(chan);
1359         ast_free(chan);
1360         AST_RWLIST_UNLOCK(&channels);
1361
1362         ast_device_state_changed_literal(name);
1363 }
1364
1365 struct ast_datastore *ast_channel_datastore_alloc(const struct ast_datastore_info *info, const char *uid)
1366 {
1367         struct ast_datastore *datastore = NULL;
1368
1369         /* Make sure we at least have type so we can identify this */
1370         if (!info) {
1371                 return NULL;
1372         }
1373
1374         /* Allocate memory for datastore and clear it */
1375         datastore = ast_calloc(1, sizeof(*datastore));
1376         if (!datastore) {
1377                 return NULL;
1378         }
1379
1380         datastore->info = info;
1381
1382         datastore->uid = ast_strdup(uid);
1383
1384         return datastore;
1385 }
1386
1387 int ast_channel_datastore_free(struct ast_datastore *datastore)
1388 {
1389         int res = 0;
1390
1391         /* Using the destroy function (if present) destroy the data */
1392         if (datastore->info->destroy != NULL && datastore->data != NULL) {
1393                 datastore->info->destroy(datastore->data);
1394                 datastore->data = NULL;
1395         }
1396
1397         /* Free allocated UID memory */
1398         if (datastore->uid != NULL) {
1399                 ast_free((void *) datastore->uid);
1400                 datastore->uid = NULL;
1401         }
1402
1403         /* Finally free memory used by ourselves */
1404         ast_free(datastore);
1405
1406         return res;
1407 }
1408
1409 int ast_channel_datastore_inherit(struct ast_channel *from, struct ast_channel *to)
1410 {
1411         struct ast_datastore *datastore = NULL, *datastore2;
1412
1413         AST_LIST_TRAVERSE(&from->datastores, datastore, entry) {
1414                 if (datastore->inheritance > 0) {
1415                         datastore2 = ast_channel_datastore_alloc(datastore->info, datastore->uid);
1416                         if (datastore2) {
1417                                 datastore2->data = datastore->info->duplicate(datastore->data);
1418                                 datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
1419                                 AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry);
1420                         }
1421                 }
1422         }
1423         return 0;
1424 }
1425
1426 int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
1427 {
1428         int res = 0;
1429
1430         AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
1431
1432         return res;
1433 }
1434
1435 int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
1436 {
1437         return AST_LIST_REMOVE(&chan->datastores, datastore, entry) ? 0 : -1;
1438 }
1439
1440 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
1441 {
1442         struct ast_datastore *datastore = NULL;
1443
1444         if (info == NULL)
1445                 return NULL;
1446
1447         AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
1448                 if (datastore->info == info) {
1449                         if (uid != NULL && datastore->uid != NULL) {
1450                                 if (!strcasecmp(uid, datastore->uid)) {
1451                                         /* Matched by type AND uid */
1452                                         break;
1453                                 }
1454                         } else {
1455                                 /* Matched by type at least */
1456                                 break;
1457                         }
1458                 }
1459         }
1460         AST_LIST_TRAVERSE_SAFE_END
1461
1462         return datastore;
1463 }
1464
1465 /*! Set the file descriptor on the channel */
1466 void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
1467 {
1468 #ifdef HAVE_EPOLL
1469         struct epoll_event ev;
1470         struct ast_epoll_data *aed = NULL;
1471
1472         if (chan->fds[which] > -1) {
1473                 epoll_ctl(chan->epfd, EPOLL_CTL_DEL, chan->fds[which], &ev);
1474                 aed = chan->epfd_data[which];
1475         }
1476
1477         /* If this new fd is valid, add it to the epoll */
1478         if (fd > -1) {
1479                 if (!aed && (!(aed = ast_calloc(1, sizeof(*aed)))))
1480                         return;
1481
1482                 chan->epfd_data[which] = aed;
1483                 aed->chan = chan;
1484                 aed->which = which;
1485
1486                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1487                 ev.data.ptr = aed;
1488                 epoll_ctl(chan->epfd, EPOLL_CTL_ADD, fd, &ev);
1489         } else if (aed) {
1490                 /* We don't have to keep around this epoll data structure now */
1491                 free(aed);
1492                 chan->epfd_data[which] = NULL;
1493         }
1494 #endif
1495         chan->fds[which] = fd;
1496         return;
1497 }
1498
1499 /*! Add a channel to an optimized waitfor */
1500 void ast_poll_channel_add(struct ast_channel *chan0, struct ast_channel *chan1)
1501 {
1502 #ifdef HAVE_EPOLL
1503         struct epoll_event ev;
1504         int i = 0;
1505
1506         if (chan0->epfd == -1)
1507                 return;
1508
1509         /* Iterate through the file descriptors on chan1, adding them to chan0 */
1510         for (i = 0; i < AST_MAX_FDS; i++) {
1511                 if (chan1->fds[i] == -1)
1512                         continue;
1513                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1514                 ev.data.ptr = chan1->epfd_data[i];
1515                 epoll_ctl(chan0->epfd, EPOLL_CTL_ADD, chan1->fds[i], &ev);
1516         }
1517
1518 #endif
1519         return;
1520 }
1521
1522 /*! Delete a channel from an optimized waitfor */
1523 void ast_poll_channel_del(struct ast_channel *chan0, struct ast_channel *chan1)
1524 {
1525 #ifdef HAVE_EPOLL
1526         struct epoll_event ev;
1527         int i = 0;
1528
1529         if (chan0->epfd == -1)
1530                 return;
1531
1532         for (i = 0; i < AST_MAX_FDS; i++) {
1533                 if (chan1->fds[i] == -1)
1534                         continue;
1535                 epoll_ctl(chan0->epfd, EPOLL_CTL_DEL, chan1->fds[i], &ev);
1536         }
1537
1538 #endif
1539         return;
1540 }
1541
1542 /*! \brief Softly hangup a channel, don't lock */
1543 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
1544 {
1545         ast_debug(1, "Soft-Hanging up channel '%s'\n", chan->name);
1546         /* Inform channel driver that we need to be hung up, if it cares */
1547         chan->_softhangup |= cause;
1548         ast_queue_frame(chan, &ast_null_frame);
1549         /* Interrupt any poll call or such */
1550         if (ast_test_flag(chan, AST_FLAG_BLOCKING))
1551                 pthread_kill(chan->blocker, SIGURG);
1552         return 0;
1553 }
1554
1555 /*! \brief Softly hangup a channel, lock */
1556 int ast_softhangup(struct ast_channel *chan, int cause)
1557 {
1558         int res;
1559         ast_channel_lock(chan);
1560         res = ast_softhangup_nolock(chan, cause);
1561         ast_channel_unlock(chan);
1562         return res;
1563 }
1564
1565 static void free_translation(struct ast_channel *clone)
1566 {
1567         if (clone->writetrans)
1568                 ast_translator_free_path(clone->writetrans);
1569         if (clone->readtrans)
1570                 ast_translator_free_path(clone->readtrans);
1571         clone->writetrans = NULL;
1572         clone->readtrans = NULL;
1573         clone->rawwriteformat = clone->nativeformats;
1574         clone->rawreadformat = clone->nativeformats;
1575 }
1576
1577 /*! \brief Hangup a channel */
1578 int ast_hangup(struct ast_channel *chan)
1579 {
1580         int res = 0;
1581         struct ast_cdr *cdr = NULL;
1582
1583         /* Don't actually hang up a channel that will masquerade as someone else, or
1584            if someone is going to masquerade as us */
1585         ast_channel_lock(chan);
1586
1587         if (chan->audiohooks) {
1588                 ast_audiohook_detach_list(chan->audiohooks);
1589                 chan->audiohooks = NULL;
1590         }
1591
1592         ast_autoservice_stop(chan);
1593
1594         if (chan->masq) {
1595                 if (ast_do_masquerade(chan))
1596                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1597         }
1598
1599         if (chan->masq) {
1600                 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
1601                 ast_channel_unlock(chan);
1602                 return 0;
1603         }
1604         /* If this channel is one which will be masqueraded into something,
1605            mark it as a zombie already, so we know to free it later */
1606         if (chan->masqr) {
1607                 ast_set_flag(chan, AST_FLAG_ZOMBIE);
1608                 ast_channel_unlock(chan);
1609                 return 0;
1610         }
1611         free_translation(chan);
1612         /* Close audio stream */
1613         if (chan->stream) {
1614                 ast_closestream(chan->stream);
1615                 chan->stream = NULL;
1616         }
1617         /* Close video stream */
1618         if (chan->vstream) {
1619                 ast_closestream(chan->vstream);
1620                 chan->vstream = NULL;
1621         }
1622         if (chan->sched) {
1623                 sched_context_destroy(chan->sched);
1624                 chan->sched = NULL;
1625         }
1626
1627         if (chan->generatordata)        /* Clear any tone stuff remaining */
1628                 if (chan->generator && chan->generator->release)
1629                         chan->generator->release(chan, chan->generatordata);
1630         chan->generatordata = NULL;
1631         chan->generator = NULL;
1632         if (chan->cdr) {                /* End the CDR if it hasn't already */
1633                 ast_cdr_end(chan->cdr);
1634                 cdr = chan->cdr;
1635                 chan->cdr = NULL;
1636         }
1637         if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1638                 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
1639                                         "is blocked by thread %ld in procedure %s!  Expect a failure\n",
1640                                         (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
1641                 ast_assert(0);
1642         }
1643         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
1644                 ast_debug(1, "Hanging up channel '%s'\n", chan->name);
1645                 if (chan->tech->hangup)
1646                         res = chan->tech->hangup(chan);
1647         } else {
1648                 ast_debug(1, "Hanging up zombie '%s'\n", chan->name);
1649         }
1650
1651         ast_channel_unlock(chan);
1652         manager_event(EVENT_FLAG_CALL, "Hangup",
1653                         "Channel: %s\r\n"
1654                         "Uniqueid: %s\r\n"
1655                         "CallerIDNum: %s\r\n"
1656                         "CallerIDName: %s\r\n"
1657                         "Cause: %d\r\n"
1658                         "Cause-txt: %s\r\n",
1659                         chan->name,
1660                         chan->uniqueid,
1661                         S_OR(chan->cid.cid_num, "<unknown>"),
1662                         S_OR(chan->cid.cid_name, "<unknown>"),
1663                         chan->hangupcause,
1664                         ast_cause2str(chan->hangupcause)
1665                         );
1666         ast_channel_free(chan);
1667
1668         if (cdr)
1669                 ast_cdr_detach(cdr);
1670
1671         return res;
1672 }
1673
1674 int __ast_answer(struct ast_channel *chan, unsigned int delay)
1675 {
1676         int res = 0;
1677
1678         ast_channel_lock(chan);
1679
1680         /* You can't answer an outbound call */
1681         if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
1682                 ast_channel_unlock(chan);
1683                 return 0;
1684         }
1685
1686         /* Stop if we're a zombie or need a soft hangup */
1687         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1688                 ast_channel_unlock(chan);
1689                 return -1;
1690         }
1691
1692         switch (chan->_state) {
1693         case AST_STATE_RINGING:
1694         case AST_STATE_RING:
1695                 if (chan->tech->answer)
1696                         res = chan->tech->answer(chan);
1697                 ast_setstate(chan, AST_STATE_UP);
1698                 ast_cdr_answer(chan->cdr);
1699                 ast_channel_unlock(chan);
1700                 if (delay)
1701                         ast_safe_sleep(chan, delay);
1702                 return res;
1703                 break;
1704         case AST_STATE_UP:
1705                 ast_cdr_answer(chan->cdr);
1706                 break;
1707         default:
1708                 break;
1709         }
1710         chan->visible_indication = 0;
1711         ast_channel_unlock(chan);
1712
1713         return res;
1714 }
1715
1716 int ast_answer(struct ast_channel *chan)
1717 {
1718         return __ast_answer(chan, 500);
1719 }
1720
1721 void ast_deactivate_generator(struct ast_channel *chan)
1722 {
1723         ast_channel_lock(chan);
1724         if (chan->generatordata) {
1725                 if (chan->generator && chan->generator->release)
1726                         chan->generator->release(chan, chan->generatordata);
1727                 chan->generatordata = NULL;
1728                 chan->generator = NULL;
1729                 ast_channel_set_fd(chan, AST_GENERATOR_FD, -1);
1730                 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1731                 ast_settimeout(chan, 0, NULL, NULL);
1732         }
1733         ast_channel_unlock(chan);
1734 }
1735
1736 static int generator_force(const void *data)
1737 {
1738         /* Called if generator doesn't have data */
1739         void *tmp;
1740         int res;
1741         int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL;
1742         struct ast_channel *chan = (struct ast_channel *)data;
1743
1744         ast_channel_lock(chan);
1745         tmp = chan->generatordata;
1746         chan->generatordata = NULL;
1747         if (chan->generator)
1748                 generate = chan->generator->generate;
1749         ast_channel_unlock(chan);
1750
1751         if (!tmp || !generate)
1752                 return 0;
1753
1754         res = generate(chan, tmp, 0, ast_format_rate(chan->writeformat & AST_FORMAT_AUDIO_MASK) / 50);
1755
1756         chan->generatordata = tmp;
1757
1758         if (res) {
1759                 ast_debug(1, "Auto-deactivating generator\n");
1760                 ast_deactivate_generator(chan);
1761         }
1762
1763         return 0;
1764 }
1765
1766 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1767 {
1768         int res = 0;
1769
1770         ast_channel_lock(chan);
1771
1772         if (chan->generatordata) {
1773                 if (chan->generator && chan->generator->release)
1774                         chan->generator->release(chan, chan->generatordata);
1775                 chan->generatordata = NULL;
1776         }
1777
1778         ast_prod(chan);
1779         if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1780                 res = -1;
1781         }
1782
1783         if (!res) {
1784                 ast_settimeout(chan, 160, generator_force, chan);
1785                 chan->generator = gen;
1786         }
1787
1788         ast_channel_unlock(chan);
1789
1790         return res;
1791 }
1792
1793 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1794 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1795 {
1796         int winner = -1;
1797         ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1798         return winner;
1799 }
1800
1801 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1802 #ifdef HAVE_EPOLL
1803 static struct ast_channel *ast_waitfor_nandfds_classic(struct ast_channel **c, int n, int *fds, int nfds,
1804                                         int *exception, int *outfd, int *ms)
1805 #else
1806 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1807                                         int *exception, int *outfd, int *ms)
1808 #endif
1809 {
1810         struct timeval start = { 0 , 0 };
1811         struct pollfd *pfds = NULL;
1812         int res;
1813         long rms;
1814         int x, y, max;
1815         int sz;
1816         struct timeval now = { 0, 0 };
1817         struct timeval whentohangup = { 0, 0 }, diff;
1818         struct ast_channel *winner = NULL;
1819         struct fdmap {
1820                 int chan;
1821                 int fdno;
1822         } *fdmap = NULL;
1823
1824         if ((sz = n * AST_MAX_FDS + nfds)) {
1825                 pfds = alloca(sizeof(*pfds) * sz);
1826                 fdmap = alloca(sizeof(*fdmap) * sz);
1827         }
1828
1829         if (outfd)
1830                 *outfd = -99999;
1831         if (exception)
1832                 *exception = 0;
1833
1834         /* Perform any pending masquerades */
1835         for (x = 0; x < n; x++) {
1836                 ast_channel_lock(c[x]);
1837                 if (c[x]->masq && ast_do_masquerade(c[x])) {
1838                         ast_log(LOG_WARNING, "Masquerade failed\n");
1839                         *ms = -1;
1840                         ast_channel_unlock(c[x]);
1841                         return NULL;
1842                 }
1843                 if (!ast_tvzero(c[x]->whentohangup)) {
1844                         if (ast_tvzero(whentohangup))
1845                                 now = ast_tvnow();
1846                         diff = ast_tvsub(c[x]->whentohangup, now);
1847                         if (diff.tv_sec < 0 || ast_tvzero(diff)) {
1848                                 /* Should already be hungup */
1849                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1850                                 ast_channel_unlock(c[x]);
1851                                 return c[x];
1852                         }
1853                         if (ast_tvzero(whentohangup) || ast_tvcmp(diff, whentohangup) < 0)
1854                                 whentohangup = diff;
1855                 }
1856                 ast_channel_unlock(c[x]);
1857         }
1858         /* Wait full interval */
1859         rms = *ms;
1860         if (!ast_tvzero(whentohangup)) {
1861                 rms = whentohangup.tv_sec * 1000 + whentohangup.tv_usec / 1000;              /* timeout in milliseconds */
1862                 if (*ms >= 0 && *ms < rms)              /* original *ms still smaller */
1863                         rms =  *ms;
1864         }
1865         /*
1866          * Build the pollfd array, putting the channels' fds first,
1867          * followed by individual fds. Order is important because
1868          * individual fd's must have priority over channel fds.
1869          */
1870         max = 0;
1871         for (x = 0; x < n; x++) {
1872                 for (y = 0; y < AST_MAX_FDS; y++) {
1873                         fdmap[max].fdno = y;  /* fd y is linked to this pfds */
1874                         fdmap[max].chan = x;  /* channel x is linked to this pfds */
1875                         max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1876                 }
1877                 CHECK_BLOCKING(c[x]);
1878         }
1879         /* Add the individual fds */
1880         for (x = 0; x < nfds; x++) {
1881                 fdmap[max].chan = -1;
1882                 max += ast_add_fd(&pfds[max], fds[x]);
1883         }
1884
1885         if (*ms > 0)
1886                 start = ast_tvnow();
1887
1888         if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1889                 do {
1890                         int kbrms = rms;
1891                         if (kbrms > 600000)
1892                                 kbrms = 600000;
1893                         res = poll(pfds, max, kbrms);
1894                         if (!res)
1895                                 rms -= kbrms;
1896                 } while (!res && (rms > 0));
1897         } else {
1898                 res = poll(pfds, max, rms);
1899         }
1900         for (x = 0; x < n; x++)
1901                 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1902         if (res < 0) { /* Simulate a timeout if we were interrupted */
1903                 if (errno != EINTR)
1904                         *ms = -1;
1905                 return NULL;
1906         }
1907         if (!ast_tvzero(whentohangup)) {   /* if we have a timeout, check who expired */
1908                 now = ast_tvnow();
1909                 for (x = 0; x < n; x++) {
1910                         if (!ast_tvzero(c[x]->whentohangup) && ast_tvcmp(c[x]->whentohangup, now) <= 0) {
1911                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1912                                 if (winner == NULL)
1913                                         winner = c[x];
1914                         }
1915                 }
1916         }
1917         if (res == 0) { /* no fd ready, reset timeout and done */
1918                 *ms = 0;        /* XXX use 0 since we may not have an exact timeout. */
1919                 return winner;
1920         }
1921         /*
1922          * Then check if any channel or fd has a pending event.
1923          * Remember to check channels first and fds last, as they
1924          * must have priority on setting 'winner'
1925          */
1926         for (x = 0; x < max; x++) {
1927                 res = pfds[x].revents;
1928                 if (res == 0)
1929                         continue;
1930                 if (fdmap[x].chan >= 0) {       /* this is a channel */
1931                         winner = c[fdmap[x].chan];      /* override previous winners */
1932                         if (res & POLLPRI)
1933                                 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1934                         else
1935                                 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1936                         winner->fdno = fdmap[x].fdno;
1937                 } else {                        /* this is an fd */
1938                         if (outfd)
1939                                 *outfd = pfds[x].fd;
1940                         if (exception)
1941                                 *exception = (res & POLLPRI) ? -1 : 0;
1942                         winner = NULL;
1943                 }
1944         }
1945         if (*ms > 0) {
1946                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1947                 if (*ms < 0)
1948                         *ms = 0;
1949         }
1950         return winner;
1951 }
1952
1953 #ifdef HAVE_EPOLL
1954 static struct ast_channel *ast_waitfor_nandfds_simple(struct ast_channel *chan, int *ms)
1955 {
1956         struct timeval start = { 0 , 0 };
1957         int res = 0;
1958         struct epoll_event ev[1];
1959         long diff, rms = *ms;
1960         struct ast_channel *winner = NULL;
1961         struct ast_epoll_data *aed = NULL;
1962
1963         ast_channel_lock(chan);
1964
1965         /* See if this channel needs to be masqueraded */
1966         if (chan->masq && ast_do_masquerade(chan)) {
1967                 ast_log(LOG_WARNING, "Failed to perform masquerade on %s\n", chan->name);
1968                 *ms = -1;
1969                 ast_channel_unlock(chan);
1970                 return NULL;
1971         }
1972
1973         /* Figure out their timeout */
1974         if (!ast_tvzero(chan->whentohangup)) {
1975                 if ((diff = ast_tvdiff_ms(chan->whentohangup, ast_tvnow())) < 0) {
1976                         /* They should already be hungup! */
1977                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1978                         ast_channel_unlock(chan);
1979                         return NULL;
1980                 }
1981                 /* If this value is smaller then the current one... make it priority */
1982                 if (rms > diff)
1983                         rms = diff;
1984         }
1985
1986         ast_channel_unlock(chan);
1987
1988         /* Time to make this channel block... */
1989         CHECK_BLOCKING(chan);
1990
1991         if (*ms > 0)
1992                 start = ast_tvnow();
1993
1994         /* We don't have to add any file descriptors... they are already added, we just have to wait! */
1995         res = epoll_wait(chan->epfd, ev, 1, rms);
1996
1997         /* Stop blocking */
1998         ast_clear_flag(chan, AST_FLAG_BLOCKING);
1999
2000         /* Simulate a timeout if we were interrupted */
2001         if (res < 0) {
2002                 if (errno != EINTR)
2003                         *ms = -1;
2004                 return NULL;
2005         }
2006
2007         /* If this channel has a timeout see if it expired */
2008         if (!ast_tvzero(chan->whentohangup)) {
2009                 if (ast_tvdiff_ms(ast_tvnow(), chan->whentohangup) >= 0) {
2010                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2011                         winner = chan;
2012                 }
2013         }
2014
2015         /* No fd ready, reset timeout and be done for now */
2016         if (!res) {
2017                 *ms = 0;
2018                 return winner;
2019         }
2020
2021         /* See what events are pending */
2022         aed = ev[0].data.ptr;
2023         chan->fdno = aed->which;
2024         if (ev[0].events & EPOLLPRI)
2025                 ast_set_flag(chan, AST_FLAG_EXCEPTION);
2026         else
2027                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2028
2029         if (*ms > 0) {
2030                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
2031                 if (*ms < 0)
2032                         *ms = 0;
2033         }
2034
2035         return chan;
2036 }
2037
2038 static struct ast_channel *ast_waitfor_nandfds_complex(struct ast_channel **c, int n, int *ms)
2039 {
2040         struct timeval start = { 0 , 0 };
2041         int res = 0, i;
2042         struct epoll_event ev[25] = { { 0, } };
2043         struct timeval now = { 0, 0 };
2044         long whentohangup = 0, diff = 0, rms = *ms;
2045         struct ast_channel *winner = NULL;
2046
2047         for (i = 0; i < n; i++) {
2048                 ast_channel_lock(c[i]);
2049                 if (c[i]->masq && ast_do_masquerade(c[i])) {
2050                         ast_log(LOG_WARNING, "Masquerade failed\n");
2051                         *ms = -1;
2052                         ast_channel_unlock(c[i]);
2053                         return NULL;
2054                 }
2055                 if (!ast_tvzero(c[i]->whentohangup)) {
2056                         if (whentohangup == 0)
2057                                 now = ast_tvnow();
2058                         if ((diff = ast_tvdiff_ms(c[i]->whentohangup, now)) < 0) {
2059                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2060                                 ast_channel_unlock(c[i]);
2061                                 return c[i];
2062                         }
2063                         if (!whentohangup || whentohangup > diff)
2064                                 whentohangup = diff;
2065                 }
2066                 ast_channel_unlock(c[i]);
2067                 CHECK_BLOCKING(c[i]);
2068         }
2069
2070         rms = *ms;
2071         if (whentohangup) {
2072                 rms = whentohangup;
2073                 if (*ms >= 0 && *ms < rms)
2074                         rms = *ms;
2075         }
2076
2077         if (*ms > 0)
2078                 start = ast_tvnow();
2079
2080         res = epoll_wait(c[0]->epfd, ev, 25, rms);
2081
2082         for (i = 0; i < n; i++)
2083                 ast_clear_flag(c[i], AST_FLAG_BLOCKING);
2084
2085         if (res < 0) {
2086                 if (errno != EINTR)
2087                         *ms = -1;
2088                 return NULL;
2089         }
2090
2091         if (whentohangup) {
2092                 now = ast_tvnow();
2093                 for (i = 0; i < n; i++) {
2094                         if (!ast_tvzero(c[i]->whentohangup) && ast_tvdiff_ms(now, c[i]->whentohangup) >= 0) {
2095                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2096                                 if (!winner)
2097                                         winner = c[i];
2098                         }
2099                 }
2100         }
2101
2102         if (!res) {
2103                 *ms = 0;
2104                 return winner;
2105         }
2106
2107         for (i = 0; i < res; i++) {
2108                 struct ast_epoll_data *aed = ev[i].data.ptr;
2109
2110                 if (!ev[i].events || !aed)
2111                         continue;
2112
2113                 winner = aed->chan;
2114                 if (ev[i].events & EPOLLPRI)
2115                         ast_set_flag(winner, AST_FLAG_EXCEPTION);
2116                 else
2117                         ast_clear_flag(winner, AST_FLAG_EXCEPTION);
2118                 winner->fdno = aed->which;
2119         }
2120
2121         if (*ms > 0) {
2122                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
2123                 if (*ms < 0)
2124                         *ms = 0;
2125         }
2126
2127         return winner;
2128 }
2129
2130 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
2131                                         int *exception, int *outfd, int *ms)
2132 {
2133         /* Clear all provided values in one place. */
2134         if (outfd)
2135                 *outfd = -99999;
2136         if (exception)
2137                 *exception = 0;
2138
2139         /* If no epoll file descriptor is available resort to classic nandfds */
2140         if (!n || nfds || c[0]->epfd == -1)
2141                 return ast_waitfor_nandfds_classic(c, n, fds, nfds, exception, outfd, ms);
2142         else if (!nfds && n == 1)
2143                 return ast_waitfor_nandfds_simple(c[0], ms);
2144         else
2145                 return ast_waitfor_nandfds_complex(c, n, ms);
2146 }
2147 #endif
2148
2149 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
2150 {
2151         return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
2152 }
2153
2154 int ast_waitfor(struct ast_channel *c, int ms)
2155 {
2156         int oldms = ms; /* -1 if no timeout */
2157
2158         ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
2159         if ((ms < 0) && (oldms < 0))
2160                 ms = 0;
2161         return ms;
2162 }
2163
2164 /* XXX never to be called with ms = -1 */
2165 int ast_waitfordigit(struct ast_channel *c, int ms)
2166 {
2167         return ast_waitfordigit_full(c, ms, -1, -1);
2168 }
2169
2170 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(const void *data), void *data)
2171 {
2172         int res = -1;
2173 #ifdef HAVE_ZAPTEL
2174         if (c->timingfd > -1) {
2175                 if (!func) {
2176                         samples = 0;
2177                         data = 0;
2178                 }
2179                 ast_debug(1, "Scheduling timer at %d sample intervals\n", samples);
2180                 res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
2181                 c->timingfunc = func;
2182                 c->timingdata = data;
2183         }
2184 #endif
2185         return res;
2186 }
2187
2188 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
2189 {
2190         /* Stop if we're a zombie or need a soft hangup */
2191         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
2192                 return -1;
2193
2194         /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
2195         ast_set_flag(c, AST_FLAG_END_DTMF_ONLY);
2196
2197         /* Wait for a digit, no more than ms milliseconds total. */
2198
2199         while (ms) {
2200                 struct ast_channel *rchan;
2201                 int outfd=-1;
2202
2203                 errno = 0;
2204                 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
2205
2206                 if (!rchan && outfd < 0 && ms) {
2207                         if (errno == 0 || errno == EINTR)
2208                                 continue;
2209                         ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
2210                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2211                         return -1;
2212                 } else if (outfd > -1) {
2213                         /* The FD we were watching has something waiting */
2214                         ast_log(LOG_WARNING, "The FD we were waiting for has something waiting. Waitfordigit returning numeric 1\n");
2215                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2216                         return 1;
2217                 } else if (rchan) {
2218                         int res;
2219                         struct ast_frame *f = ast_read(c);
2220                         if (!f)
2221                                 return -1;
2222
2223                         switch (f->frametype) {
2224                         case AST_FRAME_DTMF_BEGIN:
2225                                 break;
2226                         case AST_FRAME_DTMF_END:
2227                                 res = f->subclass;
2228                                 ast_frfree(f);
2229                                 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2230                                 return res;
2231                         case AST_FRAME_CONTROL:
2232                                 switch (f->subclass) {
2233                                 case AST_CONTROL_HANGUP:
2234                                         ast_frfree(f);
2235                                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2236                                         return -1;
2237                                 case AST_CONTROL_RINGING:
2238                                 case AST_CONTROL_ANSWER:
2239                                 case AST_CONTROL_SRCUPDATE:
2240                                         /* Unimportant */
2241                                         break;
2242                                 default:
2243                                         ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
2244                                         break;
2245                                 }
2246                                 break;
2247                         case AST_FRAME_VOICE:
2248                                 /* Write audio if appropriate */
2249                                 if (audiofd > -1)
2250                                         write(audiofd, f->data.ptr, f->datalen);
2251                         default:
2252                                 /* Ignore */
2253                                 break;
2254                         }
2255                         ast_frfree(f);
2256                 }
2257         }
2258
2259         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2260
2261         return 0; /* Time is up */
2262 }
2263
2264 static void send_dtmf_event(const struct ast_channel *chan, const char *direction, const char digit, const char *begin, const char *end)
2265 {
2266         manager_event(EVENT_FLAG_DTMF,
2267                         "DTMF",
2268                         "Channel: %s\r\n"
2269                         "Uniqueid: %s\r\n"
2270                         "Digit: %c\r\n"
2271                         "Direction: %s\r\n"
2272                         "Begin: %s\r\n"
2273                         "End: %s\r\n",
2274                         chan->name, chan->uniqueid, digit, direction, begin, end);
2275 }
2276
2277 static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
2278 {
2279         if (chan->generatordata &&  !ast_internal_timing_enabled(chan)) {
2280                 void *tmp = chan->generatordata;
2281                 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL;
2282                 int res;
2283                 int samples;
2284
2285                 if (chan->timingfunc) {
2286                         ast_debug(1, "Generator got voice, switching to phase locked mode\n");
2287                         ast_settimeout(chan, 0, NULL, NULL);
2288                 }
2289
2290                 chan->generatordata = NULL;     /* reset, to let writes go through */
2291
2292                 if (f->subclass != chan->writeformat) {
2293                         float factor;
2294                         factor = ((float) ast_format_rate(chan->writeformat)) / ((float) ast_format_rate(f->subclass));
2295                         samples = (int) ( ((float) f->samples) * factor );
2296                 } else {
2297                         samples = f->samples;
2298                 }
2299
2300                 if (chan->generator->generate) {
2301                         generate = chan->generator->generate;
2302                 }
2303                 /* This unlock is here based on two assumptions that hold true at this point in the
2304                  * code. 1) this function is only called from within __ast_read() and 2) all generators
2305                  * call ast_write() in their generate callback.
2306                  *
2307                  * The reason this is added is so that when ast_write is called, the lock that occurs
2308                  * there will not recursively lock the channel. Doing this will cause intended deadlock
2309                  * avoidance not to work in deeper functions
2310                  */
2311                 ast_channel_unlock(chan);
2312                 res = generate(chan, tmp, f->datalen, samples);
2313                 ast_channel_lock(chan);
2314                 chan->generatordata = tmp;
2315                 if (res) {
2316                         ast_debug(1, "Auto-deactivating generator\n");
2317                         ast_deactivate_generator(chan);
2318                 }
2319
2320         } else if (f->frametype == AST_FRAME_CNG) {
2321                 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
2322                         ast_debug(1, "Generator got CNG, switching to timed mode\n");
2323                         ast_settimeout(chan, 160, generator_force, chan);
2324                 }
2325         }
2326 }
2327
2328 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
2329 {
2330         struct ast_frame *f = NULL;     /* the return value */
2331         int blah;
2332         int prestate;
2333         int count = 0, cause = 0;
2334
2335         /* this function is very long so make sure there is only one return
2336          * point at the end (there are only two exceptions to this).
2337          */
2338         while(ast_channel_trylock(chan)) {
2339                 if(count++ > 10)
2340                         /*cannot goto done since the channel is not locked*/
2341                         return &ast_null_frame;
2342                 usleep(1);
2343         }
2344
2345         if (chan->masq) {
2346                 if (ast_do_masquerade(chan))
2347                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2348                 else
2349                         f =  &ast_null_frame;
2350                 goto done;
2351         }
2352
2353         /* Stop if we're a zombie or need a soft hangup */
2354         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2355                 if (chan->generator)
2356                         ast_deactivate_generator(chan);
2357                 goto done;
2358         }
2359         prestate = chan->_state;
2360
2361         if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) &&
2362             !ast_strlen_zero(chan->dtmfq) &&
2363                 (ast_tvzero(chan->dtmf_tv) || ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) > AST_MIN_DTMF_GAP) ) {
2364                 /* We have DTMF that has been deferred.  Return it now */
2365                 chan->dtmff.subclass = chan->dtmfq[0];
2366                 /* Drop first digit from the buffer */
2367                 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
2368                 f = &chan->dtmff;
2369                 if (ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
2370                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2371                         chan->dtmff.frametype = AST_FRAME_DTMF_END;
2372                 } else {
2373                         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);
2374                         chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
2375                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2376                         chan->emulate_dtmf_digit = f->subclass;
2377                         chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2378                 }
2379                 chan->dtmf_tv = ast_tvnow();
2380                 goto done;
2381         }
2382
2383         /* Read and ignore anything on the alertpipe, but read only
2384            one sizeof(blah) per frame that we send from it */
2385         if (chan->alertpipe[0] > -1)
2386                 read(chan->alertpipe[0], &blah, sizeof(blah));
2387
2388 #ifdef HAVE_ZAPTEL
2389         if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2390                 int res;
2391
2392                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2393                 blah = -1;
2394                 /* IF we can't get event, assume it's an expired as-per the old interface */
2395                 res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
2396                 if (res)
2397                         blah = ZT_EVENT_TIMER_EXPIRED;
2398
2399                 if (blah == ZT_EVENT_TIMER_PING) {
2400                         if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
2401                                 /* Acknowledge PONG unless we need it again */
2402                                 if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
2403                                         ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
2404                                 }
2405                         }
2406                 } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
2407                         ioctl(chan->timingfd, ZT_TIMERACK, &blah);
2408                         if (chan->timingfunc) {
2409                                 /* save a copy of func/data before unlocking the channel */
2410                                 int (*func)(const void *) = chan->timingfunc;
2411                                 void *data = chan->timingdata;
2412                                 ast_channel_unlock(chan);
2413                                 func(data);
2414                         } else {
2415                                 blah = 0;
2416                                 ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
2417                                 chan->timingdata = NULL;
2418                                 ast_channel_unlock(chan);
2419                         }
2420                         /* cannot 'goto done' because the channel is already unlocked */
2421                         return &ast_null_frame;
2422                 } else
2423                         ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
2424         } else
2425 #endif
2426         if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
2427                 /* if the AST_GENERATOR_FD is set, call the generator with args
2428                  * set to -1 so it can do whatever it needs to.
2429                  */
2430                 void *tmp = chan->generatordata;
2431                 chan->generatordata = NULL;     /* reset to let ast_write get through */
2432                 chan->generator->generate(chan, tmp, -1, -1);
2433                 chan->generatordata = tmp;
2434                 f = &ast_null_frame;
2435                 goto done;
2436         }
2437
2438         /* Check for pending read queue */
2439         if (!AST_LIST_EMPTY(&chan->readq)) {
2440                 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
2441                 /* Interpret hangup and return NULL */
2442                 /* XXX why not the same for frames from the channel ? */
2443                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
2444                         cause = f->data.uint32;
2445                         ast_frfree(f);
2446                         f = NULL;
2447                 }
2448         } else {
2449                 chan->blocker = pthread_self();
2450                 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2451                         if (chan->tech->exception)
2452                                 f = chan->tech->exception(chan);
2453                         else {
2454                                 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
2455                                 f = &ast_null_frame;
2456                         }
2457                         /* Clear the exception flag */
2458                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2459                 } else if (chan->tech->read)
2460                         f = chan->tech->read(chan);
2461                 else
2462                         ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
2463         }
2464
2465         if (f) {
2466                 /* if the channel driver returned more than one frame, stuff the excess
2467                    into the readq for the next ast_read call (note that we can safely assume
2468                    that the readq is empty, because otherwise we would not have called into
2469                    the channel driver and f would be only a single frame)
2470                 */
2471                 if (AST_LIST_NEXT(f, frame_list)) {
2472                         AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
2473                         AST_LIST_NEXT(f, frame_list) = NULL;
2474                 }
2475
2476                 switch (f->frametype) {
2477                 case AST_FRAME_CONTROL:
2478                         if (f->subclass == AST_CONTROL_ANSWER) {
2479                                 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
2480                                         ast_debug(1, "Ignoring answer on an inbound call!\n");
2481                                         ast_frfree(f);
2482                                         f = &ast_null_frame;
2483                                 } else if (prestate == AST_STATE_UP) {
2484                                         ast_debug(1, "Dropping duplicate answer!\n");
2485                                         ast_frfree(f);
2486                                         f = &ast_null_frame;
2487                                 } else {
2488                                         /* Answer the CDR */
2489                                         ast_setstate(chan, AST_STATE_UP);
2490                                         if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
2491                                                                                  to keep from throwing off the basic order of the universe,
2492                                                                                  we will try to keep this cdr from getting posted. */
2493                                                 chan->cdr = ast_cdr_alloc();
2494                                                 ast_cdr_init(chan->cdr, chan);
2495                                                 ast_cdr_start(chan->cdr);
2496                                         }
2497
2498                                         ast_cdr_answer(chan->cdr);
2499                                 }
2500                         }
2501                         break;
2502                 case AST_FRAME_DTMF_END:
2503                         send_dtmf_event(chan, "Received", f->subclass, "No", "Yes");
2504                         ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass, chan->name, f->len);
2505                         /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2506                          * However, only let emulation be forced if the other end cares about BEGIN frames */
2507                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF) ||
2508                                 (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) ) {
2509                                 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2510                                         ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2511                                         chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2512                                 } else
2513                                         ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2514                                 ast_frfree(f);
2515                                 f = &ast_null_frame;
2516                         } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) {
2517                                 if (!ast_tvzero(chan->dtmf_tv) &&
2518                                     ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) {
2519                                         /* If it hasn't been long enough, defer this digit */
2520                                         if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2521                                                 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2522                                                 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2523                                         } else
2524                                                 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2525                                         ast_frfree(f);
2526                                         f = &ast_null_frame;
2527                                 } else {
2528                                         /* There was no begin, turn this into a begin and send the end later */
2529                                         f->frametype = AST_FRAME_DTMF_BEGIN;
2530                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2531                                         chan->emulate_dtmf_digit = f->subclass;
2532                                         chan->dtmf_tv = ast_tvnow();
2533                                         if (f->len) {
2534                                                 if (f->len > AST_MIN_DTMF_DURATION)
2535                                                         chan->emulate_dtmf_duration = f->len;
2536                                                 else
2537                                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION;
2538                                         } else
2539                                                 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2540                                         ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass, chan->emulate_dtmf_duration, chan->name);
2541                                 }
2542                                 if (chan->audiohooks) {
2543                                         struct ast_frame *old_frame = f;
2544                                         /*!
2545                                          * \todo XXX It is possible to write a digit to the audiohook twice
2546                                          * if the digit was originally read while the channel was in autoservice. */
2547                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2548                                         if (old_frame != f)
2549                                                 ast_frfree(old_frame);
2550                                 }
2551                         } else {
2552                                 struct timeval now = ast_tvnow();
2553                                 if (ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2554                                         ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass, chan->name);
2555                                         ast_clear_flag(chan, AST_FLAG_IN_DTMF);
2556                                         if (!f->len)
2557                                                 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2558                                 } else if (!f->len) {
2559                                         ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass, chan->name);
2560                                         f->len = AST_MIN_DTMF_DURATION;
2561                                 }
2562                                 if (f->len < AST_MIN_DTMF_DURATION) {
2563                                         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);
2564                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2565                                         chan->emulate_dtmf_digit = f->subclass;
2566                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len;
2567                                         ast_frfree(f);
2568                                         f = &ast_null_frame;
2569                                 } else {
2570                                         ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass, chan->name);
2571                                         chan->dtmf_tv = now;
2572                                 }
2573                                 if (chan->audiohooks) {
2574                                         struct ast_frame *old_frame = f;
2575                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2576                                         if (old_frame != f)
2577                                                 ast_frfree(old_frame);
2578                                 }
2579                         }
2580                         break;
2581                 case AST_FRAME_DTMF_BEGIN:
2582                         send_dtmf_event(chan, "Received", f->subclass, "Yes", "No");
2583                         ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2584                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY | AST_FLAG_EMULATE_DTMF) ||
2585                             (!ast_tvzero(chan->dtmf_tv) &&
2586                               ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) {
2587                                 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass, chan->name);
2588                                 ast_frfree(f);
2589                                 f = &ast_null_frame;
2590                         } else {
2591                                 ast_set_flag(chan, AST_FLAG_IN_DTMF);
2592                                 chan->dtmf_tv = ast_tvnow();
2593                                 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass, chan->name);
2594                         }
2595                         break;
2596                 case AST_FRAME_NULL:
2597                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2598                          * is reached , because we want to make sure we pass at least one
2599                          * voice frame through before starting the next digit, to ensure a gap
2600                          * between DTMF digits. */
2601                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2602                                 struct timeval now = ast_tvnow();
2603                                 if (!chan->emulate_dtmf_duration) {
2604                                         ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2605                                         chan->emulate_dtmf_digit = 0;
2606                                 } else if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2607                                         chan->emulate_dtmf_duration = 0;
2608                                         ast_frfree(f);
2609                                         f = &chan->dtmff;
2610                                         f->frametype = AST_FRAME_DTMF_END;
2611                                         f->subclass = chan->emulate_dtmf_digit;
2612                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2613                                         chan->dtmf_tv = now;
2614                                         ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2615                                         chan->emulate_dtmf_digit = 0;
2616                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2617                                 }
2618                         }
2619                         break;
2620                 case AST_FRAME_VOICE:
2621                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2622                          * is reached , because we want to make sure we pass at least one
2623                          * voice frame through before starting the next digit, to ensure a gap
2624                          * between DTMF digits. */
2625                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) {
2626                                 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2627                                 chan->emulate_dtmf_digit = 0;
2628                         }
2629
2630                         if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2631                                 if (dropaudio)
2632                                         ast_read_generator_actions(chan, f);
2633                                 ast_frfree(f);
2634                                 f = &ast_null_frame;
2635                         }
2636
2637                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2638                                 struct timeval now = ast_tvnow();
2639                                 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2640                                         chan->emulate_dtmf_duration = 0;
2641                                         ast_frfree(f);
2642                                         f = &chan->dtmff;
2643                                         f->frametype = AST_FRAME_DTMF_END;
2644                                         f->subclass = chan->emulate_dtmf_digit;
2645                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2646                                         chan->dtmf_tv = now;
2647                                         if (chan->audiohooks) {
2648                                                 struct ast_frame *old_frame = f;
2649                                                 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2650                                                 if (old_frame != f)
2651                                                         ast_frfree(old_frame);
2652                                         }
2653                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2654                                 } else {
2655                                         /* Drop voice frames while we're still in the middle of the digit */
2656                                         ast_frfree(f);
2657                                         f = &ast_null_frame;
2658                                 }
2659                         } else if ((f->frametype == AST_FRAME_VOICE) && !(f->subclass & chan->nativeformats)) {
2660                                 /* This frame can't be from the current native formats -- drop it on the
2661                                    floor */
2662                                 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2663                                         chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
2664                                 ast_frfree(f);
2665                                 f = &ast_null_frame;
2666                         } else if ((f->frametype == AST_FRAME_VOICE)) {
2667                                 /* Send frame to audiohooks if present */
2668                                 if (chan->audiohooks) {
2669                                         struct ast_frame *old_frame = f;
2670                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2671                                         if (old_frame != f)
2672                                                 ast_frfree(old_frame);
2673                                 }
2674                                 if (chan->monitor && chan->monitor->read_stream ) {
2675                                         /* XXX what does this do ? */
2676 #ifndef MONITOR_CONSTANT_DELAY
2677                                         int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2678                                         if (jump >= 0) {
2679                                                 jump = chan->outsmpl - chan->insmpl;
2680                                                 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1)
2681                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2682                                                 chan->insmpl += jump + f->samples;
2683                                         } else
2684                                                 chan->insmpl+= f->samples;
2685 #else
2686                                         int jump = chan->outsmpl - chan->insmpl;
2687                                         if (jump - MONITOR_DELAY >= 0) {
2688                                                 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2689                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2690                                                 chan->insmpl += jump;
2691                                         } else
2692                                                 chan->insmpl += f->samples;
2693 #endif
2694                                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2695                                                 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2696                                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2697                                         }
2698                                 }
2699
2700                                 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
2701                                         f = &ast_null_frame;
2702                                 else
2703                                         /* Run generator sitting on the line if timing device not available
2704                                          * and synchronous generation of outgoing frames is necessary       */
2705                                         ast_read_generator_actions(chan, f);
2706                         }
2707                 default:
2708                         /* Just pass it on! */
2709                         break;
2710                 }
2711         } else {
2712                 /* Make sure we always return NULL in the future */
2713                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2714                 if (cause)
2715                         chan->hangupcause = cause;
2716                 if (chan->generator)
2717                         ast_deactivate_generator(chan);
2718                 /* End the CDR if appropriate */
2719                 if (chan->cdr)
2720                         ast_cdr_end(chan->cdr);
2721         }
2722
2723         /* High bit prints debugging */
2724         if (chan->fin & DEBUGCHAN_FLAG)
2725                 ast_frame_dump(chan->name, f, "<<");
2726         chan->fin = FRAMECOUNT_INC(chan->fin);
2727
2728 done:
2729         if (chan->music_state && chan->generator && chan->generator->digit && f && f->frametype == AST_FRAME_DTMF_END)
2730                 chan->generator->digit(chan, f->subclass);
2731
2732         ast_channel_unlock(chan);
2733         return f;
2734 }
2735
2736 int ast_internal_timing_enabled(struct ast_channel *chan)
2737 {
2738         int ret = ast_opt_internal_timing && chan->timingfd > -1;
2739         ast_debug(5, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
2740         return ret;
2741 }
2742
2743 struct ast_frame *ast_read(struct ast_channel *chan)
2744 {
2745         return __ast_read(chan, 0);
2746 }
2747
2748 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2749 {
2750         return __ast_read(chan, 1);
2751 }
2752
2753 int ast_indicate(struct ast_channel *chan, int condition)
2754 {
2755         return ast_indicate_data(chan, condition, NULL, 0);
2756 }
2757
2758 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
2759 {
2760         int res = -1;
2761
2762         ast_channel_lock(chan);
2763         /* Stop if we're a zombie or need a soft hangup */
2764         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2765                 ast_channel_unlock(chan);
2766                 return -1;
2767         }
2768         if (chan->tech->indicate)
2769                 res = chan->tech->indicate(chan, condition, data, datalen);
2770         ast_channel_unlock(chan);
2771         if (!chan->tech->indicate || res) {
2772                 /*
2773                  * Device does not support (that) indication, lets fake
2774                  * it by doing our own tone generation. (PM2002)
2775                  */
2776                 if (condition < 0)
2777                         ast_playtones_stop(chan);
2778                 else {
2779                         const struct ind_tone_zone_sound *ts = NULL;
2780                         switch (condition) {
2781                         case AST_CONTROL_RINGING:
2782                                 ts = ast_get_indication_tone(chan->zone, "ring");
2783                                 break;
2784                         case AST_CONTROL_BUSY:
2785                                 ts = ast_get_indication_tone(chan->zone, "busy");
2786                                 break;
2787                         case AST_CONTROL_CONGESTION:
2788                                 ts = ast_get_indication_tone(chan->zone, "congestion");
2789                                 break;
2790                         }
2791                         if (ts && ts->data[0]) {
2792                                 ast_debug(1, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2793                                 ast_playtones_start(chan,0,ts->data, 1);
2794                                 res = 0;
2795                                 chan->visible_indication = condition;
2796                         } else if (condition == AST_CONTROL_PROGRESS) {
2797                                 /* ast_playtones_stop(chan); */
2798                         } else if (condition == AST_CONTROL_PROCEEDING) {
2799                                 /* Do nothing, really */
2800                         } else if (condition == AST_CONTROL_HOLD) {
2801                                 /* Do nothing.... */
2802                         } else if (condition == AST_CONTROL_UNHOLD) {
2803                                 /* Do nothing.... */
2804                         } else if (condition == AST_CONTROL_VIDUPDATE) {
2805                                 /* Do nothing.... */
2806                         } else if (condition == AST_CONTROL_SRCUPDATE) {
2807                                 /* Do nothing... */
2808                         } else {
2809                                 /* not handled */
2810                                 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2811                                 res = -1;
2812                         }
2813                 }
2814         } else
2815                 chan->visible_indication = condition;
2816
2817         return res;
2818 }
2819
2820 int ast_recvchar(struct ast_channel *chan, int timeout)
2821 {
2822         int c;
2823         char *buf = ast_recvtext(chan, timeout);
2824         if (buf == NULL)
2825                 return -1;      /* error or timeout */
2826         c = *(unsigned char *)buf;
2827         ast_free(buf);
2828         return c;
2829 }
2830
2831 char *ast_recvtext(struct ast_channel *chan, int timeout)
2832 {
2833         int res, done = 0;
2834         char *buf = NULL;
2835
2836         while (!done) {
2837                 struct ast_frame *f;
2838                 if (ast_check_hangup(chan))
2839                         break;
2840                 res = ast_waitfor(chan, timeout);
2841                 if (res <= 0) /* timeout or error */
2842                         break;
2843                 timeout = res;  /* update timeout */
2844                 f = ast_read(chan);
2845                 if (f == NULL)
2846                         break; /* no frame */
2847                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2848                         done = 1;       /* force a break */
2849                 else if (f->frametype == AST_FRAME_TEXT) {              /* what we want */
2850                         buf = ast_strndup((char *) f->data.ptr, f->datalen);    /* dup and break */
2851                         done = 1;
2852                 }
2853                 ast_frfree(f);
2854         }
2855         return buf;
2856 }
2857
2858 int ast_sendtext(struct ast_channel *chan, const char *text)
2859 {
2860         int res = 0;
2861         /* Stop if we're a zombie or need a soft hangup */
2862         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2863                 return -1;
2864         CHECK_BLOCKING(chan);
2865         if (chan->tech->send_text)
2866                 res = chan->tech->send_text(chan, text);
2867         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2868         return res;
2869 }
2870
2871 int ast_senddigit_begin(struct ast_channel *chan, char digit)
2872 {
2873         /* Device does not support DTMF tones, lets fake
2874          * it by doing our own generation. */
2875         static const char* dtmf_tones[] = {
2876                 "941+1336", /* 0 */
2877                 "697+1209", /* 1 */
2878                 "697+1336", /* 2 */
2879                 "697+1477", /* 3 */
2880                 "770+1209", /* 4 */
2881                 "770+1336", /* 5 */
2882                 "770+1477", /* 6 */
2883                 "852+1209", /* 7 */
2884                 "852+1336", /* 8 */
2885                 "852+1477", /* 9 */
2886                 "697+1633", /* A */
2887                 "770+1633", /* B */
2888                 "852+1633", /* C */
2889                 "941+1633", /* D */
2890                 "941+1209", /* * */
2891                 "941+1477"  /* # */
2892         };
2893
2894         if (!chan->tech->send_digit_begin)
2895                 return 0;
2896
2897         if (!chan->tech->send_digit_begin(chan, digit))
2898                 return 0;
2899
2900         if (digit >= '0' && digit <='9')
2901                 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2902         else if (digit >= 'A' && digit <= 'D')
2903                 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2904         else if (digit == '*')
2905                 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2906         else if (digit == '#')
2907                 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2908         else {
2909                 /* not handled */
2910                 ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2911         }
2912
2913         return 0;
2914 }
2915
2916 int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
2917 {
2918         int res = -1;
2919
2920         if (chan->tech->send_digit_end)
2921                 res = chan->tech->send_digit_end(chan, digit, duration);
2922
2923         if (res && chan->generator)
2924                 ast_playtones_stop(chan);
2925
2926         return 0;
2927 }
2928
2929 int ast_senddigit(struct ast_channel *chan, char digit, unsigned int duration)
2930 {
2931         if (chan->tech->send_digit_begin) {
2932                 ast_senddigit_begin(chan, digit);
2933                 ast_safe_sleep(chan, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2934         }
2935
2936         return ast_senddigit_end(chan, digit, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2937 }
2938
2939 int ast_prod(struct ast_channel *chan)
2940 {
2941         struct ast_frame a = { AST_FRAME_VOICE };
2942         char nothing[128];
2943
2944         /* Send an empty audio frame to get things moving */
2945         if (chan->_state != AST_STATE_UP) {
2946                 ast_debug(1, "Prodding channel '%s'\n", chan->name);
2947                 a.subclass = chan->rawwriteformat;
2948                 a.data.ptr = nothing + AST_FRIENDLY_OFFSET;
2949                 a.src = "ast_prod";
2950                 if (ast_write(chan, &a))
2951                         ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2952         }
2953         return 0;
2954 }
2955
2956 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2957 {
2958         int res;
2959         if (!chan->tech->write_video)
2960                 return 0;
2961         res = ast_write(chan, fr);
2962         if (!res)
2963                 res = 1;
2964         return res;
2965 }
2966
2967 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2968 {
2969         int res = -1;
2970         struct ast_frame *f = NULL, *f2 = NULL;
2971         int count = 0;
2972
2973         /*Deadlock avoidance*/
2974         while(ast_channel_trylock(chan)) {
2975                 /*cannot goto done since the channel is not locked*/
2976                 if(count++ > 10) {
2977                         ast_debug(1, "Deadlock avoided for write to channel '%s'\n", chan->name);
2978                         return 0;
2979                 }
2980                 usleep(1);
2981         }
2982         /* Stop if we're a zombie or need a soft hangup */
2983         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2984                 goto done;
2985
2986         /* Handle any pending masquerades */
2987         if (chan->masq && ast_do_masquerade(chan)) {
2988                 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2989                 goto done;
2990         }
2991         if (chan->masqr) {
2992                 res = 0;        /* XXX explain, why 0 ? */
2993                 goto done;
2994         }
2995         if (chan->generatordata) {
2996                 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
2997                         ast_deactivate_generator(chan);
2998                 else {
2999                         if (fr->frametype == AST_FRAME_DTMF_END) {
3000                                 /* There is a generator running while we're in the middle of a digit.
3001                                  * It's probably inband DTMF, so go ahead and pass it so it can
3002                                  * stop the generator */
3003                                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3004                                 ast_channel_unlock(chan);
3005                                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
3006                                 ast_channel_lock(chan);
3007                                 CHECK_BLOCKING(chan);
3008                         } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
3009                                 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
3010                                 res = (chan->tech->indicate == NULL) ? 0 :
3011                                         chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
3012                         }
3013                         res = 0;        /* XXX explain, why 0 ? */
3014                         goto done;
3015                 }
3016         }
3017         /* High bit prints debugging */
3018         if (chan->fout & DEBUGCHAN_FLAG)
3019                 ast_frame_dump(chan->name, fr, ">>");
3020         CHECK_BLOCKING(chan);
3021         switch (fr->frametype) {
3022         case AST_FRAME_CONTROL:
3023                 res = (chan->tech->indicate == NULL) ? 0 :
3024                         chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
3025                 break;
3026         case AST_FRAME_DTMF_BEGIN:
3027                 if (chan->audiohooks) {
3028                         struct ast_frame *old_frame = fr;
3029                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3030                         if (old_frame != fr)
3031                                 f = fr;
3032                 }
3033                 send_dtmf_event(chan, "Sent", fr->subclass, "Yes", "No");
3034                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3035                 ast_channel_unlock(chan);
3036                 res = ast_senddigit_begin(chan, fr->subclass);
3037                 ast_channel_lock(chan);
3038                 CHECK_BLOCKING(chan);
3039                 break;
3040         case AST_FRAME_DTMF_END:
3041                 if (chan->audiohooks) {
3042                         struct ast_frame *old_frame = fr;
3043                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3044                         if (old_frame != fr)
3045                                 f = fr;
3046                 }
3047                 send_dtmf_event(chan, "Sent", fr->subclass, "No", "Yes");
3048                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3049                 ast_channel_unlock(chan);
3050                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
3051                 ast_channel_lock(chan);
3052                 CHECK_BLOCKING(chan);
3053                 break;
3054         case AST_FRAME_TEXT:
3055                 if (fr->subclass == AST_FORMAT_T140) {
3056                         res = (chan->tech->write_text == NULL) ? 0 :
3057                                 chan->tech->write_text(chan, fr);
3058                 } else {
3059                         res = (chan->tech->send_text == NULL) ? 0 :
3060                                 chan->tech->send_text(chan, (char *) fr->data.ptr);
3061                 }
3062                 break;
3063         case AST_FRAME_HTML:
3064                 res = (chan->tech->send_html == NULL) ? 0 :
3065                         chan->tech->send_html(chan, fr->subclass, (char *) fr->data.ptr, fr->datalen);
3066                 break;
3067         case AST_FRAME_VIDEO:
3068                 /* XXX Handle translation of video codecs one day XXX */
3069                 res = (chan->tech->write_video == NULL) ? 0 :
3070                         chan->tech->write_video(chan, fr);
3071                 break;
3072         case AST_FRAME_MODEM:
3073                 res = (chan->tech->write == NULL) ? 0 :
3074                         chan->tech->write(chan, fr);
3075                 break;
3076         case AST_FRAME_VOICE:
3077                 if (chan->tech->write == NULL)
3078                         break;  /*! \todo XXX should return 0 maybe ? */
3079
3080                 /* If audiohooks are present, write the frame out */
3081                 if (chan->audiohooks) {
3082                         struct ast_frame *old_frame = fr;
3083                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3084                         if (old_frame != fr)
3085                                 f2 = fr;
3086                 }
3087
3088                 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
3089                 if (fr->subclass == chan->rawwriteformat)
3090