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