3a9726393857363c6ad8b5408661c3c2da075d0b
[asterisk/asterisk.git] / main / channel.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Channel Management
22  *
23  * \author Mark Spencer <markster@digium.com>
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include "asterisk/_private.h"
31
32 #include <sys/time.h>
33 #include <signal.h>
34 #include <math.h>
35
36 #include "asterisk/paths.h"     /* use ast_config_AST_SYSTEM_NAME */
37
38 #include "asterisk/pbx.h"
39 #include "asterisk/frame.h"
40 #include "asterisk/sched.h"
41 #include "asterisk/channel.h"
42 #include "asterisk/musiconhold.h"
43 #include "asterisk/say.h"
44 #include "asterisk/file.h"
45 #include "asterisk/cli.h"
46 #include "asterisk/translate.h"
47 #include "asterisk/manager.h"
48 #include "asterisk/chanvars.h"
49 #include "asterisk/linkedlists.h"
50 #include "asterisk/indications.h"
51 #include "asterisk/monitor.h"
52 #include "asterisk/causes.h"
53 #include "asterisk/callerid.h"
54 #include "asterisk/utils.h"
55 #include "asterisk/lock.h"
56 #include "asterisk/app.h"
57 #include "asterisk/transcap.h"
58 #include "asterisk/devicestate.h"
59 #include "asterisk/sha1.h"
60 #include "asterisk/threadstorage.h"
61 #include "asterisk/slinfactory.h"
62 #include "asterisk/audiohook.h"
63 #include "asterisk/timing.h"
64
65 #ifdef HAVE_EPOLL
66 #include <sys/epoll.h>
67 #endif
68
69 struct ast_epoll_data {
70         struct ast_channel *chan;
71         int which;
72 };
73
74 /* uncomment if you have problems with 'monitoring' synchronized files */
75 #if 0
76 #define MONITOR_CONSTANT_DELAY
77 #define MONITOR_DELAY   150 * 8         /*!< 150 ms of MONITORING DELAY */
78 #endif
79
80 /*! \brief Prevent new channel allocation if shutting down. */
81 static int shutting_down;
82
83 static int uniqueint;
84
85 unsigned long global_fin, global_fout;
86
87 AST_THREADSTORAGE(state2str_threadbuf);
88 #define STATE2STR_BUFSIZE   32
89
90 /*! Default amount of time to use when emulating a digit as a begin and end 
91  *  100ms */
92 #define AST_DEFAULT_EMULATE_DTMF_DURATION 100
93
94 /*! Minimum allowed digit length - 80ms */
95 #define AST_MIN_DTMF_DURATION 80
96
97 /*! Minimum amount of time between the end of the last digit and the beginning 
98  *  of a new one - 45ms */
99 #define AST_MIN_DTMF_GAP 45
100
101 /*! \brief List of channel drivers */
102 struct chanlist {
103         const struct ast_channel_tech *tech;
104         AST_LIST_ENTRY(chanlist) list;
105 };
106
107 #ifdef CHANNEL_TRACE
108 /*! \brief Structure to hold channel context backtrace data */
109 struct ast_chan_trace_data {
110         int enabled;
111         AST_LIST_HEAD_NOLOCK(, ast_chan_trace) trace;
112 };
113
114 /*! \brief Structure to save contexts where an ast_chan has been into */
115 struct ast_chan_trace {
116         char context[AST_MAX_CONTEXT];
117         char exten[AST_MAX_EXTENSION];
118         int priority;
119         AST_LIST_ENTRY(ast_chan_trace) entry;
120 };
121 #endif
122
123 /*! \brief the list of registered channel types */
124 static AST_LIST_HEAD_NOLOCK_STATIC(backends, chanlist);
125
126 /*! \brief the list of channels we have. Note that the lock for this list is used for
127         both the channels list and the backends list.  */
128 static AST_RWLIST_HEAD_STATIC(channels, ast_channel);
129
130 /*! \brief map AST_CAUSE's to readable string representations 
131  *
132  * \ref causes.h
133 */
134 const struct ast_cause {
135         int cause;
136         const char *name;
137         const char *desc;
138 } causes[] = {
139         { AST_CAUSE_UNALLOCATED, "UNALLOCATED", "Unallocated (unassigned) number" },
140         { AST_CAUSE_NO_ROUTE_TRANSIT_NET, "NO_ROUTE_TRANSIT_NET", "No route to specified transmit network" },
141         { AST_CAUSE_NO_ROUTE_DESTINATION, "NO_ROUTE_DESTINATION", "No route to destination" },
142         { AST_CAUSE_CHANNEL_UNACCEPTABLE, "CHANNEL_UNACCEPTABLE", "Channel unacceptable" },
143         { AST_CAUSE_CALL_AWARDED_DELIVERED, "CALL_AWARDED_DELIVERED", "Call awarded and being delivered in an established channel" },
144         { AST_CAUSE_NORMAL_CLEARING, "NORMAL_CLEARING", "Normal Clearing" },
145         { AST_CAUSE_USER_BUSY, "USER_BUSY", "User busy" },
146         { AST_CAUSE_NO_USER_RESPONSE, "NO_USER_RESPONSE", "No user responding" },
147         { AST_CAUSE_NO_ANSWER, "NO_ANSWER", "User alerting, no answer" },
148         { AST_CAUSE_CALL_REJECTED, "CALL_REJECTED", "Call Rejected" },
149         { AST_CAUSE_NUMBER_CHANGED, "NUMBER_CHANGED", "Number changed" },
150         { AST_CAUSE_DESTINATION_OUT_OF_ORDER, "DESTINATION_OUT_OF_ORDER", "Destination out of order" },
151         { AST_CAUSE_INVALID_NUMBER_FORMAT, "INVALID_NUMBER_FORMAT", "Invalid number format" },
152         { AST_CAUSE_FACILITY_REJECTED, "FACILITY_REJECTED", "Facility rejected" },
153         { AST_CAUSE_RESPONSE_TO_STATUS_ENQUIRY, "RESPONSE_TO_STATUS_ENQUIRY", "Response to STATus ENQuiry" },
154         { AST_CAUSE_NORMAL_UNSPECIFIED, "NORMAL_UNSPECIFIED", "Normal, unspecified" },
155         { AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, "NORMAL_CIRCUIT_CONGESTION", "Circuit/channel congestion" },
156         { AST_CAUSE_NETWORK_OUT_OF_ORDER, "NETWORK_OUT_OF_ORDER", "Network out of order" },
157         { AST_CAUSE_NORMAL_TEMPORARY_FAILURE, "NORMAL_TEMPORARY_FAILURE", "Temporary failure" },
158         { AST_CAUSE_SWITCH_CONGESTION, "SWITCH_CONGESTION", "Switching equipment congestion" },
159         { AST_CAUSE_ACCESS_INFO_DISCARDED, "ACCESS_INFO_DISCARDED", "Access information discarded" },
160         { AST_CAUSE_REQUESTED_CHAN_UNAVAIL, "REQUESTED_CHAN_UNAVAIL", "Requested channel not available" },
161         { AST_CAUSE_PRE_EMPTED, "PRE_EMPTED", "Pre-empted" },
162         { AST_CAUSE_FACILITY_NOT_SUBSCRIBED, "FACILITY_NOT_SUBSCRIBED", "Facility not subscribed" },
163         { AST_CAUSE_OUTGOING_CALL_BARRED, "OUTGOING_CALL_BARRED", "Outgoing call barred" },
164         { AST_CAUSE_INCOMING_CALL_BARRED, "INCOMING_CALL_BARRED", "Incoming call barred" },
165         { AST_CAUSE_BEARERCAPABILITY_NOTAUTH, "BEARERCAPABILITY_NOTAUTH", "Bearer capability not authorized" },
166         { AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, "BEARERCAPABILITY_NOTAVAIL", "Bearer capability not available" },
167         { AST_CAUSE_BEARERCAPABILITY_NOTIMPL, "BEARERCAPABILITY_NOTIMPL", "Bearer capability not implemented" },
168         { AST_CAUSE_CHAN_NOT_IMPLEMENTED, "CHAN_NOT_IMPLEMENTED", "Channel not implemented" },
169         { AST_CAUSE_FACILITY_NOT_IMPLEMENTED, "FACILITY_NOT_IMPLEMENTED", "Facility not implemented" },
170         { AST_CAUSE_INVALID_CALL_REFERENCE, "INVALID_CALL_REFERENCE", "Invalid call reference value" },
171         { AST_CAUSE_INCOMPATIBLE_DESTINATION, "INCOMPATIBLE_DESTINATION", "Incompatible destination" },
172         { AST_CAUSE_INVALID_MSG_UNSPECIFIED, "INVALID_MSG_UNSPECIFIED", "Invalid message unspecified" },
173         { AST_CAUSE_MANDATORY_IE_MISSING, "MANDATORY_IE_MISSING", "Mandatory information element is missing" },
174         { AST_CAUSE_MESSAGE_TYPE_NONEXIST, "MESSAGE_TYPE_NONEXIST", "Message type nonexist." },
175         { AST_CAUSE_WRONG_MESSAGE, "WRONG_MESSAGE", "Wrong message" },
176         { AST_CAUSE_IE_NONEXIST, "IE_NONEXIST", "Info. element nonexist or not implemented" },
177         { AST_CAUSE_INVALID_IE_CONTENTS, "INVALID_IE_CONTENTS", "Invalid information element contents" },
178         { AST_CAUSE_WRONG_CALL_STATE, "WRONG_CALL_STATE", "Message not compatible with call state" },
179         { AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, "RECOVERY_ON_TIMER_EXPIRE", "Recover on timer expiry" },
180         { AST_CAUSE_MANDATORY_IE_LENGTH_ERROR, "MANDATORY_IE_LENGTH_ERROR", "Mandatory IE length error" },
181         { AST_CAUSE_PROTOCOL_ERROR, "PROTOCOL_ERROR", "Protocol error, unspecified" },
182         { AST_CAUSE_INTERWORKING, "INTERWORKING", "Interworking, unspecified" },
183 };
184
185 struct ast_variable *ast_channeltype_list(void)
186 {
187         struct chanlist *cl;
188         struct ast_variable *var=NULL, *prev = NULL;
189         AST_LIST_TRAVERSE(&backends, cl, list) {
190                 if (prev)  {
191                         if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description, "")))
192                                 prev = prev->next;
193                 } else {
194                         var = ast_variable_new(cl->tech->type, cl->tech->description, "");
195                         prev = var;
196                 }
197         }
198         return var;
199 }
200
201 /*! \brief Show channel types - CLI command */
202 static char *handle_cli_core_show_channeltypes(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
203 {
204 #define FORMAT  "%-10.10s  %-40.40s %-12.12s %-12.12s %-12.12s\n"
205         struct chanlist *cl;
206         int count_chan = 0;
207
208         switch (cmd) {
209         case CLI_INIT:
210                 e->command = "core show channeltypes";
211                 e->usage =
212                         "Usage: core show channeltypes\n"
213                         "       Lists available channel types registered in your\n"
214                         "       Asterisk server.\n";
215                 return NULL;
216         case CLI_GENERATE:
217                 return NULL;
218         }
219
220         if (a->argc != 3)
221                 return CLI_SHOWUSAGE;
222
223         ast_cli(a->fd, FORMAT, "Type", "Description",       "Devicestate", "Indications", "Transfer");
224         ast_cli(a->fd, FORMAT, "----------", "-----------", "-----------", "-----------", "--------");
225
226         AST_RWLIST_RDLOCK(&channels);
227
228         AST_LIST_TRAVERSE(&backends, cl, list) {
229                 ast_cli(a->fd, FORMAT, cl->tech->type, cl->tech->description,
230                         (cl->tech->devicestate) ? "yes" : "no",
231                         (cl->tech->indicate) ? "yes" : "no",
232                         (cl->tech->transfer) ? "yes" : "no");
233                 count_chan++;
234         }
235
236         AST_RWLIST_UNLOCK(&channels);
237
238         ast_cli(a->fd, "----------\n%d channel drivers registered.\n", count_chan);
239
240         return CLI_SUCCESS;
241
242 #undef FORMAT
243 }
244
245 static char *complete_channeltypes(struct ast_cli_args *a)
246 {
247         struct chanlist *cl;
248         int which = 0;
249         int wordlen;
250         char *ret = NULL;
251
252         if (a->pos != 3)
253                 return NULL;
254
255         wordlen = strlen(a->word);
256
257         AST_LIST_TRAVERSE(&backends, cl, list) {
258                 if (!strncasecmp(a->word, cl->tech->type, wordlen) && ++which > a->n) {
259                         ret = ast_strdup(cl->tech->type);
260                         break;
261                 }
262         }
263         
264         return ret;
265 }
266
267 /*! \brief Show details about a channel driver - CLI command */
268 static char *handle_cli_core_show_channeltype(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
269 {
270         struct chanlist *cl = NULL;
271
272         switch (cmd) {
273         case CLI_INIT:
274                 e->command = "core show channeltype";
275                 e->usage =
276                         "Usage: core show channeltype <name>\n"
277                         "       Show details about the specified channel type, <name>.\n";
278                 return NULL;
279         case CLI_GENERATE:
280                 return complete_channeltypes(a);
281         }
282
283         if (a->argc != 4)
284                 return CLI_SHOWUSAGE;
285         
286         AST_RWLIST_RDLOCK(&channels);
287
288         AST_LIST_TRAVERSE(&backends, cl, list) {
289                 if (!strncasecmp(cl->tech->type, a->argv[3], strlen(cl->tech->type)))
290                         break;
291         }
292
293
294         if (!cl) {
295                 ast_cli(a->fd, "\n%s is not a registered channel driver.\n", a->argv[3]);
296                 AST_RWLIST_UNLOCK(&channels);
297                 return CLI_FAILURE;
298         }
299
300         ast_cli(a->fd,
301                 "-- Info about channel driver: %s --\n"
302                 "  Device State: %s\n"
303                 "    Indication: %s\n"
304                 "     Transfer : %s\n"
305                 "  Capabilities: %d\n"
306                 "   Digit Begin: %s\n"
307                 "     Digit End: %s\n"
308                 "    Send HTML : %s\n"
309                 " Image Support: %s\n"
310                 "  Text Support: %s\n",
311                 cl->tech->type,
312                 (cl->tech->devicestate) ? "yes" : "no",
313                 (cl->tech->indicate) ? "yes" : "no",
314                 (cl->tech->transfer) ? "yes" : "no",
315                 (cl->tech->capabilities) ? cl->tech->capabilities : -1,
316                 (cl->tech->send_digit_begin) ? "yes" : "no",
317                 (cl->tech->send_digit_end) ? "yes" : "no",
318                 (cl->tech->send_html) ? "yes" : "no",
319                 (cl->tech->send_image) ? "yes" : "no",
320                 (cl->tech->send_text) ? "yes" : "no"
321                 
322         );
323
324         AST_RWLIST_UNLOCK(&channels);
325         return CLI_SUCCESS;
326 }
327
328 static struct ast_cli_entry cli_channel[] = {
329         AST_CLI_DEFINE(handle_cli_core_show_channeltypes, "List available channel types"),
330         AST_CLI_DEFINE(handle_cli_core_show_channeltype,  "Give more details on that channel type")
331 };
332
333 #ifdef CHANNEL_TRACE
334 /*! \brief Destructor for the channel trace datastore */
335 static void ast_chan_trace_destroy_cb(void *data)
336 {
337         struct ast_chan_trace *trace;
338         struct ast_chan_trace_data *traced = data;
339         while ((trace = AST_LIST_REMOVE_HEAD(&traced->trace, entry))) {
340                 ast_free(trace);
341         }
342         ast_free(traced);
343 }
344
345 /*! \brief Datastore to put the linked list of ast_chan_trace and trace status */
346 const struct ast_datastore_info ast_chan_trace_datastore_info = {
347         .type = "ChanTrace",
348         .destroy = ast_chan_trace_destroy_cb
349 };
350
351 /*! \brief Put the channel backtrace in a string */
352 int ast_channel_trace_serialize(struct ast_channel *chan, struct ast_str **buf)
353 {
354         int total = 0;
355         struct ast_chan_trace *trace;
356         struct ast_chan_trace_data *traced;
357         struct ast_datastore *store;
358
359         ast_channel_lock(chan);
360         store = ast_channel_datastore_find(chan, &ast_chan_trace_datastore_info, NULL);
361         if (!store) {
362                 ast_channel_unlock(chan);
363                 return total;
364         }
365         traced = store->data;
366         (*buf)->used = 0;
367         (*buf)->str[0] = '\0';
368         AST_LIST_TRAVERSE(&traced->trace, trace, entry) {
369                 if (ast_str_append(buf, 0, "[%d] => %s, %s, %d\n", total, trace->context, trace->exten, trace->priority) < 0) {
370                         ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
371                         total = -1;
372                         break;
373                 }
374                 total++;
375         }
376         ast_channel_unlock(chan);
377         return total;
378 }
379
380 /* !\brief Whether or not context tracing is enabled */
381 int ast_channel_trace_is_enabled(struct ast_channel *chan)
382 {
383         struct ast_datastore *store = ast_channel_datastore_find(chan, &ast_chan_trace_datastore_info, NULL);
384         if (!store)
385                 return 0;
386         return ((struct ast_chan_trace_data *)store->data)->enabled;
387 }
388
389 /*! \brief Update the context backtrace data if tracing is enabled */
390 static int ast_channel_trace_data_update(struct ast_channel *chan, struct ast_chan_trace_data *traced)
391 {
392         struct ast_chan_trace *trace;
393         if (!traced->enabled)
394                 return 0;
395         /* If the last saved context does not match the current one
396            OR we have not saved any context so far, then save the current context */
397         if ((!AST_LIST_EMPTY(&traced->trace) && strcasecmp(AST_LIST_FIRST(&traced->trace)->context, chan->context)) || 
398             (AST_LIST_EMPTY(&traced->trace))) {
399                 /* Just do some debug logging */
400                 if (AST_LIST_EMPTY(&traced->trace))
401                         ast_log(LOG_DEBUG, "Setting initial trace context to %s\n", chan->context);
402                 else
403                         ast_log(LOG_DEBUG, "Changing trace context from %s to %s\n", AST_LIST_FIRST(&traced->trace)->context, chan->context);
404                 /* alloc or bail out */
405                 trace = ast_malloc(sizeof(*trace));
406                 if (!trace) 
407                         return -1;
408                 /* save the current location and store it in the trace list */
409                 ast_copy_string(trace->context, chan->context, sizeof(trace->context));
410                 ast_copy_string(trace->exten, chan->exten, sizeof(trace->exten));
411                 trace->priority = chan->priority;
412                 AST_LIST_INSERT_HEAD(&traced->trace, trace, entry);
413         }
414         return 0;
415 }
416
417 /*! \brief Update the context backtrace if tracing is enabled */
418 int ast_channel_trace_update(struct ast_channel *chan)
419 {
420         struct ast_datastore *store = ast_channel_datastore_find(chan, &ast_chan_trace_datastore_info, NULL);
421         if (!store)
422                 return 0;
423         return ast_channel_trace_data_update(chan, store->data);
424 }
425
426 /*! \brief Enable context tracing in the channel */
427 int ast_channel_trace_enable(struct ast_channel *chan)
428 {
429         struct ast_datastore *store = ast_channel_datastore_find(chan, &ast_chan_trace_datastore_info, NULL);
430         struct ast_chan_trace_data *traced;
431         if (!store) {
432                 store = ast_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 < ARRAY_LEN(prefs); x++) {
756                 if (fmts & prefs[x])
757                         return prefs[x];
758         }
759
760         ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts);
761
762         return 0;
763 }
764
765 static const struct ast_channel_tech null_tech = {
766         .type = "NULL",
767         .description = "Null channel (should not see this)",
768 };
769
770 /*! \brief Create a new channel structure */
771 struct ast_channel *ast_channel_alloc(int needqueue, int state, const char *cid_num, const char *cid_name, const char *acctcode, const char *exten, const char *context, const int amaflag, const char *name_fmt, ...)
772 {
773         struct ast_channel *tmp;
774         int x;
775         int flags;
776         struct varshead *headp;
777         va_list ap1, ap2;
778
779         /* If shutting down, don't allocate any new channels */
780         if (shutting_down) {
781                 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
782                 return NULL;
783         }
784
785         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
786                 return NULL;
787
788         if (!(tmp->sched = sched_context_create())) {
789                 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
790                 ast_free(tmp);
791                 return NULL;
792         }
793         
794         if ((ast_string_field_init(tmp, 128))) {
795                 sched_context_destroy(tmp->sched);
796                 ast_free(tmp);
797                 return NULL;
798         }
799
800 #ifdef HAVE_EPOLL
801         tmp->epfd = epoll_create(25);
802 #endif
803
804         for (x = 0; x < AST_MAX_FDS; x++) {
805                 tmp->fds[x] = -1;
806 #ifdef HAVE_EPOLL
807                 tmp->epfd_data[x] = NULL;
808 #endif
809         }
810
811         tmp->timingfd = ast_timer_open();
812         if (tmp->timingfd > -1) {
813                 needqueue = 0;
814         }
815
816         if (needqueue) {
817                 if (pipe(tmp->alertpipe)) {
818                         ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
819 alertpipe_failed:
820                         if (tmp->timingfd > -1) {
821                                 ast_timer_close(tmp->timingfd);
822                         }
823
824                         sched_context_destroy(tmp->sched);
825                         ast_string_field_free_memory(tmp);
826                         ast_free(tmp);
827                         return NULL;
828                 } else {
829                         flags = fcntl(tmp->alertpipe[0], F_GETFL);
830                         if (fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK) < 0) {
831                                 ast_log(LOG_WARNING, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno));
832                                 close(tmp->alertpipe[0]);
833                                 close(tmp->alertpipe[1]);
834                                 goto alertpipe_failed;
835                         }
836                         flags = fcntl(tmp->alertpipe[1], F_GETFL);
837                         if (fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK) < 0) {
838                                 ast_log(LOG_WARNING, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno));
839                                 close(tmp->alertpipe[0]);
840                                 close(tmp->alertpipe[1]);
841                                 goto alertpipe_failed;
842                         }
843                 }
844         } else  /* Make sure we've got it done right if they don't */
845                 tmp->alertpipe[0] = tmp->alertpipe[1] = -1;
846
847         /* Always watch the alertpipe */
848         ast_channel_set_fd(tmp, AST_ALERT_FD, tmp->alertpipe[0]);
849         /* And timing pipe */
850         ast_channel_set_fd(tmp, AST_TIMING_FD, tmp->timingfd);
851         ast_string_field_set(tmp, name, "**Unknown**");
852
853         /* Initial state */
854         tmp->_state = state;
855
856         tmp->streamid = -1;
857         
858         tmp->fin = global_fin;
859         tmp->fout = global_fout;
860
861         if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
862                 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL), 
863                                        ast_atomic_fetchadd_int(&uniqueint, 1));
864         } else {
865                 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME, 
866                                        (long) time(NULL), ast_atomic_fetchadd_int(&uniqueint, 1));
867         }
868
869         tmp->cid.cid_name = ast_strdup(cid_name);
870         tmp->cid.cid_num = ast_strdup(cid_num);
871         
872         if (!ast_strlen_zero(name_fmt)) {
873                 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
874                  * And they all use slightly different formats for their name string.
875                  * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
876                  * This means, that the stringfields must have a routine that takes the va_lists directly, and 
877                  * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
878                  * This new function was written so this can be accomplished.
879                  */
880                 va_start(ap1, name_fmt);
881                 va_start(ap2, name_fmt);
882                 ast_string_field_build_va(tmp, name, name_fmt, ap1, ap2);
883                 va_end(ap1);
884                 va_end(ap2);
885         }
886
887         /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */
888
889         /* These 4 variables need to be set up for the cdr_init() to work right */
890         if (amaflag)
891                 tmp->amaflags = amaflag;
892         else
893                 tmp->amaflags = ast_default_amaflags;
894         
895         if (!ast_strlen_zero(acctcode))
896                 ast_string_field_set(tmp, accountcode, acctcode);
897         else
898                 ast_string_field_set(tmp, accountcode, ast_default_accountcode);
899                 
900         if (!ast_strlen_zero(context))
901                 ast_copy_string(tmp->context, context, sizeof(tmp->context));
902         else
903                 strcpy(tmp->context, "default");
904
905         if (!ast_strlen_zero(exten))
906                 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten));
907         else
908                 strcpy(tmp->exten, "s");
909
910         tmp->priority = 1;
911                 
912         tmp->cdr = ast_cdr_alloc();
913         ast_cdr_init(tmp->cdr, tmp);
914         ast_cdr_start(tmp->cdr);
915         
916         headp = &tmp->varshead;
917         AST_LIST_HEAD_INIT_NOLOCK(headp);
918         
919         ast_mutex_init(&tmp->lock_dont_use);
920         
921         AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores);
922         
923         ast_string_field_set(tmp, language, defaultlanguage);
924
925         tmp->tech = &null_tech;
926
927         AST_RWLIST_WRLOCK(&channels);
928         AST_RWLIST_INSERT_HEAD(&channels, tmp, chan_list);
929         AST_RWLIST_UNLOCK(&channels);
930
931         /*\!note
932          * and now, since the channel structure is built, and has its name, let's
933          * call the manager event generator with this Newchannel event. This is the
934          * proper and correct place to make this call, but you sure do have to pass
935          * a lot of data into this func to do it here!
936          */
937         if (!ast_strlen_zero(name_fmt)) {
938                 manager_event(EVENT_FLAG_CALL, "Newchannel",
939                         "Channel: %s\r\n"
940                         "ChannelState: %d\r\n"
941                         "ChannelStateDesc: %s\r\n"
942                         "CallerIDNum: %s\r\n"
943                         "CallerIDName: %s\r\n"
944                         "AccountCode: %s\r\n"
945                         "Uniqueid: %s\r\n",
946                         tmp->name, 
947                         state, 
948                         ast_state2str(state),
949                         S_OR(cid_num, ""),
950                         S_OR(cid_name, ""),
951                         tmp->accountcode,
952                         tmp->uniqueid);
953         }
954
955         return tmp;
956 }
957
958 /*! \brief Queue an outgoing media frame */
959 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
960 {
961         struct ast_frame *f;
962         struct ast_frame *cur;
963         int blah = 1;
964         int qlen = 0;
965
966         /* Build us a copy and free the original one */
967         if (!(f = ast_frdup(fin))) {
968                 ast_log(LOG_WARNING, "Unable to duplicate frame\n");
969                 return -1;
970         }
971         ast_channel_lock(chan);
972
973         /* See if the last frame on the queue is a hangup, if so don't queue anything */
974         if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
975                 ast_frfree(f);
976                 ast_channel_unlock(chan);
977                 return 0;
978         }
979
980         /* Count how many frames exist on the queue */
981         AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
982                 qlen++;
983         }
984
985         /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
986         if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen  > 128)) {
987                 if (fin->frametype != AST_FRAME_VOICE) {
988                         ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name);
989                         ast_assert(fin->frametype == AST_FRAME_VOICE);
990                 } else {
991                         ast_debug(1, "Dropping voice to exceptionally long queue on %s\n", chan->name);
992                         ast_frfree(f);
993                         ast_channel_unlock(chan);
994                         return 0;
995                 }
996         }
997         AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
998         if (chan->alertpipe[1] > -1) {
999                 if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
1000                         ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
1001                                 chan->name, f->frametype, f->subclass, qlen, strerror(errno));
1002         } else if (chan->timingfd > -1) {
1003                 ast_timer_enable_continuous(chan->timingfd);
1004         } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1005                 pthread_kill(chan->blocker, SIGURG);
1006         }
1007         ast_channel_unlock(chan);
1008         return 0;
1009 }
1010
1011 /*! \brief Queue a hangup frame for channel */
1012 int ast_queue_hangup(struct ast_channel *chan)
1013 {
1014         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
1015         /* Yeah, let's not change a lock-critical value without locking */
1016         if (!ast_channel_trylock(chan)) {
1017                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
1018                 ast_channel_unlock(chan);
1019         }
1020         return ast_queue_frame(chan, &f);
1021 }
1022
1023 /*! \brief Queue a hangup frame for channel */
1024 int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
1025 {
1026         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
1027
1028         if (cause >= 0)
1029                 f.data.uint32 = cause;
1030
1031         /* Yeah, let's not change a lock-critical value without locking */
1032         if (!ast_channel_trylock(chan)) {
1033                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
1034                 if (cause < 0)
1035                         f.data.uint32 = chan->hangupcause;
1036
1037                 ast_channel_unlock(chan);
1038         }
1039
1040         return ast_queue_frame(chan, &f);
1041 }
1042
1043 /*! \brief Queue a control frame */
1044 int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
1045 {
1046         struct ast_frame f = { AST_FRAME_CONTROL, };
1047
1048         f.subclass = control;
1049
1050         return ast_queue_frame(chan, &f);
1051 }
1052
1053 /*! \brief Queue a control frame with payload */
1054 int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control,
1055                            const void *data, size_t datalen)
1056 {
1057         struct ast_frame f = { AST_FRAME_CONTROL, };
1058
1059         f.subclass = control;
1060         f.data.ptr = (void *) data;
1061         f.datalen = datalen;
1062
1063         return ast_queue_frame(chan, &f);
1064 }
1065
1066 /*! \brief Set defer DTMF flag on channel */
1067 int ast_channel_defer_dtmf(struct ast_channel *chan)
1068 {
1069         int pre = 0;
1070
1071         if (chan) {
1072                 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
1073                 ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
1074         }
1075         return pre;
1076 }
1077
1078 /*! \brief Unset defer DTMF flag on channel */
1079 void ast_channel_undefer_dtmf(struct ast_channel *chan)
1080 {
1081         if (chan)
1082                 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
1083 }
1084
1085 /*!
1086  * \brief Helper function to find channels.
1087  *
1088  * It supports these modes:
1089  *
1090  * prev != NULL : get channel next in list after prev
1091  * name != NULL : get channel with matching name
1092  * name != NULL && namelen != 0 : get channel whose name starts with prefix
1093  * exten != NULL : get channel whose exten or macroexten matches
1094  * context != NULL && exten != NULL : get channel whose context or macrocontext
1095  *
1096  * It returns with the channel's lock held. If getting the individual lock fails,
1097  * unlock and retry quickly up to 10 times, then give up.
1098  *
1099  * \note XXX Note that this code has cost O(N) because of the need to verify
1100  * that the object is still on the global list.
1101  *
1102  * \note XXX also note that accessing fields (e.g. c->name in ast_log())
1103  * can only be done with the lock held or someone could delete the
1104  * object while we work on it. This causes some ugliness in the code.
1105  * Note that removing the first ast_log() may be harmful, as it would
1106  * shorten the retry period and possibly cause failures.
1107  * We should definitely go for a better scheme that is deadlock-free.
1108  */
1109 static struct ast_channel *channel_find_locked(const struct ast_channel *prev,
1110                                                const char *name, const int namelen,
1111                                                const char *context, const char *exten)
1112 {
1113         const char *msg = prev ? "deadlock" : "initial deadlock";
1114         int retries;
1115         struct ast_channel *c;
1116         const struct ast_channel *_prev = prev;
1117
1118         for (retries = 0; retries < 200; retries++) {
1119                 int done;
1120                 AST_RWLIST_RDLOCK(&channels);
1121                 AST_RWLIST_TRAVERSE(&channels, c, chan_list) {
1122                         prev = _prev;
1123                         if (prev) {     /* look for next item */
1124                                 if (c != prev)  /* not this one */
1125                                         continue;
1126                                 /* found, prepare to return c->next */
1127                                 if ((c = AST_RWLIST_NEXT(c, chan_list)) == NULL) break;
1128                                 /* If prev was the last item on the channel list, then we just
1129                                  * want to return NULL, instead of trying to deref NULL in the
1130                                  * next section.
1131                                  */
1132                                 prev = NULL;
1133                                 /* We want prev to be NULL in case we end up doing more searching through
1134                                  * the channel list to find the channel (ie: name searching). If we didn't
1135                                  * set this to NULL the logic would just blow up
1136                                  * XXX Need a better explanation for this ...
1137                                  */
1138                         }
1139                         if (name) { /* want match by name */
1140                                 if ((!namelen && strcasecmp(c->name, name) && strcmp(c->uniqueid, name)) ||
1141                                     (namelen && strncasecmp(c->name, name, namelen)))
1142                                         continue;       /* name match failed */
1143                         } else if (exten) {
1144                                 if (context && strcasecmp(c->context, context) &&
1145                                     strcasecmp(c->macrocontext, context))
1146                                         continue;       /* context match failed */
1147                                 if (strcasecmp(c->exten, exten) &&
1148                                     strcasecmp(c->macroexten, exten))
1149                                         continue;       /* exten match failed */
1150                         }
1151                         /* if we get here, c points to the desired record */
1152                         break;
1153                 }
1154                 /* exit if chan not found or mutex acquired successfully */
1155                 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
1156                 done = c == NULL || ast_channel_trylock(c) == 0;
1157                 if (!done) {
1158                         ast_debug(1, "Avoiding %s for channel '%p'\n", msg, c);
1159                         if (retries == 199) {
1160                                 /* We are about to fail due to a deadlock, so report this
1161                                  * while we still have the list lock.
1162                                  */
1163                                 ast_debug(1, "Failure, could not lock '%p' after %d retries!\n", c, retries);
1164                                 /* As we have deadlocked, we will skip this channel and
1165                                  * see if there is another match.
1166                                  * NOTE: No point doing this for a full-name match,
1167                                  * as there can be no more matches.
1168                                  */
1169                                 if (!(name && !namelen)) {
1170                                         prev = c;
1171                                         retries = -1;
1172                                 }
1173                         }
1174                 }
1175                 AST_RWLIST_UNLOCK(&channels);
1176                 if (done)
1177                         return c;
1178                 /* If we reach this point we basically tried to lock a channel and failed. Instead of
1179                  * starting from the beginning of the list we can restore our saved pointer to the previous
1180                  * channel and start from there.
1181                  */
1182                 prev = _prev;
1183                 usleep(1);      /* give other threads a chance before retrying */
1184         }
1185
1186         return NULL;
1187 }
1188
1189 /*! \brief Browse channels in use */
1190 struct ast_channel *ast_channel_walk_locked(const struct ast_channel *prev)
1191 {
1192         return channel_find_locked(prev, NULL, 0, NULL, NULL);
1193 }
1194
1195 /*! \brief Get channel by name and lock it */
1196 struct ast_channel *ast_get_channel_by_name_locked(const char *name)
1197 {
1198         return channel_find_locked(NULL, name, 0, NULL, NULL);
1199 }
1200
1201 /*! \brief Get channel by name prefix and lock it */
1202 struct ast_channel *ast_get_channel_by_name_prefix_locked(const char *name, const int namelen)
1203 {
1204         return channel_find_locked(NULL, name, namelen, NULL, NULL);
1205 }
1206
1207 /*! \brief Get next channel by name prefix and lock it */
1208 struct ast_channel *ast_walk_channel_by_name_prefix_locked(const struct ast_channel *chan, const char *name,
1209                                                            const int namelen)
1210 {
1211         return channel_find_locked(chan, name, namelen, NULL, NULL);
1212 }
1213
1214 /*! \brief Get channel by exten (and optionally context) and lock it */
1215 struct ast_channel *ast_get_channel_by_exten_locked(const char *exten, const char *context)
1216 {
1217         return channel_find_locked(NULL, NULL, 0, context, exten);
1218 }
1219
1220 /*! \brief Get next channel by exten (and optionally context) and lock it */
1221 struct ast_channel *ast_walk_channel_by_exten_locked(const struct ast_channel *chan, const char *exten,
1222                                                      const char *context)
1223 {
1224         return channel_find_locked(chan, NULL, 0, context, exten);
1225 }
1226
1227 /*! \brief Wait, look for hangups and condition arg */
1228 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data)
1229 {
1230         struct ast_frame *f;
1231
1232         while (ms > 0) {
1233                 if (cond && ((*cond)(data) == 0))
1234                         return 0;
1235                 ms = ast_waitfor(chan, ms);
1236                 if (ms < 0)
1237                         return -1;
1238                 if (ms > 0) {
1239                         f = ast_read(chan);
1240                         if (!f)
1241                                 return -1;
1242                         ast_frfree(f);
1243                 }
1244         }
1245         return 0;
1246 }
1247
1248 /*! \brief Wait, look for hangups */
1249 int ast_safe_sleep(struct ast_channel *chan, int ms)
1250 {
1251         return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
1252 }
1253
1254 static void free_cid(struct ast_callerid *cid)
1255 {
1256         if (cid->cid_dnid)
1257                 ast_free(cid->cid_dnid);
1258         if (cid->cid_num)
1259                 ast_free(cid->cid_num); 
1260         if (cid->cid_name)
1261                 ast_free(cid->cid_name);        
1262         if (cid->cid_ani)
1263                 ast_free(cid->cid_ani);
1264         if (cid->cid_rdnis)
1265                 ast_free(cid->cid_rdnis);
1266         cid->cid_dnid = cid->cid_num = cid->cid_name = cid->cid_ani = cid->cid_rdnis = NULL;
1267 }
1268
1269 /*! \brief Free a channel structure */
1270 void ast_channel_free(struct ast_channel *chan)
1271 {
1272         int fd;
1273 #ifdef HAVE_EPOLL
1274         int i;
1275 #endif
1276         struct ast_var_t *vardata;
1277         struct ast_frame *f;
1278         struct varshead *headp;
1279         struct ast_datastore *datastore = NULL;
1280         char name[AST_CHANNEL_NAME], *dashptr;
1281         
1282         headp=&chan->varshead;
1283         
1284         AST_RWLIST_WRLOCK(&channels);
1285         if (!AST_RWLIST_REMOVE(&channels, chan, chan_list)) {
1286                 AST_RWLIST_UNLOCK(&channels);
1287                 ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
1288         }
1289         /* Lock and unlock the channel just to be sure nobody has it locked still
1290            due to a reference retrieved from the channel list. */
1291         ast_channel_lock(chan);
1292         ast_channel_unlock(chan);
1293
1294         /* Get rid of each of the data stores on the channel */
1295         while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
1296                 /* Free the data store */
1297                 ast_channel_datastore_free(datastore);
1298
1299         /* Lock and unlock the channel just to be sure nobody has it locked still
1300            due to a reference that was stored in a datastore. (i.e. app_chanspy) */
1301         ast_channel_lock(chan);
1302         ast_channel_unlock(chan);
1303
1304         if (chan->tech_pvt) {
1305                 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
1306                 ast_free(chan->tech_pvt);
1307         }
1308
1309         if (chan->sched)
1310                 sched_context_destroy(chan->sched);
1311
1312         ast_copy_string(name, chan->name, sizeof(name));
1313         if ((dashptr = strrchr(name, '-'))) {
1314                 *dashptr = '\0';
1315         }
1316
1317         /* Stop monitoring */
1318         if (chan->monitor)
1319                 chan->monitor->stop( chan, 0 );
1320
1321         /* If there is native format music-on-hold state, free it */
1322         if (chan->music_state)
1323                 ast_moh_cleanup(chan);
1324
1325         /* Free translators */
1326         if (chan->readtrans)
1327                 ast_translator_free_path(chan->readtrans);
1328         if (chan->writetrans)
1329                 ast_translator_free_path(chan->writetrans);
1330         if (chan->pbx)
1331                 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
1332         free_cid(&chan->cid);
1333         /* Close pipes if appropriate */
1334         if ((fd = chan->alertpipe[0]) > -1)
1335                 close(fd);
1336         if ((fd = chan->alertpipe[1]) > -1)
1337                 close(fd);
1338         if ((fd = chan->timingfd) > -1)
1339                 ast_timer_close(fd);
1340 #ifdef HAVE_EPOLL
1341         for (i = 0; i < AST_MAX_FDS; i++) {
1342                 if (chan->epfd_data[i])
1343                         free(chan->epfd_data[i]);
1344         }
1345         close(chan->epfd);
1346 #endif
1347         while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
1348                 ast_frfree(f);
1349         
1350         /* loop over the variables list, freeing all data and deleting list items */
1351         /* no need to lock the list, as the channel is already locked */
1352         
1353         while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
1354                 ast_var_delete(vardata);
1355
1356         ast_app_group_discard(chan);
1357
1358         /* Destroy the jitterbuffer */
1359         ast_jb_destroy(chan);
1360         
1361         ast_mutex_destroy(&chan->lock_dont_use);
1362
1363         ast_string_field_free_memory(chan);
1364         ast_free(chan);
1365         AST_RWLIST_UNLOCK(&channels);
1366
1367         ast_devstate_changed_literal(AST_DEVICE_NOT_INUSE, name);
1368 }
1369
1370 struct ast_datastore *ast_channel_datastore_alloc(const struct ast_datastore_info *info, const char *uid)
1371 {
1372         struct ast_datastore *datastore = NULL;
1373
1374         /* Make sure we at least have type so we can identify this */
1375         if (!info) {
1376                 return NULL;
1377         }
1378
1379         /* Allocate memory for datastore and clear it */
1380         datastore = ast_calloc(1, sizeof(*datastore));
1381         if (!datastore) {
1382                 return NULL;
1383         }
1384
1385         datastore->info = info;
1386
1387         datastore->uid = ast_strdup(uid);
1388
1389         return datastore;
1390 }
1391
1392 int ast_channel_datastore_free(struct ast_datastore *datastore)
1393 {
1394         int res = 0;
1395
1396         /* Using the destroy function (if present) destroy the data */
1397         if (datastore->info->destroy != NULL && datastore->data != NULL) {
1398                 datastore->info->destroy(datastore->data);
1399                 datastore->data = NULL;
1400         }
1401
1402         /* Free allocated UID memory */
1403         if (datastore->uid != NULL) {
1404                 ast_free((void *) datastore->uid);
1405                 datastore->uid = NULL;
1406         }
1407
1408         /* Finally free memory used by ourselves */
1409         ast_free(datastore);
1410
1411         return res;
1412 }
1413
1414 int ast_channel_datastore_inherit(struct ast_channel *from, struct ast_channel *to)
1415 {
1416         struct ast_datastore *datastore = NULL, *datastore2;
1417
1418         AST_LIST_TRAVERSE(&from->datastores, datastore, entry) {
1419                 if (datastore->inheritance > 0) {
1420                         datastore2 = ast_channel_datastore_alloc(datastore->info, datastore->uid);
1421                         if (datastore2) {
1422                                 datastore2->data = datastore->info->duplicate(datastore->data);
1423                                 datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
1424                                 AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry);
1425                         }
1426                 }
1427         }
1428         return 0;
1429 }
1430
1431 int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
1432 {
1433         int res = 0;
1434
1435         AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
1436
1437         return res;
1438 }
1439
1440 int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
1441 {
1442         return AST_LIST_REMOVE(&chan->datastores, datastore, entry) ? 0 : -1;
1443 }
1444
1445 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
1446 {
1447         struct ast_datastore *datastore = NULL;
1448         
1449         if (info == NULL)
1450                 return NULL;
1451
1452         AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
1453                 if (datastore->info == info) {
1454                         if (uid != NULL && datastore->uid != NULL) {
1455                                 if (!strcasecmp(uid, datastore->uid)) {
1456                                         /* Matched by type AND uid */
1457                                         break;
1458                                 }
1459                         } else {
1460                                 /* Matched by type at least */
1461                                 break;
1462                         }
1463                 }
1464         }
1465         AST_LIST_TRAVERSE_SAFE_END
1466
1467         return datastore;
1468 }
1469
1470 /*! Set the file descriptor on the channel */
1471 void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
1472 {
1473 #ifdef HAVE_EPOLL
1474         struct epoll_event ev;
1475         struct ast_epoll_data *aed = NULL;
1476
1477         if (chan->fds[which] > -1) {
1478                 epoll_ctl(chan->epfd, EPOLL_CTL_DEL, chan->fds[which], &ev);
1479                 aed = chan->epfd_data[which];
1480         }
1481
1482         /* If this new fd is valid, add it to the epoll */
1483         if (fd > -1) {
1484                 if (!aed && (!(aed = ast_calloc(1, sizeof(*aed)))))
1485                         return;
1486                 
1487                 chan->epfd_data[which] = aed;
1488                 aed->chan = chan;
1489                 aed->which = which;
1490                 
1491                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1492                 ev.data.ptr = aed;
1493                 epoll_ctl(chan->epfd, EPOLL_CTL_ADD, fd, &ev);
1494         } else if (aed) {
1495                 /* We don't have to keep around this epoll data structure now */
1496                 free(aed);
1497                 chan->epfd_data[which] = NULL;
1498         }
1499 #endif
1500         chan->fds[which] = fd;
1501         return;
1502 }
1503
1504 /*! Add a channel to an optimized waitfor */
1505 void ast_poll_channel_add(struct ast_channel *chan0, struct ast_channel *chan1)
1506 {
1507 #ifdef HAVE_EPOLL
1508         struct epoll_event ev;
1509         int i = 0;
1510
1511         if (chan0->epfd == -1)
1512                 return;
1513
1514         /* Iterate through the file descriptors on chan1, adding them to chan0 */
1515         for (i = 0; i < AST_MAX_FDS; i++) {
1516                 if (chan1->fds[i] == -1)
1517                         continue;
1518                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1519                 ev.data.ptr = chan1->epfd_data[i];
1520                 epoll_ctl(chan0->epfd, EPOLL_CTL_ADD, chan1->fds[i], &ev);
1521         }
1522
1523 #endif
1524         return;
1525 }
1526
1527 /*! Delete a channel from an optimized waitfor */
1528 void ast_poll_channel_del(struct ast_channel *chan0, struct ast_channel *chan1)
1529 {
1530 #ifdef HAVE_EPOLL
1531         struct epoll_event ev;
1532         int i = 0;
1533
1534         if (chan0->epfd == -1)
1535                 return;
1536
1537         for (i = 0; i < AST_MAX_FDS; i++) {
1538                 if (chan1->fds[i] == -1)
1539                         continue;
1540                 epoll_ctl(chan0->epfd, EPOLL_CTL_DEL, chan1->fds[i], &ev);
1541         }
1542
1543 #endif
1544         return;
1545 }
1546
1547 /*! \brief Softly hangup a channel, don't lock */
1548 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
1549 {
1550         ast_debug(1, "Soft-Hanging up channel '%s'\n", chan->name);
1551         /* Inform channel driver that we need to be hung up, if it cares */
1552         chan->_softhangup |= cause;
1553         ast_queue_frame(chan, &ast_null_frame);
1554         /* Interrupt any poll call or such */
1555         if (ast_test_flag(chan, AST_FLAG_BLOCKING))
1556                 pthread_kill(chan->blocker, SIGURG);
1557         return 0;
1558 }
1559
1560 /*! \brief Softly hangup a channel, lock */
1561 int ast_softhangup(struct ast_channel *chan, int cause)
1562 {
1563         int res;
1564
1565         ast_channel_lock(chan);
1566         res = ast_softhangup_nolock(chan, cause);
1567         ast_channel_unlock(chan);
1568
1569         return res;
1570 }
1571
1572 static void free_translation(struct ast_channel *clone)
1573 {
1574         if (clone->writetrans)
1575                 ast_translator_free_path(clone->writetrans);
1576         if (clone->readtrans)
1577                 ast_translator_free_path(clone->readtrans);
1578         clone->writetrans = NULL;
1579         clone->readtrans = NULL;
1580         clone->rawwriteformat = clone->nativeformats;
1581         clone->rawreadformat = clone->nativeformats;
1582 }
1583
1584 /*! \brief Hangup a channel */
1585 int ast_hangup(struct ast_channel *chan)
1586 {
1587         int res = 0;
1588
1589         /* Don't actually hang up a channel that will masquerade as someone else, or
1590            if someone is going to masquerade as us */
1591         ast_channel_lock(chan);
1592
1593         if (chan->audiohooks) {
1594                 ast_audiohook_detach_list(chan->audiohooks);
1595                 chan->audiohooks = NULL;
1596         }
1597
1598         ast_autoservice_stop(chan);
1599
1600         if (chan->masq) {
1601                 if (ast_do_masquerade(chan))
1602                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1603         }
1604
1605         if (chan->masq) {
1606                 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
1607                 ast_channel_unlock(chan);
1608                 return 0;
1609         }
1610         /* If this channel is one which will be masqueraded into something,
1611            mark it as a zombie already, so we know to free it later */
1612         if (chan->masqr) {
1613                 ast_set_flag(chan, AST_FLAG_ZOMBIE);
1614                 ast_channel_unlock(chan);
1615                 return 0;
1616         }
1617         free_translation(chan);
1618         /* Close audio stream */
1619         if (chan->stream) {
1620                 ast_closestream(chan->stream);
1621                 chan->stream = NULL;
1622         }
1623         /* Close video stream */
1624         if (chan->vstream) {
1625                 ast_closestream(chan->vstream);
1626                 chan->vstream = NULL;
1627         }
1628         if (chan->sched) {
1629                 sched_context_destroy(chan->sched);
1630                 chan->sched = NULL;
1631         }
1632         
1633         if (chan->generatordata)        /* Clear any tone stuff remaining */
1634                 if (chan->generator && chan->generator->release)
1635                         chan->generator->release(chan, chan->generatordata);
1636         chan->generatordata = NULL;
1637         chan->generator = NULL;
1638         if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1639                 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
1640                                         "is blocked by thread %ld in procedure %s!  Expect a failure\n",
1641                                         (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
1642                 ast_assert(ast_test_flag(chan, AST_FLAG_BLOCKING) == 0);
1643         }
1644         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
1645                 ast_debug(1, "Hanging up channel '%s'\n", chan->name);
1646                 if (chan->tech->hangup)
1647                         res = chan->tech->hangup(chan);
1648         } else {
1649                 ast_debug(1, "Hanging up zombie '%s'\n", chan->name);
1650         }
1651                         
1652         ast_channel_unlock(chan);
1653         manager_event(EVENT_FLAG_CALL, "Hangup",
1654                         "Channel: %s\r\n"
1655                         "Uniqueid: %s\r\n"
1656                         "CallerIDNum: %s\r\n"
1657                         "CallerIDName: %s\r\n"
1658                         "Cause: %d\r\n"
1659                         "Cause-txt: %s\r\n",
1660                         chan->name,
1661                         chan->uniqueid,
1662                         S_OR(chan->cid.cid_num, "<unknown>"),
1663                         S_OR(chan->cid.cid_name, "<unknown>"),
1664                         chan->hangupcause,
1665                         ast_cause2str(chan->hangupcause)
1666                         );
1667
1668         if (chan->cdr && !ast_test_flag(chan->cdr, AST_CDR_FLAG_BRIDGED) && !ast_test_flag(chan->cdr, AST_CDR_FLAG_POST_DISABLED) && chan->cdr->disposition != AST_CDR_NULL) {
1669                 ast_cdr_end(chan->cdr);
1670                 ast_cdr_detach(chan->cdr);
1671         }
1672         
1673         ast_channel_free(chan);
1674
1675         return res;
1676 }
1677
1678 int __ast_answer(struct ast_channel *chan, unsigned int delay)
1679 {
1680         int res = 0;
1681
1682         ast_channel_lock(chan);
1683
1684         /* You can't answer an outbound call */
1685         if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
1686                 ast_channel_unlock(chan);
1687                 return 0;
1688         }
1689
1690         /* Stop if we're a zombie or need a soft hangup */
1691         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1692                 ast_channel_unlock(chan);
1693                 return -1;
1694         }
1695
1696         switch (chan->_state) {
1697         case AST_STATE_RINGING:
1698         case AST_STATE_RING:
1699                 if (delay) {
1700                         int needanswer = (chan->tech->answer != NULL);
1701
1702                         ast_cdr_answer(chan->cdr);
1703                         ast_channel_unlock(chan);
1704                         ast_safe_sleep(chan, delay);
1705                         /* don't tell the channel it has been answered until *after* the delay,
1706                            so that the media path will be in place and usable when it wants to
1707                            send media
1708                         */
1709                         if (needanswer) {
1710                                 ast_channel_lock(chan);
1711                                 res = chan->tech->answer(chan);
1712                                 ast_channel_unlock(chan);
1713                         }
1714                         ast_setstate(chan, AST_STATE_UP);       
1715                 } else {
1716                         if (chan->tech->answer) {
1717                                 res = chan->tech->answer(chan);
1718                         }
1719                         ast_setstate(chan, AST_STATE_UP);
1720                         ast_cdr_answer(chan->cdr);
1721                         ast_channel_unlock(chan);
1722                 }
1723                 return res;
1724         case AST_STATE_UP:
1725                 break;
1726         default:
1727                 break;
1728         }
1729         chan->visible_indication = 0;
1730         ast_channel_unlock(chan);
1731
1732         return res;
1733 }
1734
1735 int ast_answer(struct ast_channel *chan)
1736 {
1737         return __ast_answer(chan, 500);
1738 }
1739
1740 void ast_deactivate_generator(struct ast_channel *chan)
1741 {
1742         ast_channel_lock(chan);
1743         if (chan->generatordata) {
1744                 if (chan->generator && chan->generator->release)
1745                         chan->generator->release(chan, chan->generatordata);
1746                 chan->generatordata = NULL;
1747                 chan->generator = NULL;
1748                 ast_channel_set_fd(chan, AST_GENERATOR_FD, -1);
1749                 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1750                 ast_settimeout(chan, 0, NULL, NULL);
1751         }
1752         ast_channel_unlock(chan);
1753 }
1754
1755 static int generator_force(const void *data)
1756 {
1757         /* Called if generator doesn't have data */
1758         void *tmp;
1759         int res;
1760         int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL;
1761         struct ast_channel *chan = (struct ast_channel *)data;
1762
1763         ast_channel_lock(chan);
1764         tmp = chan->generatordata;
1765         chan->generatordata = NULL;
1766         if (chan->generator)
1767                 generate = chan->generator->generate;
1768         ast_channel_unlock(chan);
1769
1770         if (!tmp || !generate)
1771                 return 0;
1772
1773         res = generate(chan, tmp, 0, ast_format_rate(chan->writeformat & AST_FORMAT_AUDIO_MASK) / 50);
1774
1775         chan->generatordata = tmp;
1776
1777         if (res) {
1778                 ast_debug(1, "Auto-deactivating generator\n");
1779                 ast_deactivate_generator(chan);
1780         }
1781
1782         return 0;
1783 }
1784
1785 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1786 {
1787         int res = 0;
1788
1789         ast_channel_lock(chan);
1790
1791         if (chan->generatordata) {
1792                 if (chan->generator && chan->generator->release)
1793                         chan->generator->release(chan, chan->generatordata);
1794                 chan->generatordata = NULL;
1795         }
1796
1797         ast_prod(chan);
1798         if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1799                 res = -1;
1800         }
1801         
1802         if (!res) {
1803                 ast_settimeout(chan, 50, generator_force, chan);
1804                 chan->generator = gen;
1805         }
1806
1807         ast_channel_unlock(chan);
1808
1809         return res;
1810 }
1811
1812 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1813 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1814 {
1815         int winner = -1;
1816         ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1817         return winner;
1818 }
1819
1820 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1821 #ifdef HAVE_EPOLL
1822 static struct ast_channel *ast_waitfor_nandfds_classic(struct ast_channel **c, int n, int *fds, int nfds,
1823                                         int *exception, int *outfd, int *ms)
1824 #else
1825 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1826                                         int *exception, int *outfd, int *ms)
1827 #endif
1828 {
1829         struct timeval start = { 0 , 0 };
1830         struct pollfd *pfds = NULL;
1831         int res;
1832         long rms;
1833         int x, y, max;
1834         int sz;
1835         struct timeval now = { 0, 0 };
1836         struct timeval whentohangup = { 0, 0 }, diff;
1837         struct ast_channel *winner = NULL;
1838         struct fdmap {
1839                 int chan;
1840                 int fdno;
1841         } *fdmap = NULL;
1842
1843         if ((sz = n * AST_MAX_FDS + nfds)) {
1844                 pfds = alloca(sizeof(*pfds) * sz);
1845                 fdmap = alloca(sizeof(*fdmap) * sz);
1846         }
1847
1848         if (outfd)
1849                 *outfd = -99999;
1850         if (exception)
1851                 *exception = 0;
1852         
1853         /* Perform any pending masquerades */
1854         for (x = 0; x < n; x++) {
1855                 ast_channel_lock(c[x]);
1856                 if (c[x]->masq && ast_do_masquerade(c[x])) {
1857                         ast_log(LOG_WARNING, "Masquerade failed\n");
1858                         *ms = -1;
1859                         ast_channel_unlock(c[x]);
1860                         return NULL;
1861                 }
1862                 if (!ast_tvzero(c[x]->whentohangup)) {
1863                         if (ast_tvzero(whentohangup))
1864                                 now = ast_tvnow();
1865                         diff = ast_tvsub(c[x]->whentohangup, now);
1866                         if (diff.tv_sec < 0 || ast_tvzero(diff)) {
1867                                 /* Should already be hungup */
1868                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1869                                 ast_channel_unlock(c[x]);
1870                                 return c[x];
1871                         }
1872                         if (ast_tvzero(whentohangup) || ast_tvcmp(diff, whentohangup) < 0)
1873                                 whentohangup = diff;
1874                 }
1875                 ast_channel_unlock(c[x]);
1876         }
1877         /* Wait full interval */
1878         rms = *ms;
1879         if (!ast_tvzero(whentohangup)) {
1880                 rms = whentohangup.tv_sec * 1000 + whentohangup.tv_usec / 1000;              /* timeout in milliseconds */
1881                 if (*ms >= 0 && *ms < rms)              /* original *ms still smaller */
1882                         rms =  *ms;
1883         }
1884         /*
1885          * Build the pollfd array, putting the channels' fds first,
1886          * followed by individual fds. Order is important because
1887          * individual fd's must have priority over channel fds.
1888          */
1889         max = 0;
1890         for (x = 0; x < n; x++) {
1891                 for (y = 0; y < AST_MAX_FDS; y++) {
1892                         fdmap[max].fdno = y;  /* fd y is linked to this pfds */
1893                         fdmap[max].chan = x;  /* channel x is linked to this pfds */
1894                         max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1895                 }
1896                 CHECK_BLOCKING(c[x]);
1897         }
1898         /* Add the individual fds */
1899         for (x = 0; x < nfds; x++) {
1900                 fdmap[max].chan = -1;
1901                 max += ast_add_fd(&pfds[max], fds[x]);
1902         }
1903
1904         if (*ms > 0)
1905                 start = ast_tvnow();
1906         
1907         if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1908                 do {
1909                         int kbrms = rms;
1910                         if (kbrms > 600000)
1911                                 kbrms = 600000;
1912                         res = poll(pfds, max, kbrms);
1913                         if (!res)
1914                                 rms -= kbrms;
1915                 } while (!res && (rms > 0));
1916         } else {
1917                 res = poll(pfds, max, rms);
1918         }
1919         for (x = 0; x < n; x++)
1920                 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1921         if (res < 0) { /* Simulate a timeout if we were interrupted */
1922                 if (errno != EINTR)
1923                         *ms = -1;
1924                 return NULL;
1925         }
1926         if (!ast_tvzero(whentohangup)) {   /* if we have a timeout, check who expired */
1927                 now = ast_tvnow();
1928                 for (x = 0; x < n; x++) {
1929                         if (!ast_tvzero(c[x]->whentohangup) && ast_tvcmp(c[x]->whentohangup, now) <= 0) {
1930                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1931                                 if (winner == NULL)
1932                                         winner = c[x];
1933                         }
1934                 }
1935         }
1936         if (res == 0) { /* no fd ready, reset timeout and done */
1937                 *ms = 0;        /* XXX use 0 since we may not have an exact timeout. */
1938                 return winner;
1939         }
1940         /*
1941          * Then check if any channel or fd has a pending event.
1942          * Remember to check channels first and fds last, as they
1943          * must have priority on setting 'winner'
1944          */
1945         for (x = 0; x < max; x++) {
1946                 res = pfds[x].revents;
1947                 if (res == 0)
1948                         continue;
1949                 if (fdmap[x].chan >= 0) {       /* this is a channel */
1950                         winner = c[fdmap[x].chan];      /* override previous winners */
1951                         if (res & POLLPRI)
1952                                 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1953                         else
1954                                 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1955                         winner->fdno = fdmap[x].fdno;
1956                 } else {                        /* this is an fd */
1957                         if (outfd)
1958                                 *outfd = pfds[x].fd;
1959                         if (exception)
1960                                 *exception = (res & POLLPRI) ? -1 : 0;
1961                         winner = NULL;
1962                 }
1963         }
1964         if (*ms > 0) {
1965                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1966                 if (*ms < 0)
1967                         *ms = 0;
1968         }
1969         return winner;
1970 }
1971
1972 #ifdef HAVE_EPOLL
1973 static struct ast_channel *ast_waitfor_nandfds_simple(struct ast_channel *chan, int *ms)
1974 {
1975         struct timeval start = { 0 , 0 };
1976         int res = 0;
1977         struct epoll_event ev[1];
1978         long diff, rms = *ms;
1979         struct ast_channel *winner = NULL;
1980         struct ast_epoll_data *aed = NULL;
1981
1982         ast_channel_lock(chan);
1983
1984         /* See if this channel needs to be masqueraded */
1985         if (chan->masq && ast_do_masquerade(chan)) {
1986                 ast_log(LOG_WARNING, "Failed to perform masquerade on %s\n", chan->name);
1987                 *ms = -1;
1988                 ast_channel_unlock(chan);
1989                 return NULL;
1990         }
1991
1992         /* Figure out their timeout */
1993         if (!ast_tvzero(chan->whentohangup)) {
1994                 if ((diff = ast_tvdiff_ms(chan->whentohangup, ast_tvnow())) < 0) {
1995                         /* They should already be hungup! */
1996                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1997                         ast_channel_unlock(chan);
1998                         return NULL;
1999                 }
2000                 /* If this value is smaller then the current one... make it priority */
2001                 if (rms > diff)
2002                         rms = diff;
2003         }
2004
2005         ast_channel_unlock(chan);
2006
2007         /* Time to make this channel block... */
2008         CHECK_BLOCKING(chan);
2009
2010         if (*ms > 0)
2011                 start = ast_tvnow();
2012
2013         /* We don't have to add any file descriptors... they are already added, we just have to wait! */
2014         res = epoll_wait(chan->epfd, ev, 1, rms);
2015
2016         /* Stop blocking */
2017         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2018
2019         /* Simulate a timeout if we were interrupted */
2020         if (res < 0) {
2021                 if (errno != EINTR)
2022                         *ms = -1;
2023                 return NULL;
2024         }
2025
2026         /* If this channel has a timeout see if it expired */
2027         if (!ast_tvzero(chan->whentohangup)) {
2028                 if (ast_tvdiff_ms(ast_tvnow(), chan->whentohangup) >= 0) {
2029                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2030                         winner = chan;
2031                 }
2032         }
2033
2034         /* No fd ready, reset timeout and be done for now */
2035         if (!res) {
2036                 *ms = 0;
2037                 return winner;
2038         }
2039
2040         /* See what events are pending */
2041         aed = ev[0].data.ptr;
2042         chan->fdno = aed->which;
2043         if (ev[0].events & EPOLLPRI)
2044                 ast_set_flag(chan, AST_FLAG_EXCEPTION);
2045         else
2046                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2047
2048         if (*ms > 0) {
2049                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
2050                 if (*ms < 0)
2051                         *ms = 0;
2052         }
2053
2054         return chan;
2055 }
2056
2057 static struct ast_channel *ast_waitfor_nandfds_complex(struct ast_channel **c, int n, int *ms)
2058 {
2059         struct timeval start = { 0 , 0 };
2060         int res = 0, i;
2061         struct epoll_event ev[25] = { { 0, } };
2062         struct timeval now = { 0, 0 };
2063         long whentohangup = 0, diff = 0, rms = *ms;
2064         struct ast_channel *winner = NULL;
2065
2066         for (i = 0; i < n; i++) {
2067                 ast_channel_lock(c[i]);
2068                 if (c[i]->masq && ast_do_masquerade(c[i])) {
2069                         ast_log(LOG_WARNING, "Masquerade failed\n");
2070                         *ms = -1;
2071                         ast_channel_unlock(c[i]);
2072                         return NULL;
2073                 }
2074                 if (!ast_tvzero(c[i]->whentohangup)) {
2075                         if (whentohangup == 0)
2076                                 now = ast_tvnow();
2077                         if ((diff = ast_tvdiff_ms(c[i]->whentohangup, now)) < 0) {
2078                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2079                                 ast_channel_unlock(c[i]);
2080                                 return c[i];
2081                         }
2082                         if (!whentohangup || whentohangup > diff)
2083                                 whentohangup = diff;
2084                 }
2085                 ast_channel_unlock(c[i]);
2086                 CHECK_BLOCKING(c[i]);
2087         }
2088
2089         rms = *ms;
2090         if (whentohangup) {
2091                 rms = whentohangup;
2092                 if (*ms >= 0 && *ms < rms)
2093                         rms = *ms;
2094         }
2095
2096         if (*ms > 0)
2097                 start = ast_tvnow();
2098
2099         res = epoll_wait(c[0]->epfd, ev, 25, rms);
2100
2101         for (i = 0; i < n; i++)
2102                 ast_clear_flag(c[i], AST_FLAG_BLOCKING);
2103
2104         if (res < 0) {
2105                 if (errno != EINTR)
2106                         *ms = -1;
2107                 return NULL;
2108         }
2109
2110         if (whentohangup) {
2111                 now = ast_tvnow();
2112                 for (i = 0; i < n; i++) {
2113                         if (!ast_tvzero(c[i]->whentohangup) && ast_tvdiff_ms(now, c[i]->whentohangup) >= 0) {
2114                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2115                                 if (!winner)
2116                                         winner = c[i];
2117                         }
2118                 }
2119         }
2120
2121         if (!res) {
2122                 *ms = 0;
2123                 return winner;
2124         }
2125
2126         for (i = 0; i < res; i++) {
2127                 struct ast_epoll_data *aed = ev[i].data.ptr;
2128
2129                 if (!ev[i].events || !aed)
2130                         continue;
2131
2132                 winner = aed->chan;
2133                 if (ev[i].events & EPOLLPRI)
2134                         ast_set_flag(winner, AST_FLAG_EXCEPTION);
2135                 else
2136                         ast_clear_flag(winner, AST_FLAG_EXCEPTION);
2137                 winner->fdno = aed->which;
2138         }
2139
2140         if (*ms > 0) {
2141                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
2142                 if (*ms < 0)
2143                         *ms = 0;
2144         }
2145
2146         return winner;
2147 }
2148
2149 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
2150                                         int *exception, int *outfd, int *ms)
2151 {
2152         /* Clear all provided values in one place. */
2153         if (outfd)
2154                 *outfd = -99999;
2155         if (exception)
2156                 *exception = 0;
2157
2158         /* If no epoll file descriptor is available resort to classic nandfds */
2159         if (!n || nfds || c[0]->epfd == -1)
2160                 return ast_waitfor_nandfds_classic(c, n, fds, nfds, exception, outfd, ms);
2161         else if (!nfds && n == 1)
2162                 return ast_waitfor_nandfds_simple(c[0], ms);
2163         else
2164                 return ast_waitfor_nandfds_complex(c, n, ms);
2165 }
2166 #endif
2167
2168 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
2169 {
2170         return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
2171 }
2172
2173 int ast_waitfor(struct ast_channel *c, int ms)
2174 {
2175         int oldms = ms; /* -1 if no timeout */
2176
2177         ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
2178         if ((ms < 0) && (oldms < 0))
2179                 ms = 0;
2180         return ms;
2181 }
2182
2183 /* XXX never to be called with ms = -1 */
2184 int ast_waitfordigit(struct ast_channel *c, int ms)
2185 {
2186         return ast_waitfordigit_full(c, ms, -1, -1);
2187 }
2188
2189 int ast_settimeout(struct ast_channel *c, unsigned int rate, int (*func)(const void *data), void *data)
2190 {
2191         int res;
2192         unsigned int real_rate = rate, max_rate;
2193
2194         if (c->timingfd == -1) {
2195                 return -1;
2196         }
2197
2198         if (!func) {
2199                 rate = 0;
2200                 data = NULL;
2201         }
2202
2203         if (rate && rate > (max_rate = ast_timer_get_max_rate(c->timingfd))) {
2204                 real_rate = max_rate;
2205         }
2206
2207         ast_debug(1, "Scheduling timer at (%u requested / %u actual) timer ticks per second\n", rate, real_rate);
2208
2209         res = ast_timer_set_rate(c->timingfd, real_rate);
2210
2211         c->timingfunc = func;
2212         c->timingdata = data;
2213
2214         return res;
2215 }
2216
2217 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
2218 {
2219         /* Stop if we're a zombie or need a soft hangup */
2220         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
2221                 return -1;
2222
2223         /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
2224         ast_set_flag(c, AST_FLAG_END_DTMF_ONLY);
2225
2226         /* Wait for a digit, no more than ms milliseconds total. */
2227         
2228         while (ms) {
2229                 struct ast_channel *rchan;
2230                 int outfd=-1;
2231
2232                 errno = 0;
2233                 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
2234                 
2235                 if (!rchan && outfd < 0 && ms) {
2236                         if (errno == 0 || errno == EINTR)
2237                                 continue;
2238                         ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
2239                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2240                         return -1;
2241                 } else if (outfd > -1) {
2242                         /* The FD we were watching has something waiting */
2243                         ast_log(LOG_WARNING, "The FD we were waiting for has something waiting. Waitfordigit returning numeric 1\n");
2244                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2245                         return 1;
2246                 } else if (rchan) {
2247                         int res;
2248                         struct ast_frame *f = ast_read(c);
2249                         if (!f)
2250                                 return -1;
2251
2252                         switch (f->frametype) {
2253                         case AST_FRAME_DTMF_BEGIN:
2254                                 break;
2255                         case AST_FRAME_DTMF_END:
2256                                 res = f->subclass;
2257                                 ast_frfree(f);
2258                                 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2259                                 return res;
2260                         case AST_FRAME_CONTROL:
2261                                 switch (f->subclass) {
2262                                 case AST_CONTROL_HANGUP:
2263                                         ast_frfree(f);
2264                                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2265                                         return -1;
2266                                 case AST_CONTROL_RINGING:
2267                                 case AST_CONTROL_ANSWER:
2268                                 case AST_CONTROL_SRCUPDATE:
2269                                         /* Unimportant */
2270                                         break;
2271                                 default:
2272                                         ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
2273                                         break;
2274                                 }
2275                                 break;
2276                         case AST_FRAME_VOICE:
2277                                 /* Write audio if appropriate */
2278                                 if (audiofd > -1)
2279                                         write(audiofd, f->data.ptr, f->datalen);
2280                         default:
2281                                 /* Ignore */
2282                                 break;
2283                         }
2284                         ast_frfree(f);
2285                 }
2286         }
2287
2288         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2289
2290         return 0; /* Time is up */
2291 }
2292
2293 static void send_dtmf_event(const struct ast_channel *chan, const char *direction, const char digit, const char *begin, const char *end)
2294 {
2295         manager_event(EVENT_FLAG_DTMF,
2296                         "DTMF",
2297                         "Channel: %s\r\n"
2298                         "Uniqueid: %s\r\n"
2299                         "Digit: %c\r\n"
2300                         "Direction: %s\r\n"
2301                         "Begin: %s\r\n"
2302                         "End: %s\r\n",
2303                         chan->name, chan->uniqueid, digit, direction, begin, end);
2304 }
2305
2306 static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
2307 {
2308         if (chan->generatordata &&  !ast_internal_timing_enabled(chan)) {
2309                 void *tmp = chan->generatordata;
2310                 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL;
2311                 int res;
2312                 int samples;
2313
2314                 if (chan->timingfunc) {
2315                         ast_debug(1, "Generator got voice, switching to phase locked mode\n");
2316                         ast_settimeout(chan, 0, NULL, NULL);
2317                 }
2318
2319                 chan->generatordata = NULL;     /* reset, to let writes go through */
2320
2321                 if (f->subclass != chan->writeformat) {
2322                         float factor;
2323                         factor = ((float) ast_format_rate(chan->writeformat)) / ((float) ast_format_rate(f->subclass));
2324                         samples = (int) ( ((float) f->samples) * factor );
2325                 } else {
2326                         samples = f->samples;
2327                 }
2328                 
2329                 if (chan->generator->generate) {
2330                         generate = chan->generator->generate;
2331                 }
2332                 /* This unlock is here based on two assumptions that hold true at this point in the
2333                  * code. 1) this function is only called from within __ast_read() and 2) all generators
2334                  * call ast_write() in their generate callback.
2335                  *
2336                  * The reason this is added is so that when ast_write is called, the lock that occurs 
2337                  * there will not recursively lock the channel. Doing this will cause intended deadlock 
2338                  * avoidance not to work in deeper functions
2339                  */
2340                 ast_channel_unlock(chan);
2341                 res = generate(chan, tmp, f->datalen, samples);
2342                 ast_channel_lock(chan);
2343                 chan->generatordata = tmp;
2344                 if (res) {
2345                         ast_debug(1, "Auto-deactivating generator\n");
2346                         ast_deactivate_generator(chan);
2347                 }
2348
2349         } else if (f->frametype == AST_FRAME_CNG) {
2350                 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
2351                         ast_debug(1, "Generator got CNG, switching to timed mode\n");
2352                         ast_settimeout(chan, 50, generator_force, chan);
2353                 }
2354         }
2355 }
2356
2357 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
2358 {
2359         struct ast_frame *f = NULL;     /* the return value */
2360         int blah;
2361         int prestate;
2362         int count = 0, cause = 0;
2363
2364         /* this function is very long so make sure there is only one return
2365          * point at the end (there are only two exceptions to this).
2366          */
2367         while(ast_channel_trylock(chan)) {
2368                 if(count++ > 10) 
2369                         /*cannot goto done since the channel is not locked*/
2370                         return &ast_null_frame;
2371                 usleep(1);
2372         }
2373
2374         if (chan->masq) {
2375                 if (ast_do_masquerade(chan))
2376                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2377                 else
2378                         f =  &ast_null_frame;
2379                 goto done;
2380         }
2381
2382         /* Stop if we're a zombie or need a soft hangup */
2383         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2384                 if (chan->generator)
2385                         ast_deactivate_generator(chan);
2386                 goto done;
2387         }
2388         prestate = chan->_state;
2389
2390         if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) && 
2391             !ast_strlen_zero(chan->dtmfq) && 
2392                 (ast_tvzero(chan->dtmf_tv) || ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) > AST_MIN_DTMF_GAP) ) {
2393                 /* We have DTMF that has been deferred.  Return it now */
2394                 chan->dtmff.subclass = chan->dtmfq[0];
2395                 /* Drop first digit from the buffer */
2396                 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
2397                 f = &chan->dtmff;
2398                 if (ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
2399                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2400                         chan->dtmff.frametype = AST_FRAME_DTMF_END;
2401                 } else {
2402                         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);
2403                         chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
2404                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2405                         chan->emulate_dtmf_digit = f->subclass;
2406                         chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2407                 }
2408                 chan->dtmf_tv = ast_tvnow();
2409                 goto done;
2410         }
2411         
2412         /* Read and ignore anything on the alertpipe, but read only
2413            one sizeof(blah) per frame that we send from it */
2414         if (chan->alertpipe[0] > -1) {
2415                 int flags = fcntl(chan->alertpipe[0], F_GETFL);
2416                 /* For some odd reason, the alertpipe occasionally loses nonblocking status,
2417                  * which immediately causes a deadlock scenario.  Detect and prevent this. */
2418                 if ((flags & O_NONBLOCK) == 0) {
2419                         ast_log(LOG_ERROR, "Alertpipe on channel %s lost O_NONBLOCK?!!\n", chan->name);
2420                         if (fcntl(chan->alertpipe[0], F_SETFL, flags | O_NONBLOCK) < 0) {
2421                                 ast_log(LOG_WARNING, "Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno));
2422                                 f = &ast_null_frame;
2423                                 goto done;
2424                         }
2425                 }
2426                 read(chan->alertpipe[0], &blah, sizeof(blah));
2427         }
2428
2429         if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD) {
2430                 enum ast_timing_event res;
2431
2432                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2433
2434                 res = ast_timer_get_event(chan->timingfd);
2435
2436                 switch (res) {
2437                 case AST_TIMING_EVENT_EXPIRED:
2438                         ast_timer_ack(chan->timingfd, 1);
2439
2440                         if (chan->timingfunc) {
2441                                 /* save a copy of func/data before unlocking the channel */
2442                                 int (*func)(const void *) = chan->timingfunc;
2443                                 void *data = chan->timingdata;
2444                                 ast_channel_unlock(chan);
2445                                 func(data);
2446                         } else {
2447                                 ast_timer_set_rate(chan->timingfd, 0);
2448                                 ast_channel_unlock(chan);
2449                         }
2450
2451                         /* cannot 'goto done' because the channel is already unlocked */
2452                         return &ast_null_frame;
2453
2454                 case AST_TIMING_EVENT_CONTINUOUS:
2455                         if (AST_LIST_EMPTY(&chan->readq) || 
2456                                 !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
2457                                 ast_timer_disable_continuous(chan->timingfd);
2458                         }
2459                         break;
2460                 }
2461
2462         } else if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
2463                 /* if the AST_GENERATOR_FD is set, call the generator with args
2464                  * set to -1 so it can do whatever it needs to.
2465                  */
2466                 void *tmp = chan->generatordata;
2467                 chan->generatordata = NULL;     /* reset to let ast_write get through */
2468                 chan->generator->generate(chan, tmp, -1, -1);
2469                 chan->generatordata = tmp;
2470                 f = &ast_null_frame;
2471                 goto done;
2472         }
2473
2474         /* Check for pending read queue */
2475         if (!AST_LIST_EMPTY(&chan->readq)) {
2476                 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
2477                 /* Interpret hangup and return NULL */
2478                 /* XXX why not the same for frames from the channel ? */
2479                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
2480                         cause = f->data.uint32;
2481                         ast_frfree(f);
2482                         f = NULL;
2483                 }
2484         } else {
2485                 chan->blocker = pthread_self();
2486                 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2487                         if (chan->tech->exception)
2488                                 f = chan->tech->exception(chan);
2489                         else {
2490                                 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
2491                                 f = &ast_null_frame;
2492                         }
2493                         /* Clear the exception flag */
2494                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2495                 } else if (chan->tech->read)
2496                         f = chan->tech->read(chan);
2497                 else
2498                         ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
2499         }
2500
2501         if (f) {
2502                 /* if the channel driver returned more than one frame, stuff the excess
2503                    into the readq for the next ast_read call (note that we can safely assume
2504                    that the readq is empty, because otherwise we would not have called into
2505                    the channel driver and f would be only a single frame)
2506                 */
2507                 if (AST_LIST_NEXT(f, frame_list)) {
2508                         AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
2509                         AST_LIST_NEXT(f, frame_list) = NULL;
2510                 }
2511
2512                 switch (f->frametype) {
2513                 case AST_FRAME_CONTROL:
2514                         if (f->subclass == AST_CONTROL_ANSWER) {
2515                                 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
2516                                         ast_debug(1, "Ignoring answer on an inbound call!\n");
2517                                         ast_frfree(f);
2518                                         f = &ast_null_frame;
2519                                 } else if (prestate == AST_STATE_UP) {
2520                                         ast_debug(1, "Dropping duplicate answer!\n");
2521                                         ast_frfree(f);
2522                                         f = &ast_null_frame;
2523                                 } else {
2524                                         /* Answer the CDR */
2525                                         ast_setstate(chan, AST_STATE_UP);
2526                                         /* removed a call to ast_cdr_answer(chan->cdr) from here. */
2527                                 }
2528                         }
2529                         break;
2530                 case AST_FRAME_DTMF_END:
2531                         send_dtmf_event(chan, "Received", f->subclass, "No", "Yes");
2532                         ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass, chan->name, f->len);
2533                         /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2534                          * However, only let emulation be forced if the other end cares about BEGIN frames */
2535                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF) ||
2536                                 (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) ) {
2537                                 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2538                                         ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2539                                         chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2540                                 } else
2541                                         ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2542                                 ast_frfree(f);
2543                                 f = &ast_null_frame;
2544                         } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) {
2545                                 if (!ast_tvzero(chan->dtmf_tv) && 
2546                                     ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) {
2547                                         /* If it hasn't been long enough, defer this digit */
2548                                         if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2549                                                 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2550                                                 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2551                                         } else
2552                                                 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2553                                         ast_frfree(f);
2554                                         f = &ast_null_frame;
2555                                 } else {
2556                                         /* There was no begin, turn this into a begin and send the end later */
2557                                         f->frametype = AST_FRAME_DTMF_BEGIN;
2558                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2559                                         chan->emulate_dtmf_digit = f->subclass;
2560                                         chan->dtmf_tv = ast_tvnow();
2561                                         if (f->len) {
2562                                                 if (f->len > AST_MIN_DTMF_DURATION)
2563                                                         chan->emulate_dtmf_duration = f->len;
2564                                                 else 
2565                                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION;
2566                                         } else
2567                                                 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2568                                         ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass, chan->emulate_dtmf_duration, chan->name);
2569                                 }
2570                                 if (chan->audiohooks) {
2571                                         struct ast_frame *old_frame = f;
2572                                         /*!
2573                                          * \todo XXX It is possible to write a digit to the audiohook twice
2574                                          * if the digit was originally read while the channel was in autoservice. */
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                         } else {
2580                                 struct timeval now = ast_tvnow();
2581                                 if (ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2582                                         ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass, chan->name);
2583                                         ast_clear_flag(chan, AST_FLAG_IN_DTMF);
2584                                         if (!f->len)
2585                                                 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2586                                 } else if (!f->len) {
2587                                         ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass, chan->name);
2588                                         f->len = AST_MIN_DTMF_DURATION;
2589                                 }
2590                                 if (f->len < AST_MIN_DTMF_DURATION && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
2591                                         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);
2592                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2593                                         chan->emulate_dtmf_digit = f->subclass;
2594                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len;
2595                                         ast_frfree(f);
2596                                         f = &ast_null_frame;
2597                                 } else {
2598                                         ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass, chan->name);
2599                                         if (f->len < AST_MIN_DTMF_DURATION) {
2600                                                 f->len = AST_MIN_DTMF_DURATION;
2601                                         }
2602                                         chan->dtmf_tv = now;
2603                                 }
2604                                 if (chan->audiohooks) {
2605                                         struct ast_frame *old_frame = f;
2606                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2607                                         if (old_frame != f)
2608                                                 ast_frfree(old_frame);
2609                                 }
2610                         }
2611                         break;
2612                 case AST_FRAME_DTMF_BEGIN:
2613                         send_dtmf_event(chan, "Received", f->subclass, "Yes", "No");
2614                         ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2615                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY | AST_FLAG_EMULATE_DTMF) || 
2616                             (!ast_tvzero(chan->dtmf_tv) && 
2617                               ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) {
2618                                 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass, chan->name);
2619                                 ast_frfree(f);
2620                                 f = &ast_null_frame;
2621                         } else {
2622                                 ast_set_flag(chan, AST_FLAG_IN_DTMF);
2623                                 chan->dtmf_tv = ast_tvnow();
2624                                 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass, chan->name);
2625                         }
2626                         break;
2627                 case AST_FRAME_NULL:
2628                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2629                          * is reached , because we want to make sure we pass at least one
2630                          * voice frame through before starting the next digit, to ensure a gap
2631                          * between DTMF digits. */
2632                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2633                                 struct timeval now = ast_tvnow();
2634                                 if (!chan->emulate_dtmf_duration) {
2635                                         ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2636                                         chan->emulate_dtmf_digit = 0;
2637                                 } else if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2638                                         chan->emulate_dtmf_duration = 0;
2639                                         ast_frfree(f);
2640                                         f = &chan->dtmff;
2641                                         f->frametype = AST_FRAME_DTMF_END;
2642                                         f->subclass = chan->emulate_dtmf_digit;
2643                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2644                                         chan->dtmf_tv = now;
2645                                         ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2646                                         chan->emulate_dtmf_digit = 0;
2647                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2648                                 }
2649                         }
2650                         break;
2651                 case AST_FRAME_VOICE:
2652                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2653                          * is reached , because we want to make sure we pass at least one
2654                          * voice frame through before starting the next digit, to ensure a gap
2655                          * between DTMF digits. */
2656                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) {
2657                                 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2658                                 chan->emulate_dtmf_digit = 0;
2659                         }
2660
2661                         if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2662                                 if (dropaudio)
2663                                         ast_read_generator_actions(chan, f);
2664                                 ast_frfree(f);
2665                                 f = &ast_null_frame;
2666                         }
2667
2668                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2669                                 struct timeval now = ast_tvnow();
2670                                 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2671                                         chan->emulate_dtmf_duration = 0;
2672                                         ast_frfree(f);
2673                                         f = &chan->dtmff;
2674                                         f->frametype = AST_FRAME_DTMF_END;
2675                                         f->subclass = chan->emulate_dtmf_digit;
2676                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2677                                         chan->dtmf_tv = now;
2678                                         if (chan->audiohooks) {
2679                                                 struct ast_frame *old_frame = f;
2680                                                 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2681                                                 if (old_frame != f)
2682                                                         ast_frfree(old_frame);
2683                                         }
2684                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2685                                 } else {
2686                                         /* Drop voice frames while we're still in the middle of the digit */
2687                                         ast_frfree(f);
2688                                         f = &ast_null_frame;
2689                                 }
2690                         } else if ((f->frametype == AST_FRAME_VOICE) && !(f->subclass & chan->nativeformats)) {
2691                                 /* This frame is not one of the current native formats -- drop it on the floor */
2692                                 char to[200];
2693                                 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2694                                         chan->name, ast_getformatname(f->subclass), ast_getformatname_multiple(to, sizeof(to), chan->nativeformats));
2695                                 ast_frfree(f);
2696                                 f = &ast_null_frame;
2697                         } else if ((f->frametype == AST_FRAME_VOICE)) {
2698                                 /* Send frame to audiohooks if present */
2699                                 if (chan->audiohooks) {
2700                                         struct ast_frame *old_frame = f;
2701                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2702                                         if (old_frame != f)
2703                                                 ast_frfree(old_frame);
2704                                 }
2705                                 if (chan->monitor && chan->monitor->read_stream ) {
2706                                         /* XXX what does this do ? */
2707 #ifndef MONITOR_CONSTANT_DELAY
2708                                         int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2709                                         if (jump >= 0) {
2710                                                 jump = chan->outsmpl - chan->insmpl;
2711                                                 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1)
2712                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2713                                                 chan->insmpl += jump + f->samples;
2714                                         } else
2715                                                 chan->insmpl+= f->samples;
2716 #else
2717                                         int jump = chan->outsmpl - chan->insmpl;
2718                                         if (jump - MONITOR_DELAY >= 0) {
2719                                                 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2720                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2721                                                 chan->insmpl += jump;
2722                                         } else
2723                                                 chan->insmpl += f->samples;
2724 #endif
2725                                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2726                                                 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2727                                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2728                                         }
2729                                 }
2730
2731                                 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
2732                                         f = &ast_null_frame;
2733                                 else
2734                                         /* Run generator sitting on the line if timing device not available
2735                                          * and synchronous generation of outgoing frames is necessary       */
2736                                         ast_read_generator_actions(chan, f);
2737                         }
2738                 default:
2739                         /* Just pass it on! */
2740                         break;
2741                 }
2742         } else {
2743                 /* Make sure we always return NULL in the future */
2744                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2745                 if (cause)
2746                         chan->hangupcause = cause;
2747                 if (chan->generator)
2748                         ast_deactivate_generator(chan);
2749                 /* We no longer End the CDR here */
2750         }
2751
2752         /* High bit prints debugging */
2753         if (chan->fin & DEBUGCHAN_FLAG)
2754                 ast_frame_dump(chan->name, f, "<<");
2755         chan->fin = FRAMECOUNT_INC(chan->fin);
2756
2757 done:
2758         if (chan->music_state && chan->generator && chan->generator->digit && f && f->frametype == AST_FRAME_DTMF_END)
2759                 chan->generator->digit(chan, f->subclass);
2760
2761         ast_channel_unlock(chan);
2762         return f;
2763 }
2764
2765 int ast_internal_timing_enabled(struct ast_channel *chan)
2766 {
2767         int ret = ast_opt_internal_timing && chan->timingfd > -1;
2768         ast_debug(5, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
2769         return ret;
2770 }
2771
2772 struct ast_frame *ast_read(struct ast_channel *chan)
2773 {
2774         return __ast_read(chan, 0);
2775 }
2776
2777 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2778 {
2779         return __ast_read(chan, 1);
2780 }
2781
2782 int ast_indicate(struct ast_channel *chan, int condition)
2783 {
2784         return ast_indicate_data(chan, condition, NULL, 0);
2785 }
2786
2787 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
2788 {
2789         int res = -1;
2790
2791         ast_channel_lock(chan);
2792         /* Stop if we're a zombie or need a soft hangup */
2793         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2794                 ast_channel_unlock(chan);
2795                 return -1;
2796         }
2797         if (chan->tech->indicate)
2798                 res = chan->tech->indicate(chan, condition, data, datalen);
2799         ast_channel_unlock(chan);
2800         if (!chan->tech->indicate || res) {
2801                 /*
2802                  * Device does not support (that) indication, lets fake
2803                  * it by doing our own tone generation. (PM2002)
2804                  */
2805                 if (condition < 0)
2806                         ast_playtones_stop(chan);
2807                 else {
2808                         const struct ind_tone_zone_sound *ts = NULL;
2809                         switch (condition) {
2810                         case AST_CONTROL_RINGING:
2811                                 ts = ast_get_indication_tone(chan->zone, "ring");
2812                                 break;
2813                         case AST_CONTROL_BUSY:
2814                                 ts = ast_get_indication_tone(chan->zone, "busy");
2815                                 break;
2816                         case AST_CONTROL_CONGESTION:
2817                                 ts = ast_get_indication_tone(chan->zone, "congestion");
2818                                 break;
2819                         }
2820                         if (ts && ts->data[0]) {
2821                                 ast_debug(1, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2822                                 ast_playtones_start(chan,0,ts->data, 1);
2823                                 res = 0;
2824                                 chan->visible_indication = condition;
2825                         } else if (condition == AST_CONTROL_PROGRESS) {
2826                                 /* ast_playtones_stop(chan); */
2827                         } else if (condition == AST_CONTROL_PROCEEDING) {
2828                                 /* Do nothing, really */
2829                         } else if (condition == AST_CONTROL_HOLD) {
2830                                 /* Do nothing.... */
2831                         } else if (condition == AST_CONTROL_UNHOLD) {
2832                                 /* Do nothing.... */
2833                         } else if (condition == AST_CONTROL_VIDUPDATE) {
2834                                 /* Do nothing.... */
2835                         } else if (condition == AST_CONTROL_SRCUPDATE) {
2836                                 /* Do nothing... */
2837                         } else {
2838                                 /* not handled */
2839                                 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2840                                 res = -1;
2841                         }
2842                 }
2843         } else
2844                 chan->visible_indication = condition;
2845
2846         return res;
2847 }
2848
2849 int ast_recvchar(struct ast_channel *chan, int timeout)
2850 {
2851         int c;
2852         char *buf = ast_recvtext(chan, timeout);
2853         if (buf == NULL)
2854                 return -1;      /* error or timeout */
2855         c = *(unsigned char *)buf;
2856         ast_free(buf);
2857         return c;
2858 }
2859
2860 char *ast_recvtext(struct ast_channel *chan, int timeout)
2861 {
2862         int res, done = 0;
2863         char *buf = NULL;
2864         
2865         while (!done) {
2866                 struct ast_frame *f;
2867                 if (ast_check_hangup(chan))
2868                         break;
2869                 res = ast_waitfor(chan, timeout);
2870                 if (res <= 0) /* timeout or error */
2871                         break;
2872                 timeout = res;  /* update timeout */
2873                 f = ast_read(chan);
2874                 if (f == NULL)
2875                         break; /* no frame */
2876                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2877                         done = 1;       /* force a break */
2878                 else if (f->frametype == AST_FRAME_TEXT) {              /* what we want */
2879                         buf = ast_strndup((char *) f->data.ptr, f->datalen);    /* dup and break */
2880                         done = 1;
2881                 }
2882                 ast_frfree(f);
2883         }
2884         return buf;
2885 }
2886
2887 int ast_sendtext(struct ast_channel *chan, const char *text)
2888 {
2889         int res = 0;
2890         /* Stop if we're a zombie or need a soft hangup */
2891         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2892                 return -1;
2893         CHECK_BLOCKING(chan);
2894         if (chan->tech->send_text)
2895                 res = chan->tech->send_text(chan, text);
2896         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2897         return res;
2898 }
2899
2900 int ast_senddigit_begin(struct ast_channel *chan, char digit)
2901 {
2902         /* Device does not support DTMF tones, lets fake
2903          * it by doing our own generation. */
2904         static const char* dtmf_tones[] = {
2905                 "941+1336", /* 0 */
2906                 "697+1209", /* 1 */
2907                 "697+1336", /* 2 */
2908                 "697+1477", /* 3 */
2909                 "770+1209", /* 4 */
2910                 "770+1336", /* 5 */
2911                 "770+1477", /* 6 */
2912                 "852+1209", /* 7 */
2913                 "852+1336", /* 8 */
2914                 "852+1477", /* 9 */
2915                 "697+1633", /* A */
2916                 "770+1633", /* B */
2917                 "852+1633", /* C */
2918                 "941+1633", /* D */
2919                 "941+1209", /* * */
2920                 "941+1477"  /* # */
2921         };
2922
2923         if (!chan->tech->send_digit_begin)
2924                 return 0;
2925
2926         if (!chan->tech->send_digit_begin(chan, digit))
2927                 return 0;
2928
2929         if (digit >= '0' && digit <='9')
2930                 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2931         else if (digit >= 'A' && digit <= 'D')
2932                 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2933         else if (digit == '*')
2934                 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2935         else if (digit == '#')
2936                 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2937         else {
2938                 /* not handled */
2939                 ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2940         }
2941
2942         return 0;
2943 }
2944
2945 int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
2946 {
2947         int res = -1;
2948
2949         if (chan->tech->send_digit_end)
2950                 res = chan->tech->send_digit_end(chan, digit, duration);
2951
2952         if (res && chan->generator)
2953                 ast_playtones_stop(chan);
2954         
2955         return 0;
2956 }
2957
2958 int ast_senddigit(struct ast_channel *chan, char digit, unsigned int duration)
2959 {
2960         if (chan->tech->send_digit_begin) {
2961                 ast_senddigit_begin(chan, digit);
2962                 ast_safe_sleep(chan, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2963         }
2964         
2965         return ast_senddigit_end(chan, digit, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2966 }
2967
2968 int ast_prod(struct ast_channel *chan)
2969 {
2970         struct ast_frame a = { AST_FRAME_VOICE };
2971         char nothing[128];
2972
2973         /* Send an empty audio frame to get things moving */
2974         if (chan->_state != AST_STATE_UP) {
2975                 ast_debug(1, "Prodding channel '%s'\n", chan->name);
2976                 a.subclass = chan->rawwriteformat;
2977                 a.data.ptr = nothing + AST_FRIENDLY_OFFSET;
2978                 a.src = "ast_prod";
2979                 if (ast_write(chan, &a))
2980                         ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2981         }
2982         return 0;
2983 }
2984
2985 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2986 {
2987         int res;
2988         if (!chan->tech->write_video)
2989                 return 0;
2990         res = ast_write(chan, fr);
2991         if (!res)
2992                 res = 1;
2993         return res;
2994 }
2995
2996 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2997 {
2998         int res = -1;
2999         struct ast_frame *f = NULL, *f2 = NULL;
3000         int count = 0;
3001
3002         /*Deadlock avoidance*/
3003         while(ast_channel_trylock(chan)) {
3004                 /*cannot goto done since the channel is not locked*/
3005                 if(count++ > 10) {
3006                         ast_debug(1, "Deadlock avoided for write to channel '%s'\n", chan->name);
3007                         return 0;
3008                 }
3009                 usleep(1);
3010         }
3011         /* Stop if we're a zombie or need a soft hangup */
3012         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
3013                 goto done;
3014
3015         /* Handle any pending masquerades */
3016         if (chan->masq && ast_do_masquerade(chan)) {
3017                 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
3018                 goto done;
3019         }
3020         if (chan->masqr) {
3021                 res = 0;        /* XXX explain, why 0 ? */
3022                 goto done;
3023         }
3024         if (chan->generatordata) {
3025                 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
3026                         ast_deactivate_generator(chan);
3027                 else {
3028                         if (fr->frametype == AST_FRAME_DTMF_END) {
3029                                 /* There is a generator running while we're in the middle of a digit.
3030                                  * It's probably inband DTMF, so go ahead and pass it so it can
3031                                  * stop the generator */
3032                                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3033                                 ast_channel_unlock(chan);
3034                                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
3035                                 ast_channel_lock(chan);
3036                                 CHECK_BLOCKING(chan);
3037                         } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
3038                                 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
3039                                 res = (chan->tech->indicate == NULL) ? 0 :
3040                                         chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
3041                         }
3042                         res = 0;        /* XXX explain, why 0 ? */
3043                         goto done;
3044                 }
3045         }
3046         /* High bit prints debugging */
3047         if (chan->fout & DEBUGCHAN_FLAG)
3048                 ast_frame_dump(chan->name, fr, ">>");
3049         CHECK_BLOCKING(chan);
3050         switch (fr->frametype) {
3051         case AST_FRAME_CONTROL:
3052                 res = (chan->tech->indicate == NULL) ? 0 :
3053                         chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
3054                 break;
3055         case AST_FRAME_DTMF_BEGIN:
3056                 if (chan->audiohooks) {
3057                         struct ast_frame *old_frame = fr;
3058                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3059                         if (old_frame != fr)
3060                                 f = fr;
3061                 }
3062                 send_dtmf_event(chan, "Sent", fr->subclass, "Yes", "No");
3063                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3064                 ast_channel_unlock(chan);
3065                 res = ast_senddigit_begin(chan, fr->subclass);
3066                 ast_channel_lock(chan);
3067                 CHECK_BLOCKING(chan);
3068                 break;
3069         case AST_FRAME_DTMF_END:
3070                 if (chan->audiohooks) {
3071                         struct ast_frame *old_frame = fr;
3072                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3073                         if (old_frame != fr)
3074                                 f = fr;
3075                 }
3076                 send_dtmf_event(chan, "Sent", fr->subclass, "No", "Yes");
3077                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3078                 ast_channel_unlock(chan);
3079                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
3080                 ast_channel_lock(chan);
3081                 CHECK_BLOCKING(chan);
3082                 break;
3083         case AST_FRAME_TEXT:
3084                 if (fr->subclass == AST_FORMAT_T140) {
3085                         res = (chan->tech->write_text == NULL) ? 0 :
3086                                 chan->tech->write_text(chan, fr);
3087                 } else {
3088                         res = (chan->tech->send_text == NULL) ? 0 :
3089                                 chan->tech->send_text(chan, (char *) fr->data.ptr);
3090                 }
3091                 break;
3092         case AST_FRAME_HTML:
3093                 res = (chan->tech->send_html == NULL) ? 0 :
3094                         chan->tech->send_html(chan, fr->subclass, (char *) fr->data.ptr, fr->datalen);
3095                 break;
3096         case AST_FRAME_VIDEO:
3097                 /* XXX Handle translation of video codecs one day XXX */
3098                 res = (chan->tech->write_video == NULL) ? 0 :
3099                         chan->tech->write_video(chan, fr);
3100                 break;
3101         case AST_FRAME_MODEM:
3102                 res = (chan->tech->write == NULL) ? 0 :
3103                         chan->tech->write(chan, fr);
3104                 break;
3105         case AST_FRAME_VOICE:
3106                 if (chan->tech->write == NULL)
3107                         break;  /*! \todo XXX should return 0 maybe ? */
3108
3109                 /* If audiohooks are present, write the frame out */
3110                 if (chan->audiohooks) {
3111                         struct ast_frame *old_frame = fr;
3112                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3113                         if (old_frame != fr)
3114                                 f2 = fr;
3115                 }
3116
3117                 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
3118                 if (fr->subclass == chan->rawwriteformat)
3119                         f = fr;
3120                 else
3121                         f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
3122
3123                 if (!f) {
3124                         res = 0;
3125                         break;
3126                 }
3127
3128                 /* If Monitor is running on this channel, then we have to write frames out there too */
3129                 if (chan->monitor && chan->monitor->write_stream) {
3130                         /* XXX must explain this code */
3131 #ifndef MONITOR_CONSTANT_DELAY
3132                         int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
3133                         if (jump >= 0) {
3134                                 jump = chan->insmpl - chan->outsmpl;
3135                                 if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
3136                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
3137                                 chan->outsmpl += jump + f->samples;
3138                         } else
3139                                 chan->outsmpl += f->samples;
3140 #else
3141                         int jump = chan->insmpl - chan->outsmpl;
3142                         if (jump - MONITOR_DELAY >= 0) {
3143                                 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
3144                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
3145                                 chan->outsmpl += jump;
3146                         } else
3147                                 chan->outsmpl += f->samples;
3148 #endif
3149                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
3150                                 if (ast_writestream(chan->monitor->write_stream, f) < 0)
3151                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
3152                         }
3153                 }
3154
3155                 if (f) 
3156                         res = chan->tech->write(chan,f);
3157                 else
3158                         res = 0;
3159                 break;
3160         case AST_FRAME_NULL:
3161         case AST_FRAME_IAX:
3162                 /* Ignore these */
3163                 res = 0;
3164                 break;
3165         default:
3166                 /* At this point, fr is the incoming frame and f is NULL.  Channels do
3167                  * not expect to get NULL as a frame pointer and will segfault.  Hence,
3168                  * we output the original frame passed in. */
3169                 res = chan->tech->write(chan, fr);
3170                 break;
3171         }
3172
3173         if (f && f != fr)
3174                 ast_frfree(f);
3175         if (f2)
3176                 ast_frfree(f2);
3177         ast_clear_flag(chan, AST_FLAG_BLOCKING);
3178         /* Consider a write failure to force a soft hangup */
3179         if (res < 0)
3180                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
3181         else {
3182                 chan->fout = FRAMECOUNT_INC(chan->fout);
3183         }
3184 done:
3185         ast_channel_unlock(chan);
3186         return res;
3187 }
3188
3189 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
3190                       struct ast_trans_pvt **trans, const int direction)
3191 {
3192         int native;
3193         int res;
3194         char from[200], to[200];
3195         
3196         /* Make sure we only consider audio */
3197         fmt &= AST_FORMAT_AUDIO_MASK;
3198         
3199         native = chan->nativeformats;
3200
3201         if (!fmt || !native)    /* No audio requested */
3202                 return 0;       /* Let's try a call without any sounds (video, text) */
3203         
3204         /* Find a translation path from the native format to one of the desired formats */
3205         if (!direction)
3206                 /* reading */
3207                 res = ast_translator_best_choice(&fmt, &native);
3208         else
3209                 /* writing */
3210                 res = ast_translator_best_choice(&native, &fmt);
3211
3212         if (res < 0) {
3213                 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
3214                         ast_getformatname_multiple(from, sizeof(from), native),
3215                         ast_getformatname_multiple(to, sizeof(to), fmt));
3216                 return -1;
3217         }
3218         
3219         /* Now we have a good choice for both. */
3220         ast_channel_lock(chan);
3221
3222         if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
3223                 /* the channel is already in these formats, so nothing to do */
3224                 ast_channel_unlock(chan);
3225                 return 0;
3226         }
3227
3228         *rawformat = native;
3229         /* User perspective is fmt */
3230         *format = fmt;
3231         /* Free any read translation we have right now */
3232         if (*trans)
3233                 ast_translator_free_path(*trans);
3234         /* Build a translation path from the raw format to the desired format */
3235         if (!direction)
3236                 /* reading */
3237                 *trans = ast_translator_build_path(*format, *rawformat);
3238         else
3239                 /* writing */
3240                 *trans = ast_translator_build_path(*rawformat, *format);
3241         ast_channel_unlock(chan);
3242         ast_debug(1, "Set channel %s to %s format %s\n", chan->name,
3243                 direction ? "write" : "read", ast_getformatname(fmt));
3244         return 0;
3245 }
3246
3247 int ast_set_read_format(struct ast_channel *chan, int fmt)
3248 {
3249         return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
3250                           &chan->readtrans, 0);
3251 }
3252
3253 int ast_set_write_format(struct ast_channel *chan, int fmt)
3254 {
3255         return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
3256                           &chan->writetrans, 1);
3257 }
3258
3259 const char *ast_channel_reason2str(int reason)
3260 {
3261         switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */
3262         {
3263         case 0:
3264                 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
3265         case AST_CONTROL_HANGUP:
3266                 return "Hangup";
3267         case AST_CONTROL_RING:
3268                 return "Local Ring";
3269         case AST_CONTROL_RINGING:
3270                 return "Remote end Ringing";
3271         case AST_CONTROL_ANSWER:
3272                 return "Remote end has Answered";
3273         case AST_CONTROL_BUSY:
3274                 return "Remote end is Busy";
3275         case AST_CONTROL_CONGESTION:
3276                 return "Congestion (circuits busy)";
3277         default:
3278                 return "Unknown Reason!!";
3279         }
3280 }
3281
3282 struct ast_channel *__ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name, struct outgoing_helper *oh)
3283 {
3284         int dummy_outstate;
3285         int cause = 0;
3286         struct ast_channel *chan;
3287         int res = 0;
3288         int last_subclass = 0;
3289         
3290         if (outstate)
3291                 *outstate = 0;
3292         else
3293                 outstate = &dummy_outstate;     /* make outstate always a valid pointer */
3294
3295         chan = ast_request(type, format, data, &cause);
3296         if (!chan) {
3297                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
3298                 /* compute error and return */
3299                 if (cause == AST_CAUSE_BUSY)
3300                         *outstate = AST_CONTROL_BUSY;
3301                 else if (cause == AST_CAUSE_CONGESTION)
3302                         *outstate = AST_CONTROL_CONGESTION;
3303                 return NULL;
3304         }
3305
3306         if (oh) {
3307                 if (oh->vars)   
3308                         ast_set_variables(chan, oh->vars);
3309                 /* XXX why is this necessary, for the parent_channel perhaps ? */
3310                 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
3311                         ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
3312                 if (oh->parent_channel) {
3313                         ast_channel_inherit_variables(oh->parent_channel, chan);
3314                         ast_channel_datastore_inherit(oh->parent_channel, chan);
3315                 }
3316                 if (oh->account)
3317                         ast_cdr_setaccount(chan, oh->account);  
3318         }
3319         ast_set_callerid(chan, cid_num, cid_name, cid_num);
3320
3321         if (ast_call(chan, data, 0)) {  /* ast_call failed... */
3322                 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
3323         } else {
3324                 res = 1;        /* mark success in case chan->_state is already AST_STATE_UP */
3325                 while (timeout && chan->_state != AST_STATE_UP) {
3326                         struct ast_frame *f;
3327                         res = ast_waitfor(chan, timeout);
3328                         if (res <= 0) /* error, timeout, or done */
3329                                 break;
3330                         if (timeout > -1)
3331                                 timeout = res;
3332                         f = ast_read(chan);
3333                         if (!f) {
3334                                 *outstate = AST_CONTROL_HANGUP;
3335                                 res = 0;
3336                                 break;
3337                         }
3338                         if (f->frametype == AST_FRAME_CONTROL) {
3339                                 switch (f->subclass) {
3340                                 case AST_CONTROL_RINGING:       /* record but keep going */
3341                                         *outstate = f->subclass;
3342                                         break;
3343
3344                                 case AST_CONTROL_BUSY:
3345                                 case AST_CONTROL_CONGESTION:
3346                                 case AST_CONTROL_ANSWER:
3347                                         *outstate = f->subclass;
3348                                         timeout = 0;            /* trick to force exit from the while() */
3349                                         break;
3350
3351                                 /* Ignore these */
3352                                 case AST_CONTROL_PROGRESS:
3353                                 case AST_CONTROL_PROCEEDING:
3354                                 case AST_CONTROL_HOLD:
3355                                 case AST_CONTROL_UNHOLD:
3356                                 case AST_CONTROL_VIDUPDATE:
3357                                 case AST_CONTROL_SRCUPDATE:
3358                                 case -1:                        /* Ignore -- just stopping indications */
3359                                         break;
3360
3361                                 default:
3362                                         ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
3363                                 }
3364                                 last_subclass = f->subclass;
3365                         }
3366                         ast_frfree(f);
3367                 }
3368         }
3369
3370         /* Final fixups */
3371         if (oh) {
3372                 if (!ast_strlen_zero(oh->context))
3373                         ast_copy_string(chan->context, oh->context, sizeof(chan->context));
3374                 if (!ast_strlen_zero(oh->exten))
3375                         ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
3376                 if (oh->priority)       
3377                         chan->priority = oh->priority;
3378         }
3379         if (chan->_state == AST_STATE_UP)
3380                 *outstate = AST_CONTROL_ANSWER;
3381
3382         if (res <= 0) {
3383                 if ( AST_CONTROL_RINGING == last_subclass ) 
3384                         chan->hangupcause = AST_CAUSE_NO_ANSWER;
3385                 if (!chan->cdr && (chan->cdr = ast_cdr_alloc()))
3386                         ast_cdr_init(chan->cdr, chan);
3387                 if (chan->cdr) {
3388                         char tmp[256];
3389                         snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data);
3390                         ast_cdr_setapp(chan->cdr,"Dial",tmp);
3391                         ast_cdr_update(chan);
3392                         ast_cdr_start(chan->cdr);
3393                         ast_cdr_end(chan->cdr);
3394                         /* If the cause wasn't handled properly */
3395                         if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
3396                                 ast_cdr_failed(chan->cdr);
3397                 }
3398                 ast_hangup(chan);
3399                 chan = NULL;
3400         }
3401         return chan;
3402 }
3403
3404 struct ast_channel *ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname)
3405 {
3406         return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
3407 }
3408
3409 struct ast_channel *ast_request(const char *type, int format, void *data, int *cause)
3410 {
3411         struct chanlist *chan;
3412         struct ast_channel *c;
3413         int capabilities;
3414         int fmt;
3415         int res;
3416         int foo;
3417         int videoformat = format & AST_FORMAT_VIDEO_MASK;
3418         int textformat = format & AST_FORMAT_TEXT_MASK;
3419
3420         if (!cause)
3421                 cause = &foo;
3422         *cause = AST_CAUSE_NOTDEFINED;
3423
3424         if (AST_RWLIST_RDLOCK(&channels)) {
3425                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
3426                 return NULL;
3427         }
3428
3429         AST_LIST_TRAVERSE(&backends, chan, list) {
3430                 if (strcasecmp(type, chan->tech->type))
3431                         continue;
3432
3433                 capabilities = chan->tech->capabilities;
3434                 fmt = format & AST_FORMAT_AUDIO_MASK;
3435                 if (fmt) {
3436                         /* We have audio - is it possible to connect the various calls to each other? 
3437                                 (Avoid this check for calls without audio, like text+video calls)
3438                         */
3439                         res = ast_translator_best_choice(&fmt, &capabilities);
3440                         if (res < 0) {
3441                                 ast_log(LOG_WARNING, "No translator path exists for channel type %s (native 0x%x) to 0x%x\n", type, chan->tech->capabilities, format);
3442                                 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
3443                                 AST_RWLIST_UNLOCK(&channels);
3444                                 return NULL;
3445                         }
3446                 }
3447                 AST_RWLIST_UNLOCK(&channels);
3448                 if (!chan->tech->requester)
3449                         return NULL;
3450                 
3451                 if (!(c = chan->tech->requester(type, capabilities | videoformat | textformat, data, cause)))
3452                         return NULL;
3453                 
3454                 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
3455                 return c;
3456         }
3457
3458         ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
3459         *cause = AST_CAUSE_NOSUCHDRIVER;
3460         AST_RWLIST_UNLOCK(&channels);
3461
3462         return NULL;
3463 }
3464
3465 int ast_call(struct ast_channel *chan, char *addr, int timeout)
3466 {
3467         /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
3468            If the remote end does not answer within the timeout, then do NOT hang up, but
3469            return anyway.  */
3470         int res = -1;
3471         /* Stop if we're a zombie or need a soft hangup */
3472         ast_channel_lock(chan);
3473         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
3474                 if (chan->tech->call)
3475                         res = chan->tech->call(chan, addr, timeout);
3476                 ast_set_flag(chan, AST_FLAG_OUTGOING);
3477         }
3478         ast_channel_unlock(chan);
3479         return res;
3480 }
3481
3482 /*!
3483   \brief Transfer a call to dest, if the channel supports transfer
3484
3485   Called by:
3486         \arg app_transfer
3487         \arg the manager interface
3488 */
3489 int ast_transfer(struct ast_channel *chan, char *dest)
3490 {
3491         int res = -1;
3492
3493         /* Stop if we're a zombie or need a soft hangup */
3494         ast_channel_lock(chan);
3495         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
3496                 if (chan->tech->transfer) {
3497                         res = chan->tech->transfer(chan, dest);
3498                         if (!res)
3499                                 res = 1;
3500                 } else
3501                         res = 0;
3502         }
3503         ast_channel_unlock(chan);
3504         return res;
3505 }
3506
3507 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
3508 {
3509         return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
3510 }
3511
3512 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
3513 {
3514         int pos = 0;    /* index in the buffer where we accumulate digits */
3515         int to = ftimeout;
3516
3517         /* Stop if we're a zombie or need a soft hangup */
3518         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
3519                 return -1;
3520         if (!len)
3521                 return -1;
3522         for (;;) {
3523                 int d;
3524                 if (c->stream) {
3525                         d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
3526                         ast_stopstream(c);
3527                         usleep(1000);
3528                         if (!d)
3529                                 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
3530                 } else {
3531                         d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
3532                 }
3533                 if (d < 0)
3534                         return -1;
3535                 if (d == 0) {
3536                         s[pos]='\0';
3537                         return 1;
3538                 }
3539                 if (d == 1) {
3540                         s[pos]='\0';
3541                         return 2;
3542                 }
3543                 if (!strchr(enders, d))
3544                         s[pos++] = d;
3545                 if (strchr(enders, d) || (pos >= len)) {
3546                         s[pos]='\0';
3547                         return&