b19c4c9299a92a478c98c6ddcfdea6d088dc5838
[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_datastore_alloc(&ast_chan_trace_datastore_info, "ChanTrace");
433                 if (!store) 
434                         return -1;
435                 traced = ast_calloc(1, sizeof(*traced));
436                 if (!traced) {
437                         ast_datastore_free(store);
438                         return -1;
439                 }       
440                 store->data = traced;
441                 AST_LIST_HEAD_INIT_NOLOCK(&traced->trace);
442                 ast_channel_datastore_add(chan, store);
443         }       
444         ((struct ast_chan_trace_data *)store->data)->enabled = 1;
445         ast_channel_trace_data_update(chan, store->data);
446         return 0;
447 }
448
449 /*! \brief Disable context tracing in the channel */
450 int ast_channel_trace_disable(struct ast_channel *chan)
451 {
452         struct ast_datastore *store = ast_channel_datastore_find(chan, &ast_chan_trace_datastore_info, NULL);
453         if (!store)
454                 return 0;
455         ((struct ast_chan_trace_data *)store->data)->enabled = 0;
456         return 0;
457 }
458 #endif /* CHANNEL_TRACE */
459
460 /*! \brief Checks to see if a channel is needing hang up */
461 int ast_check_hangup(struct ast_channel *chan)
462 {
463         if (chan->_softhangup)          /* yes if soft hangup flag set */
464                 return 1;
465         if (!chan->tech_pvt)            /* yes if no technology private data */
466                 return 1;
467         if (ast_tvzero(chan->whentohangup))     /* no if no hangup scheduled */
468                 return 0;
469         if (ast_tvdiff_ms(chan->whentohangup, ast_tvnow()) > 0)         /* no if hangup time has not come yet. */
470                 return 0;
471         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;    /* record event */
472         return 1;
473 }
474
475 static int ast_check_hangup_locked(struct ast_channel *chan)
476 {
477         int res;
478         ast_channel_lock(chan);
479         res = ast_check_hangup(chan);
480         ast_channel_unlock(chan);
481         return res;
482 }
483
484 /*! \brief Initiate system shutdown */
485 void ast_begin_shutdown(int hangup)
486 {
487         struct ast_channel *c;
488         shutting_down = 1;
489         if (hangup) {
490                 AST_RWLIST_RDLOCK(&channels);
491                 AST_RWLIST_TRAVERSE(&channels, c, chan_list) {
492                         ast_softhangup(c, AST_SOFTHANGUP_SHUTDOWN);
493                 }
494                 AST_RWLIST_UNLOCK(&channels);
495         }
496 }
497
498 /*! \brief returns number of active/allocated channels */
499 int ast_active_channels(void)
500 {
501         struct ast_channel *c;
502         int cnt = 0;
503         AST_RWLIST_RDLOCK(&channels);
504         AST_RWLIST_TRAVERSE(&channels, c, chan_list)
505                 cnt++;
506         AST_RWLIST_UNLOCK(&channels);
507         return cnt;
508 }
509
510 /*! \brief Cancel a shutdown in progress */
511 void ast_cancel_shutdown(void)
512 {
513         shutting_down = 0;
514 }
515
516 /*! \brief Returns non-zero if Asterisk is being shut down */
517 int ast_shutting_down(void)
518 {
519         return shutting_down;
520 }
521
522 /*! \brief Set when to hangup channel */
523 void ast_channel_setwhentohangup_tv(struct ast_channel *chan, struct timeval offset)
524 {
525         chan->whentohangup = ast_tvzero(offset) ? offset : ast_tvadd(offset, ast_tvnow());
526         ast_queue_frame(chan, &ast_null_frame);
527         return;
528 }
529
530 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset)
531 {
532         struct timeval when = { offset, };
533         ast_channel_setwhentohangup_tv(chan, when);
534 }
535
536 /*! \brief Compare a offset with when to hangup channel */
537 int ast_channel_cmpwhentohangup_tv(struct ast_channel *chan, struct timeval offset)
538 {
539         struct timeval whentohangup;
540
541         if (ast_tvzero(chan->whentohangup))
542                 return ast_tvzero(offset) ? 0 : -1;
543
544         if (ast_tvzero(offset))
545                 return 1;
546
547         whentohangup = ast_tvadd(offset, ast_tvnow());
548
549         return ast_tvdiff_ms(whentohangup, chan->whentohangup);
550 }
551
552 int ast_channel_cmpwhentohangup(struct ast_channel *chan, time_t offset)
553 {
554         struct timeval when = { offset, };
555         return ast_channel_cmpwhentohangup_tv(chan, when);
556 }
557
558 /*! \brief Register a new telephony channel in Asterisk */
559 int ast_channel_register(const struct ast_channel_tech *tech)
560 {
561         struct chanlist *chan;
562
563         AST_RWLIST_WRLOCK(&channels);
564
565         AST_LIST_TRAVERSE(&backends, chan, list) {
566                 if (!strcasecmp(tech->type, chan->tech->type)) {
567                         ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
568                         AST_RWLIST_UNLOCK(&channels);
569                         return -1;
570                 }
571         }
572         
573         if (!(chan = ast_calloc(1, sizeof(*chan)))) {
574                 AST_RWLIST_UNLOCK(&channels);
575                 return -1;
576         }
577         chan->tech = tech;
578         AST_LIST_INSERT_HEAD(&backends, chan, list);
579
580         ast_debug(1, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);
581
582         ast_verb(2, "Registered channel type '%s' (%s)\n", chan->tech->type, chan->tech->description);
583
584         AST_RWLIST_UNLOCK(&channels);
585         return 0;
586 }
587
588 /*! \brief Unregister channel driver */
589 void ast_channel_unregister(const struct ast_channel_tech *tech)
590 {
591         struct chanlist *chan;
592
593         ast_debug(1, "Unregistering channel type '%s'\n", tech->type);
594
595         AST_RWLIST_WRLOCK(&channels);
596
597         AST_LIST_TRAVERSE_SAFE_BEGIN(&backends, chan, list) {
598                 if (chan->tech == tech) {
599                         AST_LIST_REMOVE_CURRENT(list);
600                         ast_free(chan);
601                         ast_verb(2, "Unregistered channel type '%s'\n", tech->type);
602                         break;  
603                 }
604         }
605         AST_LIST_TRAVERSE_SAFE_END;
606
607         AST_RWLIST_UNLOCK(&channels);
608 }
609
610 /*! \brief Get handle to channel driver based on name */
611 const struct ast_channel_tech *ast_get_channel_tech(const char *name)
612 {
613         struct chanlist *chanls;
614         const struct ast_channel_tech *ret = NULL;
615
616         AST_RWLIST_RDLOCK(&channels);
617
618         AST_LIST_TRAVERSE(&backends, chanls, list) {
619                 if (!strcasecmp(name, chanls->tech->type)) {
620                         ret = chanls->tech;
621                         break;
622                 }
623         }
624
625         AST_RWLIST_UNLOCK(&channels);
626         
627         return ret;
628 }
629
630 /*! \brief Gives the string form of a given hangup cause */
631 const char *ast_cause2str(int cause)
632 {
633         int x;
634
635         for (x = 0; x < ARRAY_LEN(causes); x++) {
636                 if (causes[x].cause == cause)
637                         return causes[x].desc;
638         }
639
640         return "Unknown";
641 }
642
643 /*! \brief Convert a symbolic hangup cause to number */
644 int ast_str2cause(const char *name)
645 {
646         int x;
647
648         for (x = 0; x < ARRAY_LEN(causes); x++)
649                 if (!strncasecmp(causes[x].name, name, strlen(causes[x].name)))
650                         return causes[x].cause;
651
652         return -1;
653 }
654
655 /*! \brief Gives the string form of a given channel state.
656         \note This function is not reentrant.
657  */
658 const char *ast_state2str(enum ast_channel_state state)
659 {
660         char *buf;
661
662         switch (state) {
663         case AST_STATE_DOWN:
664                 return "Down";
665         case AST_STATE_RESERVED:
666                 return "Rsrvd";
667         case AST_STATE_OFFHOOK:
668                 return "OffHook";
669         case AST_STATE_DIALING:
670                 return "Dialing";
671         case AST_STATE_RING:
672                 return "Ring";
673         case AST_STATE_RINGING:
674                 return "Ringing";
675         case AST_STATE_UP:
676                 return "Up";
677         case AST_STATE_BUSY:
678                 return "Busy";
679         case AST_STATE_DIALING_OFFHOOK:
680                 return "Dialing Offhook";
681         case AST_STATE_PRERING:
682                 return "Pre-ring";
683         default:
684                 if (!(buf = ast_threadstorage_get(&state2str_threadbuf, STATE2STR_BUFSIZE)))
685                         return "Unknown";
686                 snprintf(buf, STATE2STR_BUFSIZE, "Unknown (%d)", state);
687                 return buf;
688         }
689 }
690
691 /*! \brief Gives the string form of a given transfer capability */
692 char *ast_transfercapability2str(int transfercapability)
693 {
694         switch (transfercapability) {
695         case AST_TRANS_CAP_SPEECH:
696                 return "SPEECH";
697         case AST_TRANS_CAP_DIGITAL:
698                 return "DIGITAL";
699         case AST_TRANS_CAP_RESTRICTED_DIGITAL:
700                 return "RESTRICTED_DIGITAL";
701         case AST_TRANS_CAP_3_1K_AUDIO:
702                 return "3K1AUDIO";
703         case AST_TRANS_CAP_DIGITAL_W_TONES:
704                 return "DIGITAL_W_TONES";
705         case AST_TRANS_CAP_VIDEO:
706                 return "VIDEO";
707         default:
708                 return "UNKNOWN";
709         }
710 }
711
712 /*! \brief Pick the best audio codec */
713 int ast_best_codec(int fmts)
714 {
715         /* This just our opinion, expressed in code.  We are asked to choose
716            the best codec to use, given no information */
717         int x;
718         static const int prefs[] =
719         {
720                 /*! Okay, ulaw is used by all telephony equipment, so start with it */
721                 AST_FORMAT_ULAW,
722                 /*! Unless of course, you're a silly European, so then prefer ALAW */
723                 AST_FORMAT_ALAW,
724                 /*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */
725                 AST_FORMAT_G722,
726                 /*! Okay, well, signed linear is easy to translate into other stuff */
727                 AST_FORMAT_SLINEAR16,
728                 AST_FORMAT_SLINEAR,
729                 /*! G.726 is standard ADPCM, in RFC3551 packing order */
730                 AST_FORMAT_G726,
731                 /*! G.726 is standard ADPCM, in AAL2 packing order */
732                 AST_FORMAT_G726_AAL2,
733                 /*! ADPCM has great sound quality and is still pretty easy to translate */
734                 AST_FORMAT_ADPCM,
735                 /*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
736                     translate and sounds pretty good */
737                 AST_FORMAT_GSM,
738                 /*! iLBC is not too bad */
739                 AST_FORMAT_ILBC,
740                 /*! Speex is free, but computationally more expensive than GSM */
741                 AST_FORMAT_SPEEX,
742                 /*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
743                     to use it */
744                 AST_FORMAT_LPC10,
745                 /*! G.729a is faster than 723 and slightly less expensive */
746                 AST_FORMAT_G729A,
747                 /*! Down to G.723.1 which is proprietary but at least designed for voice */
748                 AST_FORMAT_G723_1,
749         };
750
751         /* Strip out video */
752         fmts &= AST_FORMAT_AUDIO_MASK;
753         
754         /* Find the first preferred codec in the format given */
755         for (x = 0; x < ARRAY_LEN(prefs); x++) {
756                 if (fmts & prefs[x])
757                         return prefs[x];
758         }
759
760         ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts);
761
762         return 0;
763 }
764
765 static const struct ast_channel_tech null_tech = {
766         .type = "NULL",
767         .description = "Null channel (should not see this)",
768 };
769
770 /*! \brief Create a new channel structure */
771 struct ast_channel *ast_channel_alloc(int needqueue, int state, const char *cid_num, const char *cid_name, const char *acctcode, const char *exten, const char *context, const int amaflag, const char *name_fmt, ...)
772 {
773         struct ast_channel *tmp;
774         int x;
775         int flags;
776         struct varshead *headp;
777         va_list ap1, ap2;
778
779         /* If shutting down, don't allocate any new channels */
780         if (shutting_down) {
781                 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
782                 return NULL;
783         }
784
785         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
786                 return NULL;
787
788         if (!(tmp->sched = sched_context_create())) {
789                 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
790                 ast_free(tmp);
791                 return NULL;
792         }
793         
794         if ((ast_string_field_init(tmp, 128))) {
795                 sched_context_destroy(tmp->sched);
796                 ast_free(tmp);
797                 return NULL;
798         }
799
800 #ifdef HAVE_EPOLL
801         tmp->epfd = epoll_create(25);
802 #endif
803
804         for (x = 0; x < AST_MAX_FDS; x++) {
805                 tmp->fds[x] = -1;
806 #ifdef HAVE_EPOLL
807                 tmp->epfd_data[x] = NULL;
808 #endif
809         }
810
811         tmp->timingfd = ast_timer_open();
812         if (tmp->timingfd > -1) {
813                 needqueue = 0;
814         }
815
816         if (needqueue) {
817                 if (pipe(tmp->alertpipe)) {
818                         ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
819 alertpipe_failed:
820                         if (tmp->timingfd > -1) {
821                                 ast_timer_close(tmp->timingfd);
822                         }
823
824                         sched_context_destroy(tmp->sched);
825                         ast_string_field_free_memory(tmp);
826                         ast_free(tmp);
827                         return NULL;
828                 } else {
829                         flags = fcntl(tmp->alertpipe[0], F_GETFL);
830                         if (fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK) < 0) {
831                                 ast_log(LOG_WARNING, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno));
832                                 close(tmp->alertpipe[0]);
833                                 close(tmp->alertpipe[1]);
834                                 goto alertpipe_failed;
835                         }
836                         flags = fcntl(tmp->alertpipe[1], F_GETFL);
837                         if (fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK) < 0) {
838                                 ast_log(LOG_WARNING, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno));
839                                 close(tmp->alertpipe[0]);
840                                 close(tmp->alertpipe[1]);
841                                 goto alertpipe_failed;
842                         }
843                 }
844         } else  /* Make sure we've got it done right if they don't */
845                 tmp->alertpipe[0] = tmp->alertpipe[1] = -1;
846
847         /* Always watch the alertpipe */
848         ast_channel_set_fd(tmp, AST_ALERT_FD, tmp->alertpipe[0]);
849         /* And timing pipe */
850         ast_channel_set_fd(tmp, AST_TIMING_FD, tmp->timingfd);
851         ast_string_field_set(tmp, name, "**Unknown**");
852
853         /* Initial state */
854         tmp->_state = state;
855
856         tmp->streamid = -1;
857         
858         tmp->fin = global_fin;
859         tmp->fout = global_fout;
860
861         if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
862                 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL), 
863                                        ast_atomic_fetchadd_int(&uniqueint, 1));
864         } else {
865                 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME, 
866                                        (long) time(NULL), ast_atomic_fetchadd_int(&uniqueint, 1));
867         }
868
869         tmp->cid.cid_name = ast_strdup(cid_name);
870         tmp->cid.cid_num = ast_strdup(cid_num);
871         
872         if (!ast_strlen_zero(name_fmt)) {
873                 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
874                  * And they all use slightly different formats for their name string.
875                  * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
876                  * This means, that the stringfields must have a routine that takes the va_lists directly, and 
877                  * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
878                  * This new function was written so this can be accomplished.
879                  */
880                 va_start(ap1, name_fmt);
881                 va_start(ap2, name_fmt);
882                 ast_string_field_build_va(tmp, name, name_fmt, ap1, ap2);
883                 va_end(ap1);
884                 va_end(ap2);
885         }
886
887         /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */
888
889         /* These 4 variables need to be set up for the cdr_init() to work right */
890         if (amaflag)
891                 tmp->amaflags = amaflag;
892         else
893                 tmp->amaflags = ast_default_amaflags;
894         
895         if (!ast_strlen_zero(acctcode))
896                 ast_string_field_set(tmp, accountcode, acctcode);
897         else
898                 ast_string_field_set(tmp, accountcode, ast_default_accountcode);
899                 
900         if (!ast_strlen_zero(context))
901                 ast_copy_string(tmp->context, context, sizeof(tmp->context));
902         else
903                 strcpy(tmp->context, "default");
904
905         if (!ast_strlen_zero(exten))
906                 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten));
907         else
908                 strcpy(tmp->exten, "s");
909
910         tmp->priority = 1;
911                 
912         tmp->cdr = ast_cdr_alloc();
913         ast_cdr_init(tmp->cdr, tmp);
914         ast_cdr_start(tmp->cdr);
915         
916         headp = &tmp->varshead;
917         AST_LIST_HEAD_INIT_NOLOCK(headp);
918         
919         ast_mutex_init(&tmp->lock_dont_use);
920         
921         AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores);
922         
923         ast_string_field_set(tmp, language, defaultlanguage);
924
925         tmp->tech = &null_tech;
926
927         AST_RWLIST_WRLOCK(&channels);
928         AST_RWLIST_INSERT_HEAD(&channels, tmp, chan_list);
929         AST_RWLIST_UNLOCK(&channels);
930
931         /*\!note
932          * and now, since the channel structure is built, and has its name, let's
933          * call the manager event generator with this Newchannel event. This is the
934          * proper and correct place to make this call, but you sure do have to pass
935          * a lot of data into this func to do it here!
936          */
937         if (!ast_strlen_zero(name_fmt)) {
938                 manager_event(EVENT_FLAG_CALL, "Newchannel",
939                         "Channel: %s\r\n"
940                         "ChannelState: %d\r\n"
941                         "ChannelStateDesc: %s\r\n"
942                         "CallerIDNum: %s\r\n"
943                         "CallerIDName: %s\r\n"
944                         "AccountCode: %s\r\n"
945                         "Uniqueid: %s\r\n",
946                         tmp->name, 
947                         state, 
948                         ast_state2str(state),
949                         S_OR(cid_num, ""),
950                         S_OR(cid_name, ""),
951                         tmp->accountcode,
952                         tmp->uniqueid);
953         }
954
955         return tmp;
956 }
957
958 /*! \brief Queue an outgoing media frame */
959 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
960 {
961         struct ast_frame *f;
962         struct ast_frame *cur;
963         int blah = 1;
964         int qlen = 0;
965
966         /* Build us a copy and free the original one */
967         if (!(f = ast_frdup(fin))) {
968                 ast_log(LOG_WARNING, "Unable to duplicate frame\n");
969                 return -1;
970         }
971         ast_channel_lock(chan);
972
973         /* See if the last frame on the queue is a hangup, if so don't queue anything */
974         if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
975                 ast_frfree(f);
976                 ast_channel_unlock(chan);
977                 return 0;
978         }
979
980         /* Count how many frames exist on the queue */
981         AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
982                 qlen++;
983         }
984
985         /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
986         if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen  > 128)) {
987                 if (fin->frametype != AST_FRAME_VOICE) {
988                         ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name);
989                         ast_assert(fin->frametype == AST_FRAME_VOICE);
990                 } else {
991                         ast_debug(1, "Dropping voice to exceptionally long queue on %s\n", chan->name);
992                         ast_frfree(f);
993                         ast_channel_unlock(chan);
994                         return 0;
995                 }
996         }
997         AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
998         if (chan->alertpipe[1] > -1) {
999                 if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
1000                         ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
1001                                 chan->name, f->frametype, f->subclass, qlen, strerror(errno));
1002         } else if (chan->timingfd > -1) {
1003                 ast_timer_enable_continuous(chan->timingfd);
1004         } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1005                 pthread_kill(chan->blocker, SIGURG);
1006         }
1007         ast_channel_unlock(chan);
1008         return 0;
1009 }
1010
1011 /*! \brief Queue a hangup frame for channel */
1012 int ast_queue_hangup(struct ast_channel *chan)
1013 {
1014         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
1015         /* Yeah, let's not change a lock-critical value without locking */
1016         if (!ast_channel_trylock(chan)) {
1017                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
1018                 ast_channel_unlock(chan);
1019         }
1020         return ast_queue_frame(chan, &f);
1021 }
1022
1023 /*! \brief Queue a hangup frame for channel */
1024 int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
1025 {
1026         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
1027
1028         if (cause >= 0)
1029                 f.data.uint32 = cause;
1030
1031         /* Yeah, let's not change a lock-critical value without locking */
1032         if (!ast_channel_trylock(chan)) {
1033                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
1034                 if (cause < 0)
1035                         f.data.uint32 = chan->hangupcause;
1036
1037                 ast_channel_unlock(chan);
1038         }
1039
1040         return ast_queue_frame(chan, &f);
1041 }
1042
1043 /*! \brief Queue a control frame */
1044 int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
1045 {
1046         struct ast_frame f = { AST_FRAME_CONTROL, };
1047
1048         f.subclass = control;
1049
1050         return ast_queue_frame(chan, &f);
1051 }
1052
1053 /*! \brief Queue a control frame with payload */
1054 int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control,
1055                            const void *data, size_t datalen)
1056 {
1057         struct ast_frame f = { AST_FRAME_CONTROL, };
1058
1059         f.subclass = control;
1060         f.data.ptr = (void *) data;
1061         f.datalen = datalen;
1062
1063         return ast_queue_frame(chan, &f);
1064 }
1065
1066 /*! \brief Set defer DTMF flag on channel */
1067 int ast_channel_defer_dtmf(struct ast_channel *chan)
1068 {
1069         int pre = 0;
1070
1071         if (chan) {
1072                 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
1073                 ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
1074         }
1075         return pre;
1076 }
1077
1078 /*! \brief Unset defer DTMF flag on channel */
1079 void ast_channel_undefer_dtmf(struct ast_channel *chan)
1080 {
1081         if (chan)
1082                 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
1083 }
1084
1085 /*!
1086  * \brief Helper function to find channels.
1087  *
1088  * It supports these modes:
1089  *
1090  * prev != NULL : get channel next in list after prev
1091  * name != NULL : get channel with matching name
1092  * name != NULL && namelen != 0 : get channel whose name starts with prefix
1093  * exten != NULL : get channel whose exten or macroexten matches
1094  * context != NULL && exten != NULL : get channel whose context or macrocontext
1095  *
1096  * It returns with the channel's lock held. If getting the individual lock fails,
1097  * unlock and retry quickly up to 10 times, then give up.
1098  *
1099  * \note XXX Note that this code has cost O(N) because of the need to verify
1100  * that the object is still on the global list.
1101  *
1102  * \note XXX also note that accessing fields (e.g. c->name in ast_log())
1103  * can only be done with the lock held or someone could delete the
1104  * object while we work on it. This causes some ugliness in the code.
1105  * Note that removing the first ast_log() may be harmful, as it would
1106  * shorten the retry period and possibly cause failures.
1107  * We should definitely go for a better scheme that is deadlock-free.
1108  */
1109 static struct ast_channel *channel_find_locked(const struct ast_channel *prev,
1110                                                const char *name, const int namelen,
1111                                                const char *context, const char *exten)
1112 {
1113         const char *msg = prev ? "deadlock" : "initial deadlock";
1114         int retries;
1115         struct ast_channel *c;
1116         const struct ast_channel *_prev = prev;
1117
1118         for (retries = 0; retries < 200; retries++) {
1119                 int done;
1120                 /* Reset prev on each retry.  See note below for the reason. */
1121                 prev = _prev;
1122                 AST_RWLIST_RDLOCK(&channels);
1123                 AST_RWLIST_TRAVERSE(&channels, c, chan_list) {
1124                         if (prev) {     /* look for last item, first, before any evaluation */
1125                                 if (c != prev)  /* not this one */
1126                                         continue;
1127                                 /* found, prepare to return c->next */
1128                                 if ((c = AST_RWLIST_NEXT(c, chan_list)) == NULL) break;
1129                                 /*!\note
1130                                  * We're done searching through the list for the previous item.
1131                                  * Any item after this point, we want to evaluate for a match.
1132                                  * If we didn't set prev to NULL here, then we would only
1133                                  * return matches for the first matching item (since the above
1134                                  * "if (c != prev)" would not permit any other potential
1135                                  * matches to reach the additional matching logic, below).
1136                                  * Instead, it would just iterate until it once again found the
1137                                  * original match, then iterate down to the end of the list and
1138                                  * quit.
1139                                  */
1140                                 prev = NULL;
1141                         }
1142                         if (name) { /* want match by name */
1143                                 if ((!namelen && strcasecmp(c->name, name) && strcmp(c->uniqueid, name)) ||
1144                                     (namelen && strncasecmp(c->name, name, namelen)))
1145                                         continue;       /* name match failed */
1146                         } else if (exten) {
1147                                 if (context && strcasecmp(c->context, context) &&
1148                                     strcasecmp(c->macrocontext, context))
1149                                         continue;       /* context match failed */
1150                                 if (strcasecmp(c->exten, exten) &&
1151                                     strcasecmp(c->macroexten, exten))
1152                                         continue;       /* exten match failed */
1153                         }
1154                         /* if we get here, c points to the desired record */
1155                         break;
1156                 }
1157                 /* exit if chan not found or mutex acquired successfully */
1158                 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
1159                 done = c == NULL || ast_channel_trylock(c) == 0;
1160                 if (!done) {
1161                         ast_debug(1, "Avoiding %s for channel '%p'\n", msg, c);
1162                         if (retries == 199) {
1163                                 /* We are about to fail due to a deadlock, so report this
1164                                  * while we still have the list lock.
1165                                  */
1166                                 ast_debug(1, "Failure, could not lock '%p' after %d retries!\n", c, retries);
1167                                 /* As we have deadlocked, we will skip this channel and
1168                                  * see if there is another match.
1169                                  * NOTE: No point doing this for a full-name match,
1170                                  * as there can be no more matches.
1171                                  */
1172                                 if (!(name && !namelen)) {
1173                                         prev = c;
1174                                         retries = -1;
1175                                 }
1176                         }
1177                 }
1178                 AST_RWLIST_UNLOCK(&channels);
1179                 if (done)
1180                         return c;
1181                 /* If we reach this point we basically tried to lock a channel and failed. Instead of
1182                  * starting from the beginning of the list we can restore our saved pointer to the previous
1183                  * channel and start from there.
1184                  */
1185                 prev = _prev;
1186                 usleep(1);      /* give other threads a chance before retrying */
1187         }
1188
1189         return NULL;
1190 }
1191
1192 /*! \brief Browse channels in use */
1193 struct ast_channel *ast_channel_walk_locked(const struct ast_channel *prev)
1194 {
1195         return channel_find_locked(prev, NULL, 0, NULL, NULL);
1196 }
1197
1198 /*! \brief Get channel by name and lock it */
1199 struct ast_channel *ast_get_channel_by_name_locked(const char *name)
1200 {
1201         return channel_find_locked(NULL, name, 0, NULL, NULL);
1202 }
1203
1204 /*! \brief Get channel by name prefix and lock it */
1205 struct ast_channel *ast_get_channel_by_name_prefix_locked(const char *name, const int namelen)
1206 {
1207         return channel_find_locked(NULL, name, namelen, NULL, NULL);
1208 }
1209
1210 /*! \brief Get next channel by name prefix and lock it */
1211 struct ast_channel *ast_walk_channel_by_name_prefix_locked(const struct ast_channel *chan, const char *name,
1212                                                            const int namelen)
1213 {
1214         return channel_find_locked(chan, name, namelen, NULL, NULL);
1215 }
1216
1217 /*! \brief Get channel by exten (and optionally context) and lock it */
1218 struct ast_channel *ast_get_channel_by_exten_locked(const char *exten, const char *context)
1219 {
1220         return channel_find_locked(NULL, NULL, 0, context, exten);
1221 }
1222
1223 /*! \brief Get next channel by exten (and optionally context) and lock it */
1224 struct ast_channel *ast_walk_channel_by_exten_locked(const struct ast_channel *chan, const char *exten,
1225                                                      const char *context)
1226 {
1227         return channel_find_locked(chan, NULL, 0, context, exten);
1228 }
1229
1230 /*! \brief Wait, look for hangups and condition arg */
1231 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data)
1232 {
1233         struct ast_frame *f;
1234
1235         while (ms > 0) {
1236                 if (cond && ((*cond)(data) == 0))
1237                         return 0;
1238                 ms = ast_waitfor(chan, ms);
1239                 if (ms < 0)
1240                         return -1;
1241                 if (ms > 0) {
1242                         f = ast_read(chan);
1243                         if (!f)
1244                                 return -1;
1245                         ast_frfree(f);
1246                 }
1247         }
1248         return 0;
1249 }
1250
1251 /*! \brief Wait, look for hangups */
1252 int ast_safe_sleep(struct ast_channel *chan, int ms)
1253 {
1254         return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
1255 }
1256
1257 static void free_cid(struct ast_callerid *cid)
1258 {
1259         if (cid->cid_dnid)
1260                 ast_free(cid->cid_dnid);
1261         if (cid->cid_num)
1262                 ast_free(cid->cid_num); 
1263         if (cid->cid_name)
1264                 ast_free(cid->cid_name);        
1265         if (cid->cid_ani)
1266                 ast_free(cid->cid_ani);
1267         if (cid->cid_rdnis)
1268                 ast_free(cid->cid_rdnis);
1269         cid->cid_dnid = cid->cid_num = cid->cid_name = cid->cid_ani = cid->cid_rdnis = NULL;
1270 }
1271
1272 /*! \brief Free a channel structure */
1273 void ast_channel_free(struct ast_channel *chan)
1274 {
1275         int fd;
1276 #ifdef HAVE_EPOLL
1277         int i;
1278 #endif
1279         struct ast_var_t *vardata;
1280         struct ast_frame *f;
1281         struct varshead *headp;
1282         struct ast_datastore *datastore = NULL;
1283         char name[AST_CHANNEL_NAME], *dashptr;
1284         
1285         headp=&chan->varshead;
1286         
1287         AST_RWLIST_WRLOCK(&channels);
1288         if (!AST_RWLIST_REMOVE(&channels, chan, chan_list)) {
1289                 AST_RWLIST_UNLOCK(&channels);
1290                 ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
1291         }
1292         /* Lock and unlock the channel just to be sure nobody has it locked still
1293            due to a reference retrieved from the channel list. */
1294         ast_channel_lock(chan);
1295         ast_channel_unlock(chan);
1296
1297         /* Get rid of each of the data stores on the channel */
1298         while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
1299                 /* Free the data store */
1300                 ast_datastore_free(datastore);
1301
1302         /* Lock and unlock the channel just to be sure nobody has it locked still
1303            due to a reference that was stored in a datastore. (i.e. app_chanspy) */
1304         ast_channel_lock(chan);
1305         ast_channel_unlock(chan);
1306
1307         if (chan->tech_pvt) {
1308                 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
1309                 ast_free(chan->tech_pvt);
1310         }
1311
1312         if (chan->sched)
1313                 sched_context_destroy(chan->sched);
1314
1315         ast_copy_string(name, chan->name, sizeof(name));
1316         if ((dashptr = strrchr(name, '-'))) {
1317                 *dashptr = '\0';
1318         }
1319
1320         /* Stop monitoring */
1321         if (chan->monitor)
1322                 chan->monitor->stop( chan, 0 );
1323
1324         /* If there is native format music-on-hold state, free it */
1325         if (chan->music_state)
1326                 ast_moh_cleanup(chan);
1327
1328         /* Free translators */
1329         if (chan->readtrans)
1330                 ast_translator_free_path(chan->readtrans);
1331         if (chan->writetrans)
1332                 ast_translator_free_path(chan->writetrans);
1333         if (chan->pbx)
1334                 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
1335         free_cid(&chan->cid);
1336         /* Close pipes if appropriate */
1337         if ((fd = chan->alertpipe[0]) > -1)
1338                 close(fd);
1339         if ((fd = chan->alertpipe[1]) > -1)
1340                 close(fd);
1341         if ((fd = chan->timingfd) > -1)
1342                 ast_timer_close(fd);
1343 #ifdef HAVE_EPOLL
1344         for (i = 0; i < AST_MAX_FDS; i++) {
1345                 if (chan->epfd_data[i])
1346                         free(chan->epfd_data[i]);
1347         }
1348         close(chan->epfd);
1349 #endif
1350         while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
1351                 ast_frfree(f);
1352         
1353         /* loop over the variables list, freeing all data and deleting list items */
1354         /* no need to lock the list, as the channel is already locked */
1355         
1356         while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
1357                 ast_var_delete(vardata);
1358
1359         ast_app_group_discard(chan);
1360
1361         /* Destroy the jitterbuffer */
1362         ast_jb_destroy(chan);
1363
1364         if (chan->cdr) {
1365                 ast_cdr_discard(chan->cdr);
1366                 chan->cdr = NULL;
1367         }
1368         
1369         ast_mutex_destroy(&chan->lock_dont_use);
1370
1371         ast_string_field_free_memory(chan);
1372         ast_free(chan);
1373         AST_RWLIST_UNLOCK(&channels);
1374
1375         ast_devstate_changed_literal(AST_DEVICE_NOT_INUSE, name);
1376 }
1377
1378 struct ast_datastore *ast_channel_datastore_alloc(const struct ast_datastore_info *info, const char *uid)
1379 {
1380         return ast_datastore_alloc(info, uid);
1381 }
1382
1383 int ast_channel_datastore_free(struct ast_datastore *datastore)
1384 {
1385         return ast_datastore_free(datastore);
1386 }
1387
1388 int ast_channel_datastore_inherit(struct ast_channel *from, struct ast_channel *to)
1389 {
1390         struct ast_datastore *datastore = NULL, *datastore2;
1391
1392         AST_LIST_TRAVERSE(&from->datastores, datastore, entry) {
1393                 if (datastore->inheritance > 0) {
1394                         datastore2 = ast_datastore_alloc(datastore->info, datastore->uid);
1395                         if (datastore2) {
1396                                 datastore2->data = datastore->info->duplicate(datastore->data);
1397                                 datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
1398                                 AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry);
1399                         }
1400                 }
1401         }
1402         return 0;
1403 }
1404
1405 int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
1406 {
1407         int res = 0;
1408
1409         AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
1410
1411         return res;
1412 }
1413
1414 int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
1415 {
1416         return AST_LIST_REMOVE(&chan->datastores, datastore, entry) ? 0 : -1;
1417 }
1418
1419 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
1420 {
1421         struct ast_datastore *datastore = NULL;
1422         
1423         if (info == NULL)
1424                 return NULL;
1425
1426         AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
1427                 if (datastore->info != info) {
1428                         continue;
1429                 }
1430
1431                 if (uid == NULL) {
1432                         /* matched by type only */
1433                         break;
1434                 }
1435
1436                 if ((datastore->uid != NULL) && !strcasecmp(uid, datastore->uid)) {
1437                         /* Matched by type AND uid */
1438                         break;
1439                 }
1440         }
1441         AST_LIST_TRAVERSE_SAFE_END;
1442
1443         return datastore;
1444 }
1445
1446 /*! Set the file descriptor on the channel */
1447 void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
1448 {
1449 #ifdef HAVE_EPOLL
1450         struct epoll_event ev;
1451         struct ast_epoll_data *aed = NULL;
1452
1453         if (chan->fds[which] > -1) {
1454                 epoll_ctl(chan->epfd, EPOLL_CTL_DEL, chan->fds[which], &ev);
1455                 aed = chan->epfd_data[which];
1456         }
1457
1458         /* If this new fd is valid, add it to the epoll */
1459         if (fd > -1) {
1460                 if (!aed && (!(aed = ast_calloc(1, sizeof(*aed)))))
1461                         return;
1462                 
1463                 chan->epfd_data[which] = aed;
1464                 aed->chan = chan;
1465                 aed->which = which;
1466                 
1467                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1468                 ev.data.ptr = aed;
1469                 epoll_ctl(chan->epfd, EPOLL_CTL_ADD, fd, &ev);
1470         } else if (aed) {
1471                 /* We don't have to keep around this epoll data structure now */
1472                 free(aed);
1473                 chan->epfd_data[which] = NULL;
1474         }
1475 #endif
1476         chan->fds[which] = fd;
1477         return;
1478 }
1479
1480 /*! Add a channel to an optimized waitfor */
1481 void ast_poll_channel_add(struct ast_channel *chan0, struct ast_channel *chan1)
1482 {
1483 #ifdef HAVE_EPOLL
1484         struct epoll_event ev;
1485         int i = 0;
1486
1487         if (chan0->epfd == -1)
1488                 return;
1489
1490         /* Iterate through the file descriptors on chan1, adding them to chan0 */
1491         for (i = 0; i < AST_MAX_FDS; i++) {
1492                 if (chan1->fds[i] == -1)
1493                         continue;
1494                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1495                 ev.data.ptr = chan1->epfd_data[i];
1496                 epoll_ctl(chan0->epfd, EPOLL_CTL_ADD, chan1->fds[i], &ev);
1497         }
1498
1499 #endif
1500         return;
1501 }
1502
1503 /*! Delete a channel from an optimized waitfor */
1504 void ast_poll_channel_del(struct ast_channel *chan0, struct ast_channel *chan1)
1505 {
1506 #ifdef HAVE_EPOLL
1507         struct epoll_event ev;
1508         int i = 0;
1509
1510         if (chan0->epfd == -1)
1511                 return;
1512
1513         for (i = 0; i < AST_MAX_FDS; i++) {
1514                 if (chan1->fds[i] == -1)
1515                         continue;
1516                 epoll_ctl(chan0->epfd, EPOLL_CTL_DEL, chan1->fds[i], &ev);
1517         }
1518
1519 #endif
1520         return;
1521 }
1522
1523 /*! \brief Softly hangup a channel, don't lock */
1524 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
1525 {
1526         ast_debug(1, "Soft-Hanging up channel '%s'\n", chan->name);
1527         /* Inform channel driver that we need to be hung up, if it cares */
1528         chan->_softhangup |= cause;
1529         ast_queue_frame(chan, &ast_null_frame);
1530         /* Interrupt any poll call or such */
1531         if (ast_test_flag(chan, AST_FLAG_BLOCKING))
1532                 pthread_kill(chan->blocker, SIGURG);
1533         return 0;
1534 }
1535
1536 /*! \brief Softly hangup a channel, lock */
1537 int ast_softhangup(struct ast_channel *chan, int cause)
1538 {
1539         int res;
1540
1541         ast_channel_lock(chan);
1542         res = ast_softhangup_nolock(chan, cause);
1543         ast_channel_unlock(chan);
1544
1545         return res;
1546 }
1547
1548 static void free_translation(struct ast_channel *clonechan)
1549 {
1550         if (clonechan->writetrans)
1551                 ast_translator_free_path(clonechan->writetrans);
1552         if (clonechan->readtrans)
1553                 ast_translator_free_path(clonechan->readtrans);
1554         clonechan->writetrans = NULL;
1555         clonechan->readtrans = NULL;
1556         clonechan->rawwriteformat = clonechan->nativeformats;
1557         clonechan->rawreadformat = clonechan->nativeformats;
1558 }
1559
1560 /*! \brief Hangup a channel */
1561 int ast_hangup(struct ast_channel *chan)
1562 {
1563         int res = 0;
1564
1565         /* Don't actually hang up a channel that will masquerade as someone else, or
1566            if someone is going to masquerade as us */
1567         ast_channel_lock(chan);
1568
1569         if (chan->audiohooks) {
1570                 ast_audiohook_detach_list(chan->audiohooks);
1571                 chan->audiohooks = NULL;
1572         }
1573
1574         ast_autoservice_stop(chan);
1575
1576         if (chan->masq) {
1577                 if (ast_do_masquerade(chan))
1578                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1579         }
1580
1581         if (chan->masq) {
1582                 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
1583                 ast_channel_unlock(chan);
1584                 return 0;
1585         }
1586         /* If this channel is one which will be masqueraded into something,
1587            mark it as a zombie already, so we know to free it later */
1588         if (chan->masqr) {
1589                 ast_set_flag(chan, AST_FLAG_ZOMBIE);
1590                 ast_channel_unlock(chan);
1591                 return 0;
1592         }
1593         free_translation(chan);
1594         /* Close audio stream */
1595         if (chan->stream) {
1596                 ast_closestream(chan->stream);
1597                 chan->stream = NULL;
1598         }
1599         /* Close video stream */
1600         if (chan->vstream) {
1601                 ast_closestream(chan->vstream);
1602                 chan->vstream = NULL;
1603         }
1604         if (chan->sched) {
1605                 sched_context_destroy(chan->sched);
1606                 chan->sched = NULL;
1607         }
1608         
1609         if (chan->generatordata)        /* Clear any tone stuff remaining */
1610                 if (chan->generator && chan->generator->release)
1611                         chan->generator->release(chan, chan->generatordata);
1612         chan->generatordata = NULL;
1613         chan->generator = NULL;
1614         if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1615                 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
1616                                         "is blocked by thread %ld in procedure %s!  Expect a failure\n",
1617                                         (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
1618                 ast_assert(ast_test_flag(chan, AST_FLAG_BLOCKING) == 0);
1619         }
1620         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
1621                 ast_debug(1, "Hanging up channel '%s'\n", chan->name);
1622                 if (chan->tech->hangup)
1623                         res = chan->tech->hangup(chan);
1624         } else {
1625                 ast_debug(1, "Hanging up zombie '%s'\n", chan->name);
1626         }
1627                         
1628         ast_channel_unlock(chan);
1629         manager_event(EVENT_FLAG_CALL, "Hangup",
1630                         "Channel: %s\r\n"
1631                         "Uniqueid: %s\r\n"
1632                         "CallerIDNum: %s\r\n"
1633                         "CallerIDName: %s\r\n"
1634                         "Cause: %d\r\n"
1635                         "Cause-txt: %s\r\n",
1636                         chan->name,
1637                         chan->uniqueid,
1638                         S_OR(chan->cid.cid_num, "<unknown>"),
1639                         S_OR(chan->cid.cid_name, "<unknown>"),
1640                         chan->hangupcause,
1641                         ast_cause2str(chan->hangupcause)
1642                         );
1643
1644         if (chan->cdr && !ast_test_flag(chan->cdr, AST_CDR_FLAG_BRIDGED) && 
1645                 !ast_test_flag(chan->cdr, AST_CDR_FLAG_POST_DISABLED) && 
1646             (chan->cdr->disposition != AST_CDR_NULL || ast_test_flag(chan->cdr, AST_CDR_FLAG_DIALED))) {
1647                         
1648                 ast_cdr_end(chan->cdr);
1649                 ast_cdr_detach(chan->cdr);
1650                 chan->cdr = NULL;
1651         }
1652         
1653         ast_channel_free(chan);
1654
1655         return res;
1656 }
1657
1658 #define ANSWER_WAIT_MS 500
1659 int __ast_answer(struct ast_channel *chan, unsigned int delay)
1660 {
1661         int res = 0;
1662
1663         ast_channel_lock(chan);
1664
1665         /* You can't answer an outbound call */
1666         if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
1667                 ast_channel_unlock(chan);
1668                 return 0;
1669         }
1670
1671         /* Stop if we're a zombie or need a soft hangup */
1672         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1673                 ast_channel_unlock(chan);
1674                 return -1;
1675         }
1676
1677         switch (chan->_state) {
1678         case AST_STATE_RINGING:
1679         case AST_STATE_RING:
1680                 if (chan->tech->answer)
1681                         res = chan->tech->answer(chan);
1682                 ast_setstate(chan, AST_STATE_UP);
1683                 ast_cdr_answer(chan->cdr);
1684                 if (delay)
1685                         ast_safe_sleep(chan, delay);
1686                 else {
1687                         struct ast_frame *f;
1688                         int ms = ANSWER_WAIT_MS;
1689                         while (1) {
1690                                 /* 500 ms was the original delay here, so now
1691                                  * we cap our waiting at 500 ms
1692                                  */
1693                                 ms = ast_waitfor(chan, ms);
1694                                 if (ms < 0) {
1695                                         ast_log(LOG_WARNING, "Error condition occurred when polling channel %s for a voice frame: %s\n", chan->name, strerror(errno));
1696                                         res = -1;
1697                                         break;
1698                                 }
1699                                 if (ms == 0) {
1700                                         ast_debug(2, "Didn't receive a voice frame from %s within %d ms of answering. Continuing anyway\n", chan->name, ANSWER_WAIT_MS);
1701                                         res = 0;
1702                                         break;
1703                                 }
1704                                 f = ast_read(chan);
1705                                 if (!f || (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)) {
1706                                         res = -1;
1707                                         ast_debug(2, "Hangup of channel %s detected in answer routine\n", chan->name);
1708                                         break;
1709                                 }
1710                                 if (f->frametype == AST_FRAME_VOICE) {
1711                                         res = 0;
1712                                         break;
1713                                 }
1714                         }
1715                 }
1716                 break;
1717         case AST_STATE_UP:
1718                 break;
1719         default:
1720                 break;
1721         }
1722         chan->visible_indication = 0;
1723         ast_channel_unlock(chan);
1724
1725         return res;
1726 }
1727
1728 int ast_answer(struct ast_channel *chan)
1729 {
1730         return __ast_answer(chan, 0);
1731 }
1732
1733 void ast_deactivate_generator(struct ast_channel *chan)
1734 {
1735         ast_channel_lock(chan);
1736         if (chan->generatordata) {
1737                 if (chan->generator && chan->generator->release)
1738                         chan->generator->release(chan, chan->generatordata);
1739                 chan->generatordata = NULL;
1740                 chan->generator = NULL;
1741                 ast_channel_set_fd(chan, AST_GENERATOR_FD, -1);
1742                 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1743                 ast_settimeout(chan, 0, NULL, NULL);
1744         }
1745         ast_channel_unlock(chan);
1746 }
1747
1748 static int generator_force(const void *data)
1749 {
1750         /* Called if generator doesn't have data */
1751         void *tmp;
1752         int res;
1753         int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL;
1754         struct ast_channel *chan = (struct ast_channel *)data;
1755
1756         ast_channel_lock(chan);
1757         tmp = chan->generatordata;
1758         chan->generatordata = NULL;
1759         if (chan->generator)
1760                 generate = chan->generator->generate;
1761         ast_channel_unlock(chan);
1762
1763         if (!tmp || !generate)
1764                 return 0;
1765
1766         res = generate(chan, tmp, 0, ast_format_rate(chan->writeformat & AST_FORMAT_AUDIO_MASK) / 50);
1767
1768         chan->generatordata = tmp;
1769
1770         if (res) {
1771                 ast_debug(1, "Auto-deactivating generator\n");
1772                 ast_deactivate_generator(chan);
1773         }
1774
1775         return 0;
1776 }
1777
1778 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1779 {
1780         int res = 0;
1781
1782         ast_channel_lock(chan);
1783
1784         if (chan->generatordata) {
1785                 if (chan->generator && chan->generator->release)
1786                         chan->generator->release(chan, chan->generatordata);
1787                 chan->generatordata = NULL;
1788         }
1789
1790         ast_prod(chan);
1791         if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1792                 res = -1;
1793         }
1794         
1795         if (!res) {
1796                 ast_settimeout(chan, 50, generator_force, chan);
1797                 chan->generator = gen;
1798         }
1799
1800         ast_channel_unlock(chan);
1801
1802         return res;
1803 }
1804
1805 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1806 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1807 {
1808         int winner = -1;
1809         ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1810         return winner;
1811 }
1812
1813 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1814 #ifdef HAVE_EPOLL
1815 static struct ast_channel *ast_waitfor_nandfds_classic(struct ast_channel **c, int n, int *fds, int nfds,
1816                                         int *exception, int *outfd, int *ms)
1817 #else
1818 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1819                                         int *exception, int *outfd, int *ms)
1820 #endif
1821 {
1822         struct timeval start = { 0 , 0 };
1823         struct pollfd *pfds = NULL;
1824         int res;
1825         long rms;
1826         int x, y, max;
1827         int sz;
1828         struct timeval now = { 0, 0 };
1829         struct timeval whentohangup = { 0, 0 }, diff;
1830         struct ast_channel *winner = NULL;
1831         struct fdmap {
1832                 int chan;
1833                 int fdno;
1834         } *fdmap = NULL;
1835
1836         if ((sz = n * AST_MAX_FDS + nfds)) {
1837                 pfds = alloca(sizeof(*pfds) * sz);
1838                 fdmap = alloca(sizeof(*fdmap) * sz);
1839         }
1840
1841         if (outfd)
1842                 *outfd = -99999;
1843         if (exception)
1844                 *exception = 0;
1845         
1846         /* Perform any pending masquerades */
1847         for (x = 0; x < n; x++) {
1848                 ast_channel_lock(c[x]);
1849                 if (c[x]->masq && ast_do_masquerade(c[x])) {
1850                         ast_log(LOG_WARNING, "Masquerade failed\n");
1851                         *ms = -1;
1852                         ast_channel_unlock(c[x]);
1853                         return NULL;
1854                 }
1855                 if (!ast_tvzero(c[x]->whentohangup)) {
1856                         if (ast_tvzero(whentohangup))
1857                                 now = ast_tvnow();
1858                         diff = ast_tvsub(c[x]->whentohangup, now);
1859                         if (diff.tv_sec < 0 || ast_tvzero(diff)) {
1860                                 /* Should already be hungup */
1861                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1862                                 ast_channel_unlock(c[x]);
1863                                 return c[x];
1864                         }
1865                         if (ast_tvzero(whentohangup) || ast_tvcmp(diff, whentohangup) < 0)
1866                                 whentohangup = diff;
1867                 }
1868                 ast_channel_unlock(c[x]);
1869         }
1870         /* Wait full interval */
1871         rms = *ms;
1872         if (!ast_tvzero(whentohangup)) {
1873                 rms = whentohangup.tv_sec * 1000 + whentohangup.tv_usec / 1000;              /* timeout in milliseconds */
1874                 if (*ms >= 0 && *ms < rms)              /* original *ms still smaller */
1875                         rms =  *ms;
1876         }
1877         /*
1878          * Build the pollfd array, putting the channels' fds first,
1879          * followed by individual fds. Order is important because
1880          * individual fd's must have priority over channel fds.
1881          */
1882         max = 0;
1883         for (x = 0; x < n; x++) {
1884                 for (y = 0; y < AST_MAX_FDS; y++) {
1885                         fdmap[max].fdno = y;  /* fd y is linked to this pfds */
1886                         fdmap[max].chan = x;  /* channel x is linked to this pfds */
1887                         max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1888                 }
1889                 CHECK_BLOCKING(c[x]);
1890         }
1891         /* Add the individual fds */
1892         for (x = 0; x < nfds; x++) {
1893                 fdmap[max].chan = -1;
1894                 max += ast_add_fd(&pfds[max], fds[x]);
1895         }
1896
1897         if (*ms > 0)
1898                 start = ast_tvnow();
1899         
1900         if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1901                 do {
1902                         int kbrms = rms;
1903                         if (kbrms > 600000)
1904                                 kbrms = 600000;
1905                         res = poll(pfds, max, kbrms);
1906                         if (!res)
1907                                 rms -= kbrms;
1908                 } while (!res && (rms > 0));
1909         } else {
1910                 res = poll(pfds, max, rms);
1911         }
1912         for (x = 0; x < n; x++)
1913                 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1914         if (res < 0) { /* Simulate a timeout if we were interrupted */
1915                 if (errno != EINTR)
1916                         *ms = -1;
1917                 return NULL;
1918         }
1919         if (!ast_tvzero(whentohangup)) {   /* if we have a timeout, check who expired */
1920                 now = ast_tvnow();
1921                 for (x = 0; x < n; x++) {
1922                         if (!ast_tvzero(c[x]->whentohangup) && ast_tvcmp(c[x]->whentohangup, now) <= 0) {
1923                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1924                                 if (winner == NULL)
1925                                         winner = c[x];
1926                         }
1927                 }
1928         }
1929         if (res == 0) { /* no fd ready, reset timeout and done */
1930                 *ms = 0;        /* XXX use 0 since we may not have an exact timeout. */
1931                 return winner;
1932         }
1933         /*
1934          * Then check if any channel or fd has a pending event.
1935          * Remember to check channels first and fds last, as they
1936          * must have priority on setting 'winner'
1937          */
1938         for (x = 0; x < max; x++) {
1939                 res = pfds[x].revents;
1940                 if (res == 0)
1941                         continue;
1942                 if (fdmap[x].chan >= 0) {       /* this is a channel */
1943                         winner = c[fdmap[x].chan];      /* override previous winners */
1944                         if (res & POLLPRI)
1945                                 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1946                         else
1947                                 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1948                         winner->fdno = fdmap[x].fdno;
1949                 } else {                        /* this is an fd */
1950                         if (outfd)
1951                                 *outfd = pfds[x].fd;
1952                         if (exception)
1953                                 *exception = (res & POLLPRI) ? -1 : 0;
1954                         winner = NULL;
1955                 }
1956         }
1957         if (*ms > 0) {
1958                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1959                 if (*ms < 0)
1960                         *ms = 0;
1961         }
1962         return winner;
1963 }
1964
1965 #ifdef HAVE_EPOLL
1966 static struct ast_channel *ast_waitfor_nandfds_simple(struct ast_channel *chan, int *ms)
1967 {
1968         struct timeval start = { 0 , 0 };
1969         int res = 0;
1970         struct epoll_event ev[1];
1971         long diff, rms = *ms;
1972         struct ast_channel *winner = NULL;
1973         struct ast_epoll_data *aed = NULL;
1974
1975         ast_channel_lock(chan);
1976
1977         /* See if this channel needs to be masqueraded */
1978         if (chan->masq && ast_do_masquerade(chan)) {
1979                 ast_log(LOG_WARNING, "Failed to perform masquerade on %s\n", chan->name);
1980                 *ms = -1;
1981                 ast_channel_unlock(chan);
1982                 return NULL;
1983         }
1984
1985         /* Figure out their timeout */
1986         if (!ast_tvzero(chan->whentohangup)) {
1987                 if ((diff = ast_tvdiff_ms(chan->whentohangup, ast_tvnow())) < 0) {
1988                         /* They should already be hungup! */
1989                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1990                         ast_channel_unlock(chan);
1991                         return NULL;
1992                 }
1993                 /* If this value is smaller then the current one... make it priority */
1994                 if (rms > diff)
1995                         rms = diff;
1996         }
1997
1998         ast_channel_unlock(chan);
1999
2000         /* Time to make this channel block... */
2001         CHECK_BLOCKING(chan);
2002
2003         if (*ms > 0)
2004                 start = ast_tvnow();
2005
2006         /* We don't have to add any file descriptors... they are already added, we just have to wait! */
2007         res = epoll_wait(chan->epfd, ev, 1, rms);
2008
2009         /* Stop blocking */
2010         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2011
2012         /* Simulate a timeout if we were interrupted */
2013         if (res < 0) {
2014                 if (errno != EINTR)
2015                         *ms = -1;
2016                 return NULL;
2017         }
2018
2019         /* If this channel has a timeout see if it expired */
2020         if (!ast_tvzero(chan->whentohangup)) {
2021                 if (ast_tvdiff_ms(ast_tvnow(), chan->whentohangup) >= 0) {
2022                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2023                         winner = chan;
2024                 }
2025         }
2026
2027         /* No fd ready, reset timeout and be done for now */
2028         if (!res) {
2029                 *ms = 0;
2030                 return winner;
2031         }
2032
2033         /* See what events are pending */
2034         aed = ev[0].data.ptr;
2035         chan->fdno = aed->which;
2036         if (ev[0].events & EPOLLPRI)
2037                 ast_set_flag(chan, AST_FLAG_EXCEPTION);
2038         else
2039                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2040
2041         if (*ms > 0) {
2042                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
2043                 if (*ms < 0)
2044                         *ms = 0;
2045         }
2046
2047         return chan;
2048 }
2049
2050 static struct ast_channel *ast_waitfor_nandfds_complex(struct ast_channel **c, int n, int *ms)
2051 {
2052         struct timeval start = { 0 , 0 };
2053         int res = 0, i;
2054         struct epoll_event ev[25] = { { 0, } };
2055         struct timeval now = { 0, 0 };
2056         long whentohangup = 0, diff = 0, rms = *ms;
2057         struct ast_channel *winner = NULL;
2058
2059         for (i = 0; i < n; i++) {
2060                 ast_channel_lock(c[i]);
2061                 if (c[i]->masq && ast_do_masquerade(c[i])) {
2062                         ast_log(LOG_WARNING, "Masquerade failed\n");
2063                         *ms = -1;
2064                         ast_channel_unlock(c[i]);
2065                         return NULL;
2066                 }
2067                 if (!ast_tvzero(c[i]->whentohangup)) {
2068                         if (whentohangup == 0)
2069                                 now = ast_tvnow();
2070                         if ((diff = ast_tvdiff_ms(c[i]->whentohangup, now)) < 0) {
2071                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2072                                 ast_channel_unlock(c[i]);
2073                                 return c[i];
2074                         }
2075                         if (!whentohangup || whentohangup > diff)
2076                                 whentohangup = diff;
2077                 }
2078                 ast_channel_unlock(c[i]);
2079                 CHECK_BLOCKING(c[i]);
2080         }
2081
2082         rms = *ms;
2083         if (whentohangup) {
2084                 rms = whentohangup;
2085                 if (*ms >= 0 && *ms < rms)
2086                         rms = *ms;
2087         }
2088
2089         if (*ms > 0)
2090                 start = ast_tvnow();
2091
2092         res = epoll_wait(c[0]->epfd, ev, 25, rms);
2093
2094         for (i = 0; i < n; i++)
2095                 ast_clear_flag(c[i], AST_FLAG_BLOCKING);
2096
2097         if (res < 0) {
2098                 if (errno != EINTR)
2099                         *ms = -1;
2100                 return NULL;
2101         }
2102
2103         if (whentohangup) {
2104                 now = ast_tvnow();
2105                 for (i = 0; i < n; i++) {
2106                         if (!ast_tvzero(c[i]->whentohangup) && ast_tvdiff_ms(now, c[i]->whentohangup) >= 0) {
2107                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
2108                                 if (!winner)
2109                                         winner = c[i];
2110                         }
2111                 }
2112         }
2113
2114         if (!res) {
2115                 *ms = 0;
2116                 return winner;
2117         }
2118
2119         for (i = 0; i < res; i++) {
2120                 struct ast_epoll_data *aed = ev[i].data.ptr;
2121
2122                 if (!ev[i].events || !aed)
2123                         continue;
2124
2125                 winner = aed->chan;
2126                 if (ev[i].events & EPOLLPRI)
2127                         ast_set_flag(winner, AST_FLAG_EXCEPTION);
2128                 else
2129                         ast_clear_flag(winner, AST_FLAG_EXCEPTION);
2130                 winner->fdno = aed->which;
2131         }
2132
2133         if (*ms > 0) {
2134                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
2135                 if (*ms < 0)
2136                         *ms = 0;
2137         }
2138
2139         return winner;
2140 }
2141
2142 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
2143                                         int *exception, int *outfd, int *ms)
2144 {
2145         /* Clear all provided values in one place. */
2146         if (outfd)
2147                 *outfd = -99999;
2148         if (exception)
2149                 *exception = 0;
2150
2151         /* If no epoll file descriptor is available resort to classic nandfds */
2152         if (!n || nfds || c[0]->epfd == -1)
2153                 return ast_waitfor_nandfds_classic(c, n, fds, nfds, exception, outfd, ms);
2154         else if (!nfds && n == 1)
2155                 return ast_waitfor_nandfds_simple(c[0], ms);
2156         else
2157                 return ast_waitfor_nandfds_complex(c, n, ms);
2158 }
2159 #endif
2160
2161 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
2162 {
2163         return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
2164 }
2165
2166 int ast_waitfor(struct ast_channel *c, int ms)
2167 {
2168         int oldms = ms; /* -1 if no timeout */
2169
2170         ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
2171         if ((ms < 0) && (oldms < 0))
2172                 ms = 0;
2173         return ms;
2174 }
2175
2176 /* XXX never to be called with ms = -1 */
2177 int ast_waitfordigit(struct ast_channel *c, int ms)
2178 {
2179         return ast_waitfordigit_full(c, ms, -1, -1);
2180 }
2181
2182 int ast_settimeout(struct ast_channel *c, unsigned int rate, int (*func)(const void *data), void *data)
2183 {
2184         int res;
2185         unsigned int real_rate = rate, max_rate;
2186
2187         if (c->timingfd == -1) {
2188                 return -1;
2189         }
2190
2191         if (!func) {
2192                 rate = 0;
2193                 data = NULL;
2194         }
2195
2196         if (rate && rate > (max_rate = ast_timer_get_max_rate(c->timingfd))) {
2197                 real_rate = max_rate;
2198         }
2199
2200         ast_debug(1, "Scheduling timer at (%u requested / %u actual) timer ticks per second\n", rate, real_rate);
2201
2202         res = ast_timer_set_rate(c->timingfd, real_rate);
2203
2204         c->timingfunc = func;
2205         c->timingdata = data;
2206
2207         return res;
2208 }
2209
2210 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
2211 {
2212         /* Stop if we're a zombie or need a soft hangup */
2213         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
2214                 return -1;
2215
2216         /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
2217         ast_set_flag(c, AST_FLAG_END_DTMF_ONLY);
2218
2219         /* Wait for a digit, no more than ms milliseconds total. */
2220         
2221         while (ms) {
2222                 struct ast_channel *rchan;
2223                 int outfd=-1;
2224
2225                 errno = 0;
2226                 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
2227                 
2228                 if (!rchan && outfd < 0 && ms) {
2229                         if (errno == 0 || errno == EINTR)
2230                                 continue;
2231                         ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
2232                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2233                         return -1;
2234                 } else if (outfd > -1) {
2235                         /* The FD we were watching has something waiting */
2236                         ast_log(LOG_WARNING, "The FD we were waiting for has something waiting. Waitfordigit returning numeric 1\n");
2237                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2238                         return 1;
2239                 } else if (rchan) {
2240                         int res;
2241                         struct ast_frame *f = ast_read(c);
2242                         if (!f)
2243                                 return -1;
2244
2245                         switch (f->frametype) {
2246                         case AST_FRAME_DTMF_BEGIN:
2247                                 break;
2248                         case AST_FRAME_DTMF_END:
2249                                 res = f->subclass;
2250                                 ast_frfree(f);
2251                                 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2252                                 return res;
2253                         case AST_FRAME_CONTROL:
2254                                 switch (f->subclass) {
2255                                 case AST_CONTROL_HANGUP:
2256                                         ast_frfree(f);
2257                                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2258                                         return -1;
2259                                 case AST_CONTROL_RINGING:
2260                                 case AST_CONTROL_ANSWER:
2261                                 case AST_CONTROL_SRCUPDATE:
2262                                         /* Unimportant */
2263                                         break;
2264                                 default:
2265                                         ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
2266                                         break;
2267                                 }
2268                                 break;
2269                         case AST_FRAME_VOICE:
2270                                 /* Write audio if appropriate */
2271                                 if (audiofd > -1)
2272                                         write(audiofd, f->data.ptr, f->datalen);
2273                         default:
2274                                 /* Ignore */
2275                                 break;
2276                         }
2277                         ast_frfree(f);
2278                 }
2279         }
2280
2281         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2282
2283         return 0; /* Time is up */
2284 }
2285
2286 static void send_dtmf_event(const struct ast_channel *chan, const char *direction, const char digit, const char *begin, const char *end)
2287 {
2288         manager_event(EVENT_FLAG_DTMF,
2289                         "DTMF",
2290                         "Channel: %s\r\n"
2291                         "Uniqueid: %s\r\n"
2292                         "Digit: %c\r\n"
2293                         "Direction: %s\r\n"
2294                         "Begin: %s\r\n"
2295                         "End: %s\r\n",
2296                         chan->name, chan->uniqueid, digit, direction, begin, end);
2297 }
2298
2299 static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
2300 {
2301         if (chan->generatordata &&  !ast_internal_timing_enabled(chan)) {
2302                 void *tmp = chan->generatordata;
2303                 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL;
2304                 int res;
2305                 int samples;
2306
2307                 if (chan->timingfunc) {
2308                         ast_debug(1, "Generator got voice, switching to phase locked mode\n");
2309                         ast_settimeout(chan, 0, NULL, NULL);
2310                 }
2311
2312                 chan->generatordata = NULL;     /* reset, to let writes go through */
2313
2314                 if (f->subclass != chan->writeformat) {
2315                         float factor;
2316                         factor = ((float) ast_format_rate(chan->writeformat)) / ((float) ast_format_rate(f->subclass));
2317                         samples = (int) ( ((float) f->samples) * factor );
2318                 } else {
2319                         samples = f->samples;
2320                 }
2321                 
2322                 if (chan->generator->generate) {
2323                         generate = chan->generator->generate;
2324                 }
2325                 /* This unlock is here based on two assumptions that hold true at this point in the
2326                  * code. 1) this function is only called from within __ast_read() and 2) all generators
2327                  * call ast_write() in their generate callback.
2328                  *
2329                  * The reason this is added is so that when ast_write is called, the lock that occurs 
2330                  * there will not recursively lock the channel. Doing this will cause intended deadlock 
2331                  * avoidance not to work in deeper functions
2332                  */
2333                 ast_channel_unlock(chan);
2334                 res = generate(chan, tmp, f->datalen, samples);
2335                 ast_channel_lock(chan);
2336                 chan->generatordata = tmp;
2337                 if (res) {
2338                         ast_debug(1, "Auto-deactivating generator\n");
2339                         ast_deactivate_generator(chan);
2340                 }
2341
2342         } else if (f->frametype == AST_FRAME_CNG) {
2343                 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
2344                         ast_debug(1, "Generator got CNG, switching to timed mode\n");
2345                         ast_settimeout(chan, 50, generator_force, chan);
2346                 }
2347         }
2348 }
2349
2350 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
2351 {
2352         struct ast_frame *f = NULL;     /* the return value */
2353         int blah;
2354         int prestate;
2355         int count = 0, cause = 0;
2356
2357         /* this function is very long so make sure there is only one return
2358          * point at the end (there are only two exceptions to this).
2359          */
2360         while(ast_channel_trylock(chan)) {
2361                 if(count++ > 10) 
2362                         /*cannot goto done since the channel is not locked*/
2363                         return &ast_null_frame;
2364                 usleep(1);
2365         }
2366
2367         if (chan->masq) {
2368                 if (ast_do_masquerade(chan))
2369                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2370                 else
2371                         f =  &ast_null_frame;
2372                 goto done;
2373         }
2374
2375         /* Stop if we're a zombie or need a soft hangup */
2376         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2377                 if (chan->generator)
2378                         ast_deactivate_generator(chan);
2379                 goto done;
2380         }
2381         prestate = chan->_state;
2382
2383         if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) && 
2384             !ast_strlen_zero(chan->dtmfq) && 
2385                 (ast_tvzero(chan->dtmf_tv) || ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) > AST_MIN_DTMF_GAP) ) {
2386                 /* We have DTMF that has been deferred.  Return it now */
2387                 chan->dtmff.subclass = chan->dtmfq[0];
2388                 /* Drop first digit from the buffer */
2389                 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
2390                 f = &chan->dtmff;
2391                 if (ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
2392                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2393                         chan->dtmff.frametype = AST_FRAME_DTMF_END;
2394                 } else {
2395                         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);
2396                         chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
2397                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2398                         chan->emulate_dtmf_digit = f->subclass;
2399                         chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2400                 }
2401                 chan->dtmf_tv = ast_tvnow();
2402                 goto done;
2403         }
2404         
2405         /* Read and ignore anything on the alertpipe, but read only
2406            one sizeof(blah) per frame that we send from it */
2407         if (chan->alertpipe[0] > -1) {
2408                 int flags = fcntl(chan->alertpipe[0], F_GETFL);
2409                 /* For some odd reason, the alertpipe occasionally loses nonblocking status,
2410                  * which immediately causes a deadlock scenario.  Detect and prevent this. */
2411                 if ((flags & O_NONBLOCK) == 0) {
2412                         ast_log(LOG_ERROR, "Alertpipe on channel %s lost O_NONBLOCK?!!\n", chan->name);
2413                         if (fcntl(chan->alertpipe[0], F_SETFL, flags | O_NONBLOCK) < 0) {
2414                                 ast_log(LOG_WARNING, "Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno));
2415                                 f = &ast_null_frame;
2416                                 goto done;
2417                         }
2418                 }
2419                 read(chan->alertpipe[0], &blah, sizeof(blah));
2420         }
2421
2422         if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD) {
2423                 enum ast_timing_event res;
2424
2425                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2426
2427                 res = ast_timer_get_event(chan->timingfd);
2428
2429                 switch (res) {
2430                 case AST_TIMING_EVENT_EXPIRED:
2431                         ast_timer_ack(chan->timingfd, 1);
2432
2433                         if (chan->timingfunc) {
2434                                 /* save a copy of func/data before unlocking the channel */
2435                                 int (*func)(const void *) = chan->timingfunc;
2436                                 void *data = chan->timingdata;
2437                                 ast_channel_unlock(chan);
2438                                 func(data);
2439                         } else {
2440                                 ast_timer_set_rate(chan->timingfd, 0);
2441                                 ast_channel_unlock(chan);
2442                         }
2443
2444                         /* cannot 'goto done' because the channel is already unlocked */
2445                         return &ast_null_frame;
2446
2447                 case AST_TIMING_EVENT_CONTINUOUS:
2448                         if (AST_LIST_EMPTY(&chan->readq) || 
2449                                 !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
2450                                 ast_timer_disable_continuous(chan->timingfd);
2451                         }
2452                         break;
2453                 }
2454
2455         } else if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
2456                 /* if the AST_GENERATOR_FD is set, call the generator with args
2457                  * set to -1 so it can do whatever it needs to.
2458                  */
2459                 void *tmp = chan->generatordata;
2460                 chan->generatordata = NULL;     /* reset to let ast_write get through */
2461                 chan->generator->generate(chan, tmp, -1, -1);
2462                 chan->generatordata = tmp;
2463                 f = &ast_null_frame;
2464                 goto done;
2465         }
2466
2467         /* Check for pending read queue */
2468         if (!AST_LIST_EMPTY(&chan->readq)) {
2469                 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
2470                 /* Interpret hangup and return NULL */
2471                 /* XXX why not the same for frames from the channel ? */
2472                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
2473                         cause = f->data.uint32;
2474                         ast_frfree(f);
2475                         f = NULL;
2476                 }
2477         } else {
2478                 chan->blocker = pthread_self();
2479                 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2480                         if (chan->tech->exception)
2481                                 f = chan->tech->exception(chan);
2482                         else {
2483                                 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
2484                                 f = &ast_null_frame;
2485                         }
2486                         /* Clear the exception flag */
2487                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2488                 } else if (chan->tech->read)
2489                         f = chan->tech->read(chan);
2490                 else
2491                         ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
2492         }
2493
2494         if (f) {
2495                 /* if the channel driver returned more than one frame, stuff the excess
2496                    into the readq for the next ast_read call (note that we can safely assume
2497                    that the readq is empty, because otherwise we would not have called into
2498                    the channel driver and f would be only a single frame)
2499                 */
2500                 if (AST_LIST_NEXT(f, frame_list)) {
2501                         AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
2502                         AST_LIST_NEXT(f, frame_list) = NULL;
2503                 }
2504
2505                 switch (f->frametype) {
2506                 case AST_FRAME_CONTROL:
2507                         if (f->subclass == AST_CONTROL_ANSWER) {
2508                                 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
2509                                         ast_debug(1, "Ignoring answer on an inbound call!\n");
2510                                         ast_frfree(f);
2511                                         f = &ast_null_frame;
2512                                 } else if (prestate == AST_STATE_UP) {
2513                                         ast_debug(1, "Dropping duplicate answer!\n");
2514                                         ast_frfree(f);
2515                                         f = &ast_null_frame;
2516                                 } else {
2517                                         /* Answer the CDR */
2518                                         ast_setstate(chan, AST_STATE_UP);
2519                                         /* removed a call to ast_cdr_answer(chan->cdr) from here. */
2520                                 }
2521                         }
2522                         break;
2523                 case AST_FRAME_DTMF_END:
2524                         send_dtmf_event(chan, "Received", f->subclass, "No", "Yes");
2525                         ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass, chan->name, f->len);
2526                         /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2527                          * However, only let emulation be forced if the other end cares about BEGIN frames */
2528                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF) ||
2529                                 (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) ) {
2530                                 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2531                                         ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2532                                         chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2533                                 } else
2534                                         ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2535                                 ast_frfree(f);
2536                                 f = &ast_null_frame;
2537                         } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) {
2538                                 if (!ast_tvzero(chan->dtmf_tv) && 
2539                                     ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) {
2540                                         /* If it hasn't been long enough, defer this digit */
2541                                         if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2542                                                 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2543                                                 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2544                                         } else
2545                                                 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2546                                         ast_frfree(f);
2547                                         f = &ast_null_frame;
2548                                 } else {
2549                                         /* There was no begin, turn this into a begin and send the end later */
2550                                         f->frametype = AST_FRAME_DTMF_BEGIN;
2551                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2552                                         chan->emulate_dtmf_digit = f->subclass;
2553                                         chan->dtmf_tv = ast_tvnow();
2554                                         if (f->len) {
2555                                                 if (f->len > AST_MIN_DTMF_DURATION)
2556                                                         chan->emulate_dtmf_duration = f->len;
2557                                                 else 
2558                                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION;
2559                                         } else
2560                                                 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2561                                         ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass, chan->emulate_dtmf_duration, chan->name);
2562                                 }
2563                                 if (chan->audiohooks) {
2564                                         struct ast_frame *old_frame = f;
2565                                         /*!
2566                                          * \todo XXX It is possible to write a digit to the audiohook twice
2567                                          * if the digit was originally read while the channel was in autoservice. */
2568                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2569                                         if (old_frame != f)
2570                                                 ast_frfree(old_frame);
2571                                 }
2572                         } else {
2573                                 struct timeval now = ast_tvnow();
2574                                 if (ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2575                                         ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass, chan->name);
2576                                         ast_clear_flag(chan, AST_FLAG_IN_DTMF);
2577                                         if (!f->len)
2578                                                 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2579                                 } else if (!f->len) {
2580                                         ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass, chan->name);
2581                                         f->len = AST_MIN_DTMF_DURATION;
2582                                 }
2583                                 if (f->len < AST_MIN_DTMF_DURATION && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
2584                                         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);
2585                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2586                                         chan->emulate_dtmf_digit = f->subclass;
2587                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len;
2588                                         ast_frfree(f);
2589                                         f = &ast_null_frame;
2590                                 } else {
2591                                         ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass, chan->name);
2592                                         if (f->len < AST_MIN_DTMF_DURATION) {
2593                                                 f->len = AST_MIN_DTMF_DURATION;
2594                                         }
2595                                         chan->dtmf_tv = now;
2596                                 }
2597                                 if (chan->audiohooks) {
2598                                         struct ast_frame *old_frame = f;
2599                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2600                                         if (old_frame != f)
2601                                                 ast_frfree(old_frame);
2602                                 }
2603                         }
2604                         break;
2605                 case AST_FRAME_DTMF_BEGIN:
2606                         send_dtmf_event(chan, "Received", f->subclass, "Yes", "No");
2607                         ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2608                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY | AST_FLAG_EMULATE_DTMF) || 
2609                             (!ast_tvzero(chan->dtmf_tv) && 
2610                               ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) {
2611                                 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass, chan->name);
2612                                 ast_frfree(f);
2613                                 f = &ast_null_frame;
2614                         } else {
2615                                 ast_set_flag(chan, AST_FLAG_IN_DTMF);
2616                                 chan->dtmf_tv = ast_tvnow();
2617                                 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass, chan->name);
2618                         }
2619                         break;
2620                 case AST_FRAME_NULL:
2621                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2622                          * is reached , because we want to make sure we pass at least one
2623                          * voice frame through before starting the next digit, to ensure a gap
2624                          * between DTMF digits. */
2625                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2626                                 struct timeval now = ast_tvnow();
2627                                 if (!chan->emulate_dtmf_duration) {
2628                                         ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2629                                         chan->emulate_dtmf_digit = 0;
2630                                 } else if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2631                                         chan->emulate_dtmf_duration = 0;
2632                                         ast_frfree(f);
2633                                         f = &chan->dtmff;
2634                                         f->frametype = AST_FRAME_DTMF_END;
2635                                         f->subclass = chan->emulate_dtmf_digit;
2636                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2637                                         chan->dtmf_tv = now;
2638                                         ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2639                                         chan->emulate_dtmf_digit = 0;
2640                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2641                                 }
2642                         }
2643                         break;
2644                 case AST_FRAME_VOICE:
2645                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2646                          * is reached , because we want to make sure we pass at least one
2647                          * voice frame through before starting the next digit, to ensure a gap
2648                          * between DTMF digits. */
2649                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) {
2650                                 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2651                                 chan->emulate_dtmf_digit = 0;
2652                         }
2653
2654                         if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2655                                 if (dropaudio)
2656                                         ast_read_generator_actions(chan, f);
2657                                 ast_frfree(f);
2658                                 f = &ast_null_frame;
2659                         }
2660
2661                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2662                                 struct timeval now = ast_tvnow();
2663                                 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2664                                         chan->emulate_dtmf_duration = 0;
2665                                         ast_frfree(f);
2666                                         f = &chan->dtmff;
2667                                         f->frametype = AST_FRAME_DTMF_END;
2668                                         f->subclass = chan->emulate_dtmf_digit;
2669                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2670                                         chan->dtmf_tv = now;
2671                                         if (chan->audiohooks) {
2672                                                 struct ast_frame *old_frame = f;
2673                                                 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2674                                                 if (old_frame != f)
2675                                                         ast_frfree(old_frame);
2676                                         }
2677                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2678                                 } else {
2679                                         /* Drop voice frames while we're still in the middle of the digit */
2680                                         ast_frfree(f);
2681                                         f = &ast_null_frame;
2682                                 }
2683                         } else if ((f->frametype == AST_FRAME_VOICE) && !(f->subclass & chan->nativeformats)) {
2684                                 /* This frame is not one of the current native formats -- drop it on the floor */
2685                                 char to[200];
2686                                 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2687                                         chan->name, ast_getformatname(f->subclass), ast_getformatname_multiple(to, sizeof(to), chan->nativeformats));
2688                                 ast_frfree(f);
2689                                 f = &ast_null_frame;
2690                         } else if ((f->frametype == AST_FRAME_VOICE)) {
2691                                 /* Send frame to audiohooks if present */
2692                                 if (chan->audiohooks) {
2693                                         struct ast_frame *old_frame = f;
2694                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2695                                         if (old_frame != f)
2696                                                 ast_frfree(old_frame);
2697                                 }
2698                                 if (chan->monitor && chan->monitor->read_stream ) {
2699                                         /* XXX what does this do ? */
2700 #ifndef MONITOR_CONSTANT_DELAY
2701                                         int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2702                                         if (jump >= 0) {
2703                                                 jump = chan->outsmpl - chan->insmpl;
2704                                                 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1)
2705                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2706                                                 chan->insmpl += jump + f->samples;
2707                                         } else
2708                                                 chan->insmpl+= f->samples;
2709 #else
2710                                         int jump = chan->outsmpl - chan->insmpl;
2711                                         if (jump - MONITOR_DELAY >= 0) {
2712                                                 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2713                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2714                                                 chan->insmpl += jump;
2715                                         } else
2716                                                 chan->insmpl += f->samples;
2717 #endif
2718                                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2719                                                 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2720                                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2721                                         }
2722                                 }
2723
2724                                 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
2725                                         f = &ast_null_frame;
2726                                 else
2727                                         /* Run generator sitting on the line if timing device not available
2728                                          * and synchronous generation of outgoing frames is necessary       */
2729                                         ast_read_generator_actions(chan, f);
2730                         }
2731                 default:
2732                         /* Just pass it on! */
2733                         break;
2734                 }
2735         } else {
2736                 /* Make sure we always return NULL in the future */
2737                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2738                 if (cause)
2739                         chan->hangupcause = cause;
2740                 if (chan->generator)
2741                         ast_deactivate_generator(chan);
2742                 /* We no longer End the CDR here */
2743         }
2744
2745         /* High bit prints debugging */
2746         if (chan->fin & DEBUGCHAN_FLAG)
2747                 ast_frame_dump(chan->name, f, "<<");
2748         chan->fin = FRAMECOUNT_INC(chan->fin);
2749
2750 done:
2751         if (chan->music_state && chan->generator && chan->generator->digit && f && f->frametype == AST_FRAME_DTMF_END)
2752                 chan->generator->digit(chan, f->subclass);
2753
2754         ast_channel_unlock(chan);
2755         return f;
2756 }
2757
2758 int ast_internal_timing_enabled(struct ast_channel *chan)
2759 {
2760         int ret = ast_opt_internal_timing && chan->timingfd > -1;
2761         ast_debug(5, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
2762         return ret;
2763 }
2764
2765 struct ast_frame *ast_read(struct ast_channel *chan)
2766 {
2767         return __ast_read(chan, 0);
2768 }
2769
2770 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2771 {
2772         return __ast_read(chan, 1);
2773 }
2774
2775 int ast_indicate(struct ast_channel *chan, int condition)
2776 {
2777         return ast_indicate_data(chan, condition, NULL, 0);
2778 }
2779
2780 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
2781 {
2782         int res = -1;
2783
2784         ast_channel_lock(chan);
2785         /* Stop if we're a zombie or need a soft hangup */
2786         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2787                 ast_channel_unlock(chan);
2788                 return -1;
2789         }
2790         if (chan->tech->indicate)
2791                 res = chan->tech->indicate(chan, condition, data, datalen);
2792         ast_channel_unlock(chan);
2793         if (!chan->tech->indicate || res) {
2794                 /*
2795                  * Device does not support (that) indication, lets fake
2796                  * it by doing our own tone generation. (PM2002)
2797                  */
2798                 if (condition < 0)
2799                         ast_playtones_stop(chan);
2800                 else {
2801                         const struct ind_tone_zone_sound *ts = NULL;
2802                         switch (condition) {
2803                         case AST_CONTROL_RINGING:
2804                                 ts = ast_get_indication_tone(chan->zone, "ring");
2805                                 break;
2806                         case AST_CONTROL_BUSY:
2807                                 ts = ast_get_indication_tone(chan->zone, "busy");
2808                                 break;
2809                         case AST_CONTROL_CONGESTION:
2810                                 ts = ast_get_indication_tone(chan->zone, "congestion");
2811                                 break;
2812                         }
2813                         if (ts && ts->data[0]) {
2814                                 ast_debug(1, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2815                                 ast_playtones_start(chan,0,ts->data, 1);
2816                                 res = 0;
2817                                 chan->visible_indication = condition;
2818                         } else if (condition == AST_CONTROL_PROGRESS) {
2819                                 /* ast_playtones_stop(chan); */
2820                         } else if (condition == AST_CONTROL_PROCEEDING) {
2821                                 /* Do nothing, really */
2822                         } else if (condition == AST_CONTROL_HOLD) {
2823                                 /* Do nothing.... */
2824                         } else if (condition == AST_CONTROL_UNHOLD) {
2825                                 /* Do nothing.... */
2826                         } else if (condition == AST_CONTROL_VIDUPDATE) {
2827                                 /* Do nothing.... */
2828                         } else if (condition == AST_CONTROL_SRCUPDATE) {
2829                                 /* Do nothing... */
2830                         } else {
2831                                 /* not handled */
2832                                 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2833                                 res = -1;
2834                         }
2835                 }
2836         } else
2837                 chan->visible_indication = condition;
2838
2839         return res;
2840 }
2841
2842 int ast_recvchar(struct ast_channel *chan, int timeout)
2843 {
2844         int c;
2845         char *buf = ast_recvtext(chan, timeout);
2846         if (buf == NULL)
2847                 return -1;      /* error or timeout */
2848         c = *(unsigned char *)buf;
2849         ast_free(buf);
2850         return c;
2851 }
2852
2853 char *ast_recvtext(struct ast_channel *chan, int timeout)
2854 {
2855         int res, done = 0;
2856         char *buf = NULL;
2857         
2858         while (!done) {
2859                 struct ast_frame *f;
2860                 if (ast_check_hangup(chan))
2861                         break;
2862                 res = ast_waitfor(chan, timeout);
2863                 if (res <= 0) /* timeout or error */
2864                         break;
2865                 timeout = res;  /* update timeout */
2866                 f = ast_read(chan);
2867                 if (f == NULL)
2868                         break; /* no frame */
2869                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2870                         done = 1;       /* force a break */
2871                 else if (f->frametype == AST_FRAME_TEXT) {              /* what we want */
2872                         buf = ast_strndup((char *) f->data.ptr, f->datalen);    /* dup and break */
2873                         done = 1;
2874                 }
2875                 ast_frfree(f);
2876         }
2877         return buf;
2878 }
2879
2880 int ast_sendtext(struct ast_channel *chan, const char *text)
2881 {
2882         int res = 0;
2883         /* Stop if we're a zombie or need a soft hangup */
2884         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2885                 return -1;
2886         CHECK_BLOCKING(chan);
2887         if (chan->tech->send_text)
2888                 res = chan->tech->send_text(chan, text);
2889         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2890         return res;
2891 }
2892
2893 int ast_senddigit_begin(struct ast_channel *chan, char digit)
2894 {
2895         /* Device does not support DTMF tones, lets fake
2896          * it by doing our own generation. */
2897         static const char* dtmf_tones[] = {
2898                 "941+1336", /* 0 */
2899                 "697+1209", /* 1 */
2900                 "697+1336", /* 2 */
2901                 "697+1477", /* 3 */
2902                 "770+1209", /* 4 */
2903                 "770+1336", /* 5 */
2904                 "770+1477", /* 6 */
2905                 "852+1209", /* 7 */
2906                 "852+1336", /* 8 */
2907                 "852+1477", /* 9 */
2908                 "697+1633", /* A */
2909                 "770+1633", /* B */
2910                 "852+1633", /* C */
2911                 "941+1633", /* D */
2912                 "941+1209", /* * */
2913                 "941+1477"  /* # */
2914         };
2915
2916         if (!chan->tech->send_digit_begin)
2917                 return 0;
2918
2919         if (!chan->tech->send_digit_begin(chan, digit))
2920                 return 0;
2921
2922         if (digit >= '0' && digit <='9')
2923                 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2924         else if (digit >= 'A' && digit <= 'D')
2925                 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2926         else if (digit == '*')
2927                 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2928         else if (digit == '#')
2929                 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2930         else {
2931                 /* not handled */
2932                 ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2933         }
2934
2935         return 0;
2936 }
2937
2938 int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
2939 {
2940         int res = -1;
2941
2942         if (chan->tech->send_digit_end)
2943                 res = chan->tech->send_digit_end(chan, digit, duration);
2944
2945         if (res && chan->generator)
2946                 ast_playtones_stop(chan);
2947         
2948         return 0;
2949 }
2950
2951 int ast_senddigit(struct ast_channel *chan, char digit, unsigned int duration)
2952 {
2953         if (chan->tech->send_digit_begin) {
2954                 ast_senddigit_begin(chan, digit);
2955                 ast_safe_sleep(chan, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2956         }
2957         
2958         return ast_senddigit_end(chan, digit, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2959 }
2960
2961 int ast_prod(struct ast_channel *chan)
2962 {
2963         struct ast_frame a = { AST_FRAME_VOICE };
2964         char nothing[128];
2965
2966         /* Send an empty audio frame to get things moving */
2967         if (chan->_state != AST_STATE_UP) {
2968                 ast_debug(1, "Prodding channel '%s'\n", chan->name);
2969                 a.subclass = chan->rawwriteformat;
2970                 a.data.ptr = nothing + AST_FRIENDLY_OFFSET;
2971                 a.src = "ast_prod";
2972                 if (ast_write(chan, &a))
2973                         ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2974         }
2975         return 0;
2976 }
2977
2978 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2979 {
2980         int res;
2981         if (!chan->tech->write_video)
2982                 return 0;
2983         res = ast_write(chan, fr);
2984         if (!res)
2985                 res = 1;
2986         return res;
2987 }
2988
2989 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2990 {
2991         int res = -1;
2992         struct ast_frame *f = NULL, *f2 = NULL;
2993         int count = 0;
2994
2995         /*Deadlock avoidance*/
2996         while(ast_channel_trylock(chan)) {
2997                 /*cannot goto done since the channel is not locked*/
2998                 if(count++ > 10) {
2999                         ast_debug(1, "Deadlock avoided for write to channel '%s'\n", chan->name);
3000                         return 0;
3001                 }
3002                 usleep(1);
3003         }
3004         /* Stop if we're a zombie or need a soft hangup */
3005         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
3006                 goto done;
3007
3008         /* Handle any pending masquerades */
3009         if (chan->masq && ast_do_masquerade(chan)) {
3010                 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
3011                 goto done;
3012         }
3013         if (chan->masqr) {
3014                 res = 0;        /* XXX explain, why 0 ? */
3015                 goto done;
3016         }
3017         if (chan->generatordata) {
3018                 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
3019                         ast_deactivate_generator(chan);
3020                 else {
3021                         if (fr->frametype == AST_FRAME_DTMF_END) {
3022                                 /* There is a generator running while we're in the middle of a digit.
3023                                  * It's probably inband DTMF, so go ahead and pass it so it can
3024                                  * stop the generator */
3025                                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3026                                 ast_channel_unlock(chan);
3027                                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
3028                                 ast_channel_lock(chan);
3029                                 CHECK_BLOCKING(chan);
3030                         } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
3031                                 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
3032                                 res = (chan->tech->indicate == NULL) ? 0 :
3033                                         chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
3034                         }
3035                         res = 0;        /* XXX explain, why 0 ? */
3036                         goto done;
3037                 }
3038         }
3039         /* High bit prints debugging */
3040         if (chan->fout & DEBUGCHAN_FLAG)
3041                 ast_frame_dump(chan->name, fr, ">>");
3042         CHECK_BLOCKING(chan);
3043         switch (fr->frametype) {
3044         case AST_FRAME_CONTROL:
3045                 res = (chan->tech->indicate == NULL) ? 0 :
3046                         chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
3047                 break;
3048         case AST_FRAME_DTMF_BEGIN:
3049                 if (chan->audiohooks) {
3050                         struct ast_frame *old_frame = fr;
3051                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3052                         if (old_frame != fr)
3053                                 f = fr;
3054                 }
3055                 send_dtmf_event(chan, "Sent", fr->subclass, "Yes", "No");
3056                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3057                 ast_channel_unlock(chan);
3058                 res = ast_senddigit_begin(chan, fr->subclass);
3059                 ast_channel_lock(chan);
3060                 CHECK_BLOCKING(chan);
3061                 break;
3062         case AST_FRAME_DTMF_END:
3063                 if (chan->audiohooks) {
3064                         struct ast_frame *old_frame = fr;
3065                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3066                         if (old_frame != fr)
3067                                 f = fr;
3068                 }
3069                 send_dtmf_event(chan, "Sent", fr->subclass, "No", "Yes");
3070                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
3071                 ast_channel_unlock(chan);
3072                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
3073                 ast_channel_lock(chan);
3074                 CHECK_BLOCKING(chan);
3075                 break;
3076         case AST_FRAME_TEXT:
3077                 if (fr->subclass == AST_FORMAT_T140) {
3078                         res = (chan->tech->write_text == NULL) ? 0 :
3079                                 chan->tech->write_text(chan, fr);
3080                 } else {
3081                         res = (chan->tech->send_text == NULL) ? 0 :
3082                                 chan->tech->send_text(chan, (char *) fr->data.ptr);
3083                 }
3084                 break;
3085         case AST_FRAME_HTML:
3086                 res = (chan->tech->send_html == NULL) ? 0 :
3087                         chan->tech->send_html(chan, fr->subclass, (char *) fr->data.ptr, fr->datalen);
3088                 break;
3089         case AST_FRAME_VIDEO:
3090                 /* XXX Handle translation of video codecs one day XXX */
3091                 res = (chan->tech->write_video == NULL) ? 0 :
3092                         chan->tech->write_video(chan, fr);
3093                 break;
3094         case AST_FRAME_MODEM:
3095                 res = (chan->tech->write == NULL) ? 0 :
3096                         chan->tech->write(chan, fr);
3097                 break;
3098         case AST_FRAME_VOICE:
3099                 if (chan->tech->write == NULL)
3100                         break;  /*! \todo XXX should return 0 maybe ? */
3101
3102                 /* If audiohooks are present, write the frame out */
3103                 if (chan->audiohooks) {
3104                         struct ast_frame *old_frame = fr;
3105                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
3106                         if (old_frame != fr)
3107                                 f2 = fr;
3108                 }
3109
3110                 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
3111                 if (fr->subclass == chan->rawwriteformat)
3112                         f = fr;
3113                 else
3114                         f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
3115
3116                 if (!f) {
3117                         res = 0;
3118                         break;
3119                 }
3120
3121                 /* If Monitor is running on this channel, then we have to write frames out there too */
3122                 if (chan->monitor && chan->monitor->write_stream) {
3123                         /* XXX must explain this code */
3124 #ifndef MONITOR_CONSTANT_DELAY
3125                         int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
3126                         if (jump >= 0) {
3127                                 jump = chan->insmpl - chan->outsmpl;
3128                                 if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
3129                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
3130                                 chan->outsmpl += jump + f->samples;
3131                         } else
3132                                 chan->outsmpl += f->samples;
3133 #else
3134                         int jump = chan->insmpl - chan->outsmpl;
3135                         if (jump - MONITOR_DELAY >= 0) {
3136                                 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
3137                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
3138                                 chan->outsmpl += jump;
3139                         } else
3140                                 chan->outsmpl += f->samples;
3141 #endif
3142                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
3143                                 if (ast_writestream(chan->monitor->write_stream, f) < 0)
3144                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
3145                         }
3146                 }
3147
3148                 if (f) 
3149                         res = chan->tech->write(chan,f);
3150                 else
3151                         res = 0;
3152                 break;
3153         case AST_FRAME_NULL:
3154         case AST_FRAME_IAX:
3155                 /* Ignore these */
3156                 res = 0;
3157                 break;
3158         default:
3159                 /* At this point, fr is the incoming frame and f is NULL.  Channels do
3160                  * not expect to get NULL as a frame pointer and will segfault.  Hence,
3161                  * we output the original frame passed in. */
3162                 res = chan->tech->write(chan, fr);
3163                 break;
3164         }
3165
3166         if (f && f != fr)
3167                 ast_frfree(f);
3168         if (f2)
3169                 ast_frfree(f2);
3170         ast_clear_flag(chan, AST_FLAG_BLOCKING);
3171         /* Consider a write failure to force a soft hangup */
3172         if (res < 0)
3173                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
3174         else {
3175                 chan->fout = FRAMECOUNT_INC(chan->fout);
3176         }
3177 done:
3178         ast_channel_unlock(chan);
3179         return res;
3180 }
3181
3182 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
3183                       struct ast_trans_pvt **trans, const int direction)
3184 {
3185         int native;
3186         int res;
3187         char from[200], to[200];
3188         
3189         /* Make sure we only consider audio */
3190         fmt &= AST_FORMAT_AUDIO_MASK;
3191         
3192         native = chan->nativeformats;
3193
3194         if (!fmt || !native)    /* No audio requested */
3195                 return 0;       /* Let's try a call without any sounds (video, text) */
3196         
3197         /* Find a translation path from the native format to one of the desired formats */
3198         if (!direction)
3199                 /* reading */
3200                 res = ast_translator_best_choice(&fmt, &native);
3201         else
3202                 /* writing */
3203                 res = ast_translator_best_choice(&native, &fmt);
3204
3205         if (res < 0) {
3206                 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
3207                         ast_getformatname_multiple(from, sizeof(from), native),
3208                         ast_getformatname_multiple(to, sizeof(to), fmt));
3209                 return -1;
3210         }
3211         
3212         /* Now we have a good choice for both. */
3213         ast_channel_lock(chan);
3214
3215         if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
3216                 /* the channel is already in these formats, so nothing to do */
3217                 ast_channel_unlock(chan);
3218                 return 0;
3219         }
3220
3221         *rawformat = native;
3222         /* User perspective is fmt */
3223         *format = fmt;
3224         /* Free any read translation we have right now */
3225         if (*trans)
3226                 ast_translator_free_path(*trans);
3227         /* Build a translation path from the raw format to the desired format */
3228         if (!direction)
3229                 /* reading */
3230                 *trans = ast_translator_build_path(*format, *rawformat);
3231         else
3232                 /* writing */
3233                 *trans = ast_translator_build_path(*rawformat, *format);
3234         ast_channel_unlock(chan);
3235         ast_debug(1, "Set channel %s to %s format %s\n", chan->name,
3236                 direction ? "write" : "read", ast_getformatname(fmt));
3237         return 0;
3238 }
3239
3240 int ast_set_read_format(struct ast_channel *chan, int fmt)
3241 {
3242         return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
3243                           &chan->readtrans, 0);
3244 }
3245
3246 int ast_set_write_format(struct ast_channel *chan, int fmt)
3247 {
3248         return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
3249                           &chan->writetrans, 1);
3250 }
3251
3252 const char *ast_channel_reason2str(int reason)
3253 {
3254         switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */
3255         {
3256         case 0:
3257                 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
3258         case AST_CONTROL_HANGUP:
3259                 return "Hangup";
3260         case AST_CONTROL_RING:
3261                 return "Local Ring";
3262         case AST_CONTROL_RINGING:
3263                 return "Remote end Ringing";
3264         case AST_CONTROL_ANSWER:
3265                 return "Remote end has Answered";
3266         case AST_CONTROL_BUSY:
3267                 return "Remote end is Busy";
3268         case AST_CONTROL_CONGESTION:
3269                 return "Congestion (circuits busy)";
3270         default:
3271                 return "Unknown Reason!!";
3272         }
3273 }
3274
3275 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)
3276 {
3277         int dummy_outstate;
3278         int cause = 0;
3279         struct ast_channel *chan;
3280         int res = 0;
3281         int last_subclass = 0;
3282         
3283         if (outstate)
3284                 *outstate = 0;
3285         else
3286                 outstate = &dummy_outstate;     /* make outstate always a valid pointer */
3287
3288         chan = ast_request(type, format, data, &cause);
3289         if (!chan) {
3290                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
3291                 /* compute error and return */
3292                 if (cause == AST_CAUSE_BUSY)
3293                         *outstate = AST_CONTROL_BUSY;
3294                 else if (cause == AST_CAUSE_CONGESTION)
3295                         *outstate = AST_CONTROL_CONGESTION;
3296                 return NULL;
3297         }
3298
3299         if (oh) {
3300                 if (oh->vars)   
3301                         ast_set_variables(chan, oh->vars);
3302                 /* XXX why is this necessary, for the parent_channel perhaps ? */
3303                 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
3304                         ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
3305                 if (oh->parent_channel) {
3306                         ast_channel_inherit_variables(oh->parent_channel, chan);
3307                         ast_channel_datastore_inherit(oh->parent_channel, chan);
3308                 }
3309                 if (oh->account)
3310                         ast_cdr_setaccount(chan, oh->account);  
3311         }
3312         ast_set_callerid(chan, cid_num, cid_name, cid_num);
3313
3314         if (ast_call(chan, data, 0)) {  /* ast_call failed... */
3315                 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
3316         } else {
3317                 res = 1;        /* mark success in case chan->_state is already AST_STATE_UP */
3318                 while (timeout && chan->_state != AST_STATE_UP) {
3319                         struct ast_frame *f;
3320                         res = ast_waitfor(chan, timeout);
3321                         if (res <= 0) /* error, timeout, or done */
3322                                 break;
3323                         if (timeout > -1)
3324                                 timeout = res;
3325                         f = ast_read(chan);
3326                         if (!f) {
3327                                 *outstate = AST_CONTROL_HANGUP;
3328                                 res = 0;
3329                                 break;
3330                         }
3331                         if (f->frametype == AST_FRAME_CONTROL) {
3332                                 switch (f->subclass) {
3333                                 case AST_CONTROL_RINGING:       /* record but keep going */
3334                                         *outstate = f->subclass;
3335                                         break;
3336
3337                                 case AST_CONTROL_BUSY:
3338                                 case AST_CONTROL_CONGESTION:
3339                                 case AST_CONTROL_ANSWER:
3340                                         *outstate = f->subclass;
3341                                         timeout = 0;            /* trick to force exit from the while() */
3342                                         break;
3343
3344                                 /* Ignore these */
3345                                 case AST_CONTROL_PROGRESS:
3346                                 case AST_CONTROL_PROCEEDING:
3347                                 case AST_CONTROL_HOLD:
3348                                 case AST_CONTROL_UNHOLD:
3349                                 case AST_CONTROL_VIDUPDATE:
3350                                 case AST_CONTROL_SRCUPDATE:
3351                                 case -1:                        /* Ignore -- just stopping indications */
3352                                         break;
3353
3354                                 default:
3355                                         ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
3356                                 }
3357                                 last_subclass = f->subclass;
3358                         }
3359                         ast_frfree(f);
3360                 }
3361         }
3362
3363         /* Final fixups */
3364         if (oh) {
3365                 if (!ast_strlen_zero(oh->context))
3366                         ast_copy_string(chan->context, oh->context, sizeof(chan->context));
3367                 if (!ast_strlen_zero(oh->exten))
3368                         ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
3369                 if (oh->priority)       
3370                         chan->priority = oh->priority;
3371         }
3372         if (chan->_state == AST_STATE_UP)
3373                 *outstate = AST_CONTROL_ANSWER;
3374
3375         if (res <= 0) {
3376                 if ( AST_CONTROL_RINGING == last_subclass ) 
3377                         chan->hangupcause = AST_CAUSE_NO_ANSWER;
3378                 if (!chan->cdr && (chan->cdr = ast_cdr_alloc()))
3379                         ast_cdr_init(chan->cdr, chan);
3380                 if (chan->cdr) {
3381                         char tmp[256];
3382                         snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data);
3383                         ast_cdr_setapp(chan->cdr,"Dial",tmp);
3384                         ast_cdr_update(chan);
3385                         ast_cdr_start(chan->cdr);
3386                         ast_cdr_end(chan->cdr);
3387                         /* If the cause wasn't handled properly */
3388                         if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
3389                                 ast_cdr_failed(chan->cdr);
3390                 }
3391                 ast_hangup(chan);
3392                 chan = NULL;
3393         }
3394         return chan;
3395 }
3396
3397 struct ast_channel *ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname)
3398 {
3399         return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
3400 }
3401
3402 struct ast_channel *ast_request(const char *type, int format, void *data, int *cause)
3403 {
3404         struct chanlist *chan;
3405         struct ast_channel *c;
3406         int capabilities;
3407         int fmt;
3408         int res;
3409         int foo;
3410         int videoformat = format & AST_FORMAT_VIDEO_MASK;
3411         int textformat = format & AST_FORMAT_TEXT_MASK;
3412
3413         if (!cause)
3414                 cause = &foo;
3415         *cause = AST_CAUSE_NOTDEFINED;
3416
3417         if (AST_RWLIST_RDLOCK(&channels)) {
3418                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
3419                 return NULL;
3420         }
3421
3422         AST_LIST_TRAVERSE(&backends, chan, list) {
3423                 if (strcasecmp(type, chan->tech->type))
3424                         continue;
3425
3426                 capabilities = chan->tech->capabilities;
3427                 fmt = format & AST_FORMAT_AUDIO_MASK;
3428                 if (fmt) {
3429                         /* We have audio - is it possible to connect the various calls to each other? 
3430                                 (Avoid this check for calls without audio, like text+video calls)
3431                         */
3432                         res = ast_translator_best_choice(&fmt, &capabilities);
3433                         if (res < 0) {
3434                                 ast_log(LOG_WARNING, "No translator path exists for channel type %s (native 0x%x) to 0x%x\n", type, chan->tech->capabilities, format);
3435                                 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
3436                                 AST_RWLIST_UNLOCK(&channels);
3437                                 return NULL;
3438                         }
3439                 }
3440                 AST_RWLIST_UNLOCK(&channels);
3441                 if (!chan->tech->requester)
3442                         return NULL;
3443                 
3444                 if (!(c = chan->tech->requester(type, capabilities | videoformat | textformat, data, cause)))
3445                         return NULL;
3446                 
3447                 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
3448                 return c;
3449         }
3450
3451         ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
3452         *cause = AST_CAUSE_NOSUCHDRIVER;
3453         AST_RWLIST_UNLOCK(&channels);
3454
3455         return NULL;
3456 }
3457
3458 int ast_call(struct ast_channel *chan, char *addr, int timeout)
3459 {
3460         /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
3461            If the remote end does not answer within the timeout, then do NOT hang up, but
3462            return anyway.  */
3463         int res = -1;
3464         /* Stop if we're a zombie or need a soft hangup */
3465         ast_channel_lock(chan);
3466         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
3467                 if (chan->cdr)
3468                         ast_set_flag(chan->cdr, AST_CDR_FLAG_DIALED);
3469                 if (chan->tech->call)
3470                         res = chan->tech->call(chan, addr, timeout);
3471                 ast_set_flag(chan, AST_FLAG_OUTGOING);
3472         }
3473         ast_channel_unlock(chan);
3474         return res;
3475 }
3476
3477 /*!
3478   \brief Transfer a call to dest, if the channel supports transfer
3479
3480   Called by:
3481         \arg app_transfer
3482         \arg the manager interface
3483 */
3484 int ast_transfer(struct ast_channel *chan, char *dest)
3485 {
3486         int res = -1;
3487
3488         /* Stop if we're a zombie or need a soft hangup */
3489         ast_channel_lock(chan);
3490         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
3491                 if (chan->tech->transfer) {
3492                         res = chan->tech->transfer(chan, dest);
3493                         if (!res)
3494                                 res = 1;
3495                 } else
3496                         res = 0;
3497         }
3498         ast_channel_unlock(chan);
3499         return res;
3500 }
3501
3502 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
3503 {
3504         return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
3505 }
3506
3507 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
3508 {
3509         int pos = 0;    /* index in the buffer where we accumulate digits */
3510         int to = ftimeout;
3511
3512         /* Stop if we're a zombie or need a soft hangup */
3513         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
3514                 return -1;
3515         if (!len)
3516                 return -1;
3517         for (;;) {
3518                 int d;
3519                 if (c->stream) {
3520                         d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
3521                         ast_stopstream(c);
3522                         usleep(1000);
3523                         if (!d)
3524                                 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
3525                 } else {
3526                         d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
3527                 }
3528                 if (d < 0)
3529                         return -1;
3530                 if (d == 0) {
3531                         s[pos]='\0';
3532                         return 1;
3533                 }
3534                 if (d == 1) {
3535                         s[pos]='\0';
3536                         return 2;