access channel locks through ast_channel_lock/unlock/trylock and not
[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_dont_use);
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_dont_use);
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         return AST_LIST_REMOVE(&chan->datastores, datastore, entry) ? 0 : -1;
1254 }
1255
1256 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
1257 {
1258         struct ast_datastore *datastore = NULL;
1259         
1260         if (info == NULL)
1261                 return NULL;
1262
1263         AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
1264                 if (datastore->info == info) {
1265                         if (uid != NULL && datastore->uid != NULL) {
1266                                 if (!strcasecmp(uid, datastore->uid)) {
1267                                         /* Matched by type AND uid */
1268                                         break;
1269                                 }
1270                         } else {
1271                                 /* Matched by type at least */
1272                                 break;
1273                         }
1274                 }
1275         }
1276         AST_LIST_TRAVERSE_SAFE_END
1277
1278         return datastore;
1279 }
1280
1281 /*! Set the file descriptor on the channel */
1282 void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
1283 {
1284 #ifdef HAVE_EPOLL
1285         struct epoll_event ev;
1286         struct ast_epoll_data *aed = NULL;
1287
1288         if (chan->fds[which] > -1) {
1289                 epoll_ctl(chan->epfd, EPOLL_CTL_DEL, chan->fds[which], &ev);
1290                 aed = chan->epfd_data[which];
1291         }
1292
1293         /* If this new fd is valid, add it to the epoll */
1294         if (fd > -1) {
1295                 if (!aed && (!(aed = ast_calloc(1, sizeof(*aed)))))
1296                         return;
1297                 
1298                 chan->epfd_data[which] = aed;
1299                 aed->chan = chan;
1300                 aed->which = which;
1301                 
1302                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1303                 ev.data.ptr = aed;
1304                 epoll_ctl(chan->epfd, EPOLL_CTL_ADD, fd, &ev);
1305         } else if (aed) {
1306                 /* We don't have to keep around this epoll data structure now */
1307                 free(aed);
1308                 chan->epfd_data[which] = NULL;
1309         }
1310 #endif
1311         chan->fds[which] = fd;
1312         return;
1313 }
1314
1315 /*! Add a channel to an optimized waitfor */
1316 void ast_poll_channel_add(struct ast_channel *chan0, struct ast_channel *chan1)
1317 {
1318 #ifdef HAVE_EPOLL
1319         struct epoll_event ev;
1320         int i = 0;
1321
1322         if (chan0->epfd == -1)
1323                 return;
1324
1325         /* Iterate through the file descriptors on chan1, adding them to chan0 */
1326         for (i = 0; i < AST_MAX_FDS; i++) {
1327                 if (chan1->fds[i] == -1)
1328                         continue;
1329                 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
1330                 ev.data.ptr = chan1->epfd_data[i];
1331                 epoll_ctl(chan0->epfd, EPOLL_CTL_ADD, chan1->fds[i], &ev);
1332         }
1333
1334 #endif
1335         return;
1336 }
1337
1338 /*! Delete a channel from an optimized waitfor */
1339 void ast_poll_channel_del(struct ast_channel *chan0, struct ast_channel *chan1)
1340 {
1341 #ifdef HAVE_EPOLL
1342         struct epoll_event ev;
1343         int i = 0;
1344
1345         if (chan0->epfd == -1)
1346                 return;
1347
1348         for (i = 0; i < AST_MAX_FDS; i++) {
1349                 if (chan1->fds[i] == -1)
1350                         continue;
1351                 epoll_ctl(chan0->epfd, EPOLL_CTL_DEL, chan1->fds[i], &ev);
1352         }
1353
1354 #endif
1355         return;
1356 }
1357
1358 /*! \brief Softly hangup a channel, don't lock */
1359 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
1360 {
1361         ast_debug(1, "Soft-Hanging up channel '%s'\n", chan->name);
1362         /* Inform channel driver that we need to be hung up, if it cares */
1363         chan->_softhangup |= cause;
1364         ast_queue_frame(chan, &ast_null_frame);
1365         /* Interrupt any poll call or such */
1366         if (ast_test_flag(chan, AST_FLAG_BLOCKING))
1367                 pthread_kill(chan->blocker, SIGURG);
1368         return 0;
1369 }
1370
1371 /*! \brief Softly hangup a channel, lock */
1372 int ast_softhangup(struct ast_channel *chan, int cause)
1373 {
1374         int res;
1375         ast_channel_lock(chan);
1376         res = ast_softhangup_nolock(chan, cause);
1377         ast_channel_unlock(chan);
1378         return res;
1379 }
1380
1381 static void free_translation(struct ast_channel *clone)
1382 {
1383         if (clone->writetrans)
1384                 ast_translator_free_path(clone->writetrans);
1385         if (clone->readtrans)
1386                 ast_translator_free_path(clone->readtrans);
1387         clone->writetrans = NULL;
1388         clone->readtrans = NULL;
1389         clone->rawwriteformat = clone->nativeformats;
1390         clone->rawreadformat = clone->nativeformats;
1391 }
1392
1393 /*! \brief Hangup a channel */
1394 int ast_hangup(struct ast_channel *chan)
1395 {
1396         int res = 0;
1397         struct ast_cdr *cdr = NULL;
1398
1399         /* Don't actually hang up a channel that will masquerade as someone else, or
1400            if someone is going to masquerade as us */
1401         ast_channel_lock(chan);
1402
1403         if (chan->audiohooks) {
1404                 ast_audiohook_detach_list(chan->audiohooks);
1405                 chan->audiohooks = NULL;
1406         }
1407
1408         ast_autoservice_stop(chan);
1409
1410         if (chan->masq) {
1411                 if (ast_do_masquerade(chan))
1412                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1413         }
1414
1415         if (chan->masq) {
1416                 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
1417                 ast_channel_unlock(chan);
1418                 return 0;
1419         }
1420         /* If this channel is one which will be masqueraded into something,
1421            mark it as a zombie already, so we know to free it later */
1422         if (chan->masqr) {
1423                 ast_set_flag(chan, AST_FLAG_ZOMBIE);
1424                 ast_channel_unlock(chan);
1425                 return 0;
1426         }
1427         free_translation(chan);
1428         /* Close audio stream */
1429         if (chan->stream) {
1430                 ast_closestream(chan->stream);
1431                 chan->stream = NULL;
1432         }
1433         /* Close video stream */
1434         if (chan->vstream) {
1435                 ast_closestream(chan->vstream);
1436                 chan->vstream = NULL;
1437         }
1438         if (chan->sched) {
1439                 sched_context_destroy(chan->sched);
1440                 chan->sched = NULL;
1441         }
1442         
1443         if (chan->generatordata)        /* Clear any tone stuff remaining */
1444                 if (chan->generator && chan->generator->release)
1445                         chan->generator->release(chan, chan->generatordata);
1446         chan->generatordata = NULL;
1447         chan->generator = NULL;
1448         if (chan->cdr) {                /* End the CDR if it hasn't already */
1449                 ast_cdr_end(chan->cdr);
1450                 cdr = chan->cdr;
1451                 chan->cdr = NULL;
1452         }
1453         if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1454                 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
1455                                         "is blocked by thread %ld in procedure %s!  Expect a failure\n",
1456                                         (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
1457                 CRASH;
1458         }
1459         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
1460                 ast_debug(1, "Hanging up channel '%s'\n", chan->name);
1461                 if (chan->tech->hangup)
1462                         res = chan->tech->hangup(chan);
1463         } else {
1464                 ast_debug(1, "Hanging up zombie '%s'\n", chan->name);
1465         }
1466                         
1467         ast_channel_unlock(chan);
1468         manager_event(EVENT_FLAG_CALL, "Hangup",
1469                         "Channel: %s\r\n"
1470                         "Uniqueid: %s\r\n"
1471                         "CallerIDNum: %s\r\n"
1472                         "CallerIDName: %s\r\n"
1473                         "Cause: %d\r\n"
1474                         "Cause-txt: %s\r\n",
1475                         chan->name,
1476                         chan->uniqueid,
1477                         S_OR(chan->cid.cid_num, "<unknown>"),
1478                         S_OR(chan->cid.cid_name, "<unknown>"),
1479                         chan->hangupcause,
1480                         ast_cause2str(chan->hangupcause)
1481                         );
1482         ast_channel_free(chan);
1483
1484         if (cdr)
1485                 ast_cdr_detach(cdr);
1486
1487         return res;
1488 }
1489
1490 int __ast_answer(struct ast_channel *chan, unsigned int delay)
1491 {
1492         int res = 0;
1493
1494         ast_channel_lock(chan);
1495
1496         /* You can't answer an outbound call */
1497         if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
1498                 ast_channel_unlock(chan);
1499                 return 0;
1500         }
1501
1502         /* Stop if we're a zombie or need a soft hangup */
1503         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1504                 ast_channel_unlock(chan);
1505                 return -1;
1506         }
1507
1508         switch (chan->_state) {
1509         case AST_STATE_RINGING:
1510         case AST_STATE_RING:
1511                 if (chan->tech->answer)
1512                         res = chan->tech->answer(chan);
1513                 ast_setstate(chan, AST_STATE_UP);
1514                 ast_cdr_answer(chan->cdr);
1515                 ast_channel_unlock(chan);
1516                 if (delay)
1517                         ast_safe_sleep(chan, delay);
1518                 return res;
1519                 break;
1520         case AST_STATE_UP:
1521                 ast_cdr_answer(chan->cdr);
1522                 break;
1523         default:
1524                 break;
1525         }
1526
1527         ast_channel_unlock(chan);
1528
1529         return res;
1530 }
1531
1532 int ast_answer(struct ast_channel *chan)
1533 {
1534         return __ast_answer(chan, 500);
1535 }
1536
1537 void ast_deactivate_generator(struct ast_channel *chan)
1538 {
1539         ast_channel_lock(chan);
1540         if (chan->generatordata) {
1541                 if (chan->generator && chan->generator->release)
1542                         chan->generator->release(chan, chan->generatordata);
1543                 chan->generatordata = NULL;
1544                 chan->generator = NULL;
1545                 ast_channel_set_fd(chan, AST_GENERATOR_FD, -1);
1546                 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1547                 ast_settimeout(chan, 0, NULL, NULL);
1548         }
1549         ast_channel_unlock(chan);
1550 }
1551
1552 static int generator_force(const void *data)
1553 {
1554         /* Called if generator doesn't have data */
1555         void *tmp;
1556         int res;
1557         int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
1558         struct ast_channel *chan = (struct ast_channel *)data;
1559         tmp = chan->generatordata;
1560         chan->generatordata = NULL;
1561         generate = chan->generator->generate;
1562         res = generate(chan, tmp, 0, 160);
1563         chan->generatordata = tmp;
1564         if (res) {
1565                 ast_debug(1, "Auto-deactivating generator\n");
1566                 ast_deactivate_generator(chan);
1567         }
1568         return 0;
1569 }
1570
1571 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1572 {
1573         int res = 0;
1574
1575         ast_channel_lock(chan);
1576
1577         if (chan->generatordata) {
1578                 if (chan->generator && chan->generator->release)
1579                         chan->generator->release(chan, chan->generatordata);
1580                 chan->generatordata = NULL;
1581         }
1582
1583         ast_prod(chan);
1584         if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1585                 res = -1;
1586         }
1587         
1588         if (!res) {
1589                 ast_settimeout(chan, 160, generator_force, chan);
1590                 chan->generator = gen;
1591         }
1592
1593         ast_channel_unlock(chan);
1594
1595         return res;
1596 }
1597
1598 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1599 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1600 {
1601         int winner = -1;
1602         ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1603         return winner;
1604 }
1605
1606 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1607 #ifdef HAVE_EPOLL
1608 static struct ast_channel *ast_waitfor_nandfds_classic(struct ast_channel **c, int n, int *fds, int nfds,
1609                                         int *exception, int *outfd, int *ms)
1610 #else
1611 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1612                                         int *exception, int *outfd, int *ms)
1613 #endif
1614 {
1615         struct timeval start = { 0 , 0 };
1616         struct pollfd *pfds;
1617         int res;
1618         long rms;
1619         int x, y, max;
1620         int sz;
1621         time_t now = 0;
1622         long whentohangup = 0, diff;
1623         struct ast_channel *winner = NULL;
1624         struct fdmap {
1625                 int chan;
1626                 int fdno;
1627         } *fdmap;
1628
1629         sz = n * AST_MAX_FDS + nfds;
1630         pfds = alloca(sizeof(*pfds) * sz);
1631         fdmap = alloca(sizeof(*fdmap) * sz);
1632
1633         if (outfd)
1634                 *outfd = -99999;
1635         if (exception)
1636                 *exception = 0;
1637         
1638         /* Perform any pending masquerades */
1639         for (x = 0; x < n; x++) {
1640                 ast_channel_lock(c[x]);
1641                 if (c[x]->masq && ast_do_masquerade(c[x])) {
1642                         ast_log(LOG_WARNING, "Masquerade failed\n");
1643                         *ms = -1;
1644                         ast_channel_unlock(c[x]);
1645                         return NULL;
1646                 }
1647                 if (c[x]->whentohangup) {
1648                         if (!whentohangup)
1649                                 time(&now);
1650                         diff = c[x]->whentohangup - now;
1651                         if (diff < 1) {
1652                                 /* Should already be hungup */
1653                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1654                                 ast_channel_unlock(c[x]);
1655                                 return c[x];
1656                         }
1657                         if (!whentohangup || (diff < whentohangup))
1658                                 whentohangup = diff;
1659                 }
1660                 ast_channel_unlock(c[x]);
1661         }
1662         /* Wait full interval */
1663         rms = *ms;
1664         if (whentohangup) {
1665                 rms = whentohangup * 1000;              /* timeout in milliseconds */
1666                 if (*ms >= 0 && *ms < rms)              /* original *ms still smaller */
1667                         rms =  *ms;
1668         }
1669         /*
1670          * Build the pollfd array, putting the channels' fds first,
1671          * followed by individual fds. Order is important because
1672          * individual fd's must have priority over channel fds.
1673          */
1674         max = 0;
1675         for (x = 0; x < n; x++) {
1676                 for (y = 0; y < AST_MAX_FDS; y++) {
1677                         fdmap[max].fdno = y;  /* fd y is linked to this pfds */
1678                         fdmap[max].chan = x;  /* channel x is linked to this pfds */
1679                         max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1680                 }
1681                 CHECK_BLOCKING(c[x]);
1682         }
1683         /* Add the individual fds */
1684         for (x = 0; x < nfds; x++) {
1685                 fdmap[max].chan = -1;
1686                 max += ast_add_fd(&pfds[max], fds[x]);
1687         }
1688
1689         if (*ms > 0)
1690                 start = ast_tvnow();
1691         
1692         if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1693                 do {
1694                         int kbrms = rms;
1695                         if (kbrms > 600000)
1696                                 kbrms = 600000;
1697                         res = poll(pfds, max, kbrms);
1698                         if (!res)
1699                                 rms -= kbrms;
1700                 } while (!res && (rms > 0));
1701         } else {
1702                 res = poll(pfds, max, rms);
1703         }
1704         for (x = 0; x < n; x++)
1705                 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1706         if (res < 0) { /* Simulate a timeout if we were interrupted */
1707                 if (errno != EINTR)
1708                         *ms = -1;
1709                 return NULL;
1710         }
1711         if (whentohangup) {   /* if we have a timeout, check who expired */
1712                 time(&now);
1713                 for (x = 0; x < n; x++) {
1714                         if (c[x]->whentohangup && now >= c[x]->whentohangup) {
1715                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1716                                 if (winner == NULL)
1717                                         winner = c[x];
1718                         }
1719                 }
1720         }
1721         if (res == 0) { /* no fd ready, reset timeout and done */
1722                 *ms = 0;        /* XXX use 0 since we may not have an exact timeout. */
1723                 return winner;
1724         }
1725         /*
1726          * Then check if any channel or fd has a pending event.
1727          * Remember to check channels first and fds last, as they
1728          * must have priority on setting 'winner'
1729          */
1730         for (x = 0; x < max; x++) {
1731                 res = pfds[x].revents;
1732                 if (res == 0)
1733                         continue;
1734                 if (fdmap[x].chan >= 0) {       /* this is a channel */
1735                         winner = c[fdmap[x].chan];      /* override previous winners */
1736                         if (res & POLLPRI)
1737                                 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1738                         else
1739                                 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1740                         winner->fdno = fdmap[x].fdno;
1741                 } else {                        /* this is an fd */
1742                         if (outfd)
1743                                 *outfd = pfds[x].fd;
1744                         if (exception)
1745                                 *exception = (res & POLLPRI) ? -1 : 0;
1746                         winner = NULL;
1747                 }
1748         }
1749         if (*ms > 0) {
1750                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1751                 if (*ms < 0)
1752                         *ms = 0;
1753         }
1754         return winner;
1755 }
1756
1757 #ifdef HAVE_EPOLL
1758 static struct ast_channel *ast_waitfor_nandfds_simple(struct ast_channel *chan, int *ms)
1759 {
1760         struct timeval start = { 0 , 0 };
1761         int res = 0;
1762         struct epoll_event ev[1];
1763         long whentohangup = 0, rms = *ms;
1764         time_t now;
1765         struct ast_channel *winner = NULL;
1766         struct ast_epoll_data *aed = NULL;
1767
1768         ast_channel_lock(chan);
1769
1770         /* See if this channel needs to be masqueraded */
1771         if (chan->masq && ast_do_masquerade(chan)) {
1772                 ast_log(LOG_WARNING, "Failed to perform masquerade on %s\n", chan->name);
1773                 *ms = -1;
1774                 ast_channel_unlock(chan);
1775                 return NULL;
1776         }
1777
1778         /* Figure out their timeout */
1779         if (chan->whentohangup) {
1780                 time(&now);
1781                 if ((whentohangup = chan->whentohangup - now) < 1) {
1782                         /* They should already be hungup! */
1783                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1784                         ast_channel_unlock(chan);
1785                         return NULL;
1786                 }
1787                 /* If this value is smaller then the current one... make it priority */
1788                 whentohangup *= 1000;
1789                 if (rms > whentohangup)
1790                         rms = whentohangup;
1791         }
1792
1793         ast_channel_unlock(chan);
1794
1795         /* Time to make this channel block... */
1796         CHECK_BLOCKING(chan);
1797
1798         if (*ms > 0)
1799                 start = ast_tvnow();
1800
1801         /* We don't have to add any file descriptors... they are already added, we just have to wait! */
1802         res = epoll_wait(chan->epfd, ev, 1, rms);
1803
1804         /* Stop blocking */
1805         ast_clear_flag(chan, AST_FLAG_BLOCKING);
1806
1807         /* Simulate a timeout if we were interrupted */
1808         if (res < 0) {
1809                 if (errno != EINTR)
1810                         *ms = -1;
1811                 return NULL;
1812         }
1813
1814         /* If this channel has a timeout see if it expired */
1815         if (chan->whentohangup) {
1816                 time(&now);
1817                 if (now >= chan->whentohangup) {
1818                         chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1819                         winner = chan;
1820                 }
1821         }
1822
1823         /* No fd ready, reset timeout and be done for now */
1824         if (!res) {
1825                 *ms = 0;
1826                 return winner;
1827         }
1828
1829         /* See what events are pending */
1830         aed = ev[0].data.ptr;
1831         chan->fdno = aed->which;
1832         if (ev[0].events & EPOLLPRI)
1833                 ast_set_flag(chan, AST_FLAG_EXCEPTION);
1834         else
1835                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
1836
1837         if (*ms > 0) {
1838                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1839                 if (*ms < 0)
1840                         *ms = 0;
1841         }
1842
1843         return chan;
1844 }
1845
1846 static struct ast_channel *ast_waitfor_nandfds_complex(struct ast_channel **c, int n, int *ms)
1847 {
1848         struct timeval start = { 0 , 0 };
1849         int res = 0, i;
1850         struct epoll_event ev[25] = { { 0, } };
1851         long whentohangup = 0, diff, rms = *ms;
1852         time_t now;
1853         struct ast_channel *winner = NULL;
1854
1855         for (i = 0; i < n; i++) {
1856                 ast_channel_lock(c[i]);
1857                 if (c[i]->masq && ast_do_masquerade(c[i])) {
1858                         ast_log(LOG_WARNING, "Masquerade failed\n");
1859                         *ms = -1;
1860                         ast_channel_unlock(c[i]);
1861                         return NULL;
1862                 }
1863                 if (c[i]->whentohangup) {
1864                         if (!whentohangup)
1865                                 time(&now);
1866                         if ((diff = c[i]->whentohangup - now) < 1) {
1867                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1868                                 ast_channel_unlock(c[i]);
1869                                 return c[i];
1870                         }
1871                         if (!whentohangup || (diff < whentohangup))
1872                                 whentohangup = diff;
1873                 }
1874                 ast_channel_unlock(c[i]);
1875                 CHECK_BLOCKING(c[i]);
1876         }
1877
1878         rms = *ms;
1879         if (whentohangup) {
1880                 rms = whentohangup * 1000;
1881                 if (*ms >= 0 && *ms < rms)
1882                         rms = *ms;
1883         }
1884
1885         if (*ms > 0)
1886                 start = ast_tvnow();
1887
1888         res = epoll_wait(c[0]->epfd, ev, 25, rms);
1889
1890         for (i = 0; i < n; i++)
1891                 ast_clear_flag(c[i], AST_FLAG_BLOCKING);
1892
1893         if (res < 0) {
1894                 if (errno != EINTR)
1895                         *ms = -1;
1896                 return NULL;
1897         }
1898
1899         if (whentohangup) {
1900                 time(&now);
1901                 for (i = 0; i < n; i++) {
1902                         if (c[i]->whentohangup && now >= c[i]->whentohangup) {
1903                                 c[i]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1904                                 if (!winner)
1905                                         winner = c[i];
1906                         }
1907                 }
1908         }
1909
1910         if (!res) {
1911                 *ms = 0;
1912                 return winner;
1913         }
1914
1915         for (i = 0; i < 25; i++) {
1916                 struct ast_epoll_data *aed = ev[i].data.ptr;
1917
1918                 if (!ev[i].events || !aed)
1919                         continue;
1920
1921                 winner = aed->chan;
1922                 if (ev[i].events & EPOLLPRI)
1923                         ast_set_flag(winner, AST_FLAG_EXCEPTION);
1924                 else
1925                         ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1926                 winner->fdno = aed->which;
1927         }
1928
1929         if (*ms > 0) {
1930                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1931                 if (*ms < 0)
1932                         *ms = 0;
1933         }
1934
1935         return winner;
1936 }
1937
1938 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1939                                         int *exception, int *outfd, int *ms)
1940 {
1941         /* Clear all provided values in one place. */
1942         if (outfd)
1943                 *outfd = -99999;
1944         if (exception)
1945                 *exception = 0;
1946
1947         /* If no epoll file descriptor is available resort to classic nandfds */
1948         if (!n || nfds || c[0]->epfd == -1)
1949                 return ast_waitfor_nandfds_classic(c, n, fds, nfds, exception, outfd, ms);
1950         else if (!nfds && n == 1)
1951                 return ast_waitfor_nandfds_simple(c[0], ms);
1952         else
1953                 return ast_waitfor_nandfds_complex(c, n, ms);
1954 }
1955 #endif
1956
1957 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
1958 {
1959         return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
1960 }
1961
1962 int ast_waitfor(struct ast_channel *c, int ms)
1963 {
1964         int oldms = ms; /* -1 if no timeout */
1965
1966         ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
1967         if ((ms < 0) && (oldms < 0))
1968                 ms = 0;
1969         return ms;
1970 }
1971
1972 /* XXX never to be called with ms = -1 */
1973 int ast_waitfordigit(struct ast_channel *c, int ms)
1974 {
1975         return ast_waitfordigit_full(c, ms, -1, -1);
1976 }
1977
1978 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(const void *data), void *data)
1979 {
1980         int res = -1;
1981 #ifdef HAVE_ZAPTEL
1982         if (c->timingfd > -1) {
1983                 if (!func) {
1984                         samples = 0;
1985                         data = 0;
1986                 }
1987                 ast_debug(1, "Scheduling timer at %d sample intervals\n", samples);
1988                 res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
1989                 c->timingfunc = func;
1990                 c->timingdata = data;
1991         }
1992 #endif  
1993         return res;
1994 }
1995
1996 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
1997 {
1998         /* Stop if we're a zombie or need a soft hangup */
1999         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
2000                 return -1;
2001
2002         /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
2003         ast_set_flag(c, AST_FLAG_END_DTMF_ONLY);
2004
2005         /* Wait for a digit, no more than ms milliseconds total. */
2006         
2007         while (ms) {
2008                 struct ast_channel *rchan;
2009                 int outfd=-1;
2010
2011                 errno = 0;
2012                 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
2013                 
2014                 if (!rchan && outfd < 0 && ms) {
2015                         if (errno == 0 || errno == EINTR)
2016                                 continue;
2017                         ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
2018                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2019                         return -1;
2020                 } else if (outfd > -1) {
2021                         /* The FD we were watching has something waiting */
2022                         ast_log(LOG_WARNING, "The FD we were waiting for has something waiting. Waitfordigit returning numeric 1\n");
2023                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2024                         return 1;
2025                 } else if (rchan) {
2026                         int res;
2027                         struct ast_frame *f = ast_read(c);
2028                         if (!f)
2029                                 return -1;
2030
2031                         switch (f->frametype) {
2032                         case AST_FRAME_DTMF_BEGIN:
2033                                 break;
2034                         case AST_FRAME_DTMF_END:
2035                                 res = f->subclass;
2036                                 ast_frfree(f);
2037                                 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2038                                 return res;
2039                         case AST_FRAME_CONTROL:
2040                                 switch (f->subclass) {
2041                                 case AST_CONTROL_HANGUP:
2042                                         ast_frfree(f);
2043                                         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2044                                         return -1;
2045                                 case AST_CONTROL_RINGING:
2046                                 case AST_CONTROL_ANSWER:
2047                                         /* Unimportant */
2048                                         break;
2049                                 default:
2050                                         ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
2051                                         break;
2052                                 }
2053                                 break;
2054                         case AST_FRAME_VOICE:
2055                                 /* Write audio if appropriate */
2056                                 if (audiofd > -1)
2057                                         write(audiofd, f->data, f->datalen);
2058                         default:
2059                                 /* Ignore */
2060                                 break;
2061                         }
2062                         ast_frfree(f);
2063                 }
2064         }
2065
2066         ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
2067
2068         return 0; /* Time is up */
2069 }
2070
2071 static void send_dtmf_event(const struct ast_channel *chan, const char *direction, const char digit, const char *begin, const char *end)
2072 {
2073         manager_event(EVENT_FLAG_DTMF,
2074                         "DTMF",
2075                         "Channel: %s\r\n"
2076                         "Uniqueid: %s\r\n"
2077                         "Digit: %c\r\n"
2078                         "Direction: %s\r\n"
2079                         "Begin: %s\r\n"
2080                         "End: %s\r\n",
2081                         chan->name, chan->uniqueid, digit, direction, begin, end);
2082 }
2083
2084 static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
2085 {
2086         if (chan->generatordata &&  !ast_internal_timing_enabled(chan)) {
2087                 void *tmp = chan->generatordata;
2088                 int res;
2089
2090                 if (chan->timingfunc) {
2091                         if (option_debug > 1)
2092                                 ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n");
2093                         ast_settimeout(chan, 0, NULL, NULL);
2094                 }
2095
2096                 chan->generatordata = NULL;     /* reset, to let writes go through */
2097                 res = chan->generator->generate(chan, tmp, f->datalen, f->samples);
2098                 chan->generatordata = tmp;
2099                 if (res) {
2100                         if (option_debug > 1)
2101                                 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
2102                         ast_deactivate_generator(chan);
2103                 }
2104
2105         } else if (f->frametype == AST_FRAME_CNG) {
2106                 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
2107                         if (option_debug > 1)
2108                                 ast_log(LOG_DEBUG, "Generator got CNG, switching to timed mode\n");
2109                         ast_settimeout(chan, 160, generator_force, chan);
2110                 }
2111         }
2112 }
2113
2114 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
2115 {
2116         struct ast_frame *f = NULL;     /* the return value */
2117         int blah;
2118         int prestate;
2119         int count = 0;
2120
2121         /* this function is very long so make sure there is only one return
2122          * point at the end (there are only two exceptions to this).
2123          */
2124         while(ast_channel_trylock(chan)) {
2125                 if(count++ > 10) 
2126                         /*cannot goto done since the channel is not locked*/
2127                         return &ast_null_frame;
2128                 usleep(1);
2129         }
2130
2131         if (chan->masq) {
2132                 if (ast_do_masquerade(chan))
2133                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2134                 else
2135                         f =  &ast_null_frame;
2136                 goto done;
2137         }
2138
2139         /* Stop if we're a zombie or need a soft hangup */
2140         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2141                 if (chan->generator)
2142                         ast_deactivate_generator(chan);
2143                 goto done;
2144         }
2145         prestate = chan->_state;
2146
2147         if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) && 
2148             !ast_strlen_zero(chan->dtmfq) && 
2149                 (ast_tvzero(chan->dtmf_tv) || ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) > AST_MIN_DTMF_GAP) ) {
2150                 /* We have DTMF that has been deferred.  Return it now */
2151                 chan->dtmff.subclass = chan->dtmfq[0];
2152                 /* Drop first digit from the buffer */
2153                 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
2154                 f = &chan->dtmff;
2155                 if (ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
2156                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2157                         chan->dtmff.frametype = AST_FRAME_DTMF_END;
2158                 } else {
2159                         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);
2160                         chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
2161                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2162                         chan->emulate_dtmf_digit = f->subclass;
2163                         chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2164                 }
2165                 chan->dtmf_tv = ast_tvnow();
2166                 goto done;
2167         }
2168         
2169         /* Read and ignore anything on the alertpipe, but read only
2170            one sizeof(blah) per frame that we send from it */
2171         if (chan->alertpipe[0] > -1)
2172                 read(chan->alertpipe[0], &blah, sizeof(blah));
2173
2174 #ifdef HAVE_ZAPTEL
2175         if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2176                 int res;
2177
2178                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2179                 blah = -1;
2180                 /* IF we can't get event, assume it's an expired as-per the old interface */
2181                 res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
2182                 if (res)
2183                         blah = ZT_EVENT_TIMER_EXPIRED;
2184
2185                 if (blah == ZT_EVENT_TIMER_PING) {
2186                         if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
2187                                 /* Acknowledge PONG unless we need it again */
2188                                 if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
2189                                         ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
2190                                 }
2191                         }
2192                 } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
2193                         ioctl(chan->timingfd, ZT_TIMERACK, &blah);
2194                         if (chan->timingfunc) {
2195                                 chan->timingfunc(chan->timingdata);
2196                         } else {
2197                                 blah = 0;
2198                                 ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
2199                                 chan->timingdata = NULL;
2200                         }
2201                         ast_channel_unlock(chan);
2202                         /* cannot 'goto done' because the channel is already unlocked */
2203                         return &ast_null_frame;
2204                 } else
2205                         ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
2206         } else
2207 #endif
2208         if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
2209                 /* if the AST_GENERATOR_FD is set, call the generator with args
2210                  * set to -1 so it can do whatever it needs to.
2211                  */
2212                 void *tmp = chan->generatordata;
2213                 chan->generatordata = NULL;     /* reset to let ast_write get through */
2214                 chan->generator->generate(chan, tmp, -1, -1);
2215                 chan->generatordata = tmp;
2216                 f = &ast_null_frame;
2217                 goto done;
2218         }
2219
2220         /* Check for pending read queue */
2221         if (!AST_LIST_EMPTY(&chan->readq)) {
2222                 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
2223                 /* Interpret hangup and return NULL */
2224                 /* XXX why not the same for frames from the channel ? */
2225                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
2226                         ast_frfree(f);
2227                         f = NULL;
2228                 }
2229         } else {
2230                 chan->blocker = pthread_self();
2231                 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2232                         if (chan->tech->exception)
2233                                 f = chan->tech->exception(chan);
2234                         else {
2235                                 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
2236                                 f = &ast_null_frame;
2237                         }
2238                         /* Clear the exception flag */
2239                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2240                 } else if (chan->tech->read)
2241                         f = chan->tech->read(chan);
2242                 else
2243                         ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
2244         }
2245
2246         if (f) {
2247                 /* if the channel driver returned more than one frame, stuff the excess
2248                    into the readq for the next ast_read call (note that we can safely assume
2249                    that the readq is empty, because otherwise we would not have called into
2250                    the channel driver and f would be only a single frame)
2251                 */
2252                 if (AST_LIST_NEXT(f, frame_list)) {
2253                         AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
2254                         AST_LIST_NEXT(f, frame_list) = NULL;
2255                 }
2256
2257                 switch (f->frametype) {
2258                 case AST_FRAME_CONTROL:
2259                         if (f->subclass == AST_CONTROL_ANSWER) {
2260                                 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
2261                                         ast_debug(1, "Ignoring answer on an inbound call!\n");
2262                                         ast_frfree(f);
2263                                         f = &ast_null_frame;
2264                                 } else if (prestate == AST_STATE_UP) {
2265                                         ast_debug(1, "Dropping duplicate answer!\n");
2266                                         ast_frfree(f);
2267                                         f = &ast_null_frame;
2268                                 } else {
2269                                         /* Answer the CDR */
2270                                         ast_setstate(chan, AST_STATE_UP);
2271                                         if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
2272                                                                                  to keep from throwing off the basic order of the universe,
2273                                                                                  we will try to keep this cdr from getting posted. */
2274                                                 chan->cdr = ast_cdr_alloc();
2275                                                 ast_cdr_init(chan->cdr, chan);
2276                                                 ast_cdr_start(chan->cdr);
2277                                         }
2278                                         
2279                                         ast_cdr_answer(chan->cdr);
2280                                 }
2281                         }
2282                         break;
2283                 case AST_FRAME_DTMF_END:
2284                         send_dtmf_event(chan, "Received", f->subclass, "No", "Yes");
2285                         ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass, chan->name, f->len);
2286                         /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2287                          * However, only let emulation be forced if the other end cares about BEGIN frames */
2288                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF) ||
2289                                 (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) ) {
2290                                 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2291                                         ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2292                                         chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2293                                 } else
2294                                         ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2295                                 ast_frfree(f);
2296                                 f = &ast_null_frame;
2297                         } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) {
2298                                 if (!ast_tvzero(chan->dtmf_tv) && 
2299                                     ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) {
2300                                         /* If it hasn't been long enough, defer this digit */
2301                                         if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2302                                                 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2303                                                 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2304                                         } else
2305                                                 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2306                                         ast_frfree(f);
2307                                         f = &ast_null_frame;
2308                                 } else {
2309                                         /* There was no begin, turn this into a begin and send the end later */
2310                                         f->frametype = AST_FRAME_DTMF_BEGIN;
2311                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2312                                         chan->emulate_dtmf_digit = f->subclass;
2313                                         chan->dtmf_tv = ast_tvnow();
2314                                         if (f->len) {
2315                                                 if (f->len > AST_MIN_DTMF_DURATION)
2316                                                         chan->emulate_dtmf_duration = f->len;
2317                                                 else 
2318                                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION;
2319                                         } else
2320                                                 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2321                                         ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass, chan->emulate_dtmf_duration, chan->name);
2322                                 }
2323                                 if (chan->audiohooks) {
2324                                         struct ast_frame *old_frame = f;
2325                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2326                                         if (old_frame != f)
2327                                                 ast_frfree(old_frame);
2328                                 }
2329                         } else {
2330                                 struct timeval now = ast_tvnow();
2331                                 if (ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2332                                         ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass, chan->name);
2333                                         ast_clear_flag(chan, AST_FLAG_IN_DTMF);
2334                                         if (!f->len)
2335                                                 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2336                                 } else if (!f->len) {
2337                                         ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass, chan->name);
2338                                         f->len = AST_MIN_DTMF_DURATION;
2339                                 }
2340                                 if (f->len < AST_MIN_DTMF_DURATION) {
2341                                         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);
2342                                         ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2343                                         chan->emulate_dtmf_digit = f->subclass;
2344                                         chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len;
2345                                         ast_frfree(f);
2346                                         f = &ast_null_frame;
2347                                 } else {
2348                                         ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass, chan->name);
2349                                         chan->dtmf_tv = now;
2350                                 }
2351                                 if (chan->audiohooks) {
2352                                         struct ast_frame *old_frame = f;
2353                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2354                                         if (old_frame != f)
2355                                                 ast_frfree(old_frame);
2356                                 }
2357                         }
2358                         break;
2359                 case AST_FRAME_DTMF_BEGIN:
2360                         send_dtmf_event(chan, "Received", f->subclass, "Yes", "No");
2361                         ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2362                         if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY) || 
2363                             (!ast_tvzero(chan->dtmf_tv) && 
2364                               ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) {
2365                                 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass, chan->name);
2366                                 ast_frfree(f);
2367                                 f = &ast_null_frame;
2368                         } else {
2369                                 ast_set_flag(chan, AST_FLAG_IN_DTMF);
2370                                 chan->dtmf_tv = ast_tvnow();
2371                                 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass, chan->name);
2372                         }
2373                         break;
2374                 case AST_FRAME_NULL:
2375                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2376                                 struct timeval now = ast_tvnow();
2377                                 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2378                                         chan->emulate_dtmf_duration = 0;
2379                                         ast_frfree(f);
2380                                         f = &chan->dtmff;
2381                                         f->frametype = AST_FRAME_DTMF_END;
2382                                         f->subclass = chan->emulate_dtmf_digit;
2383                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2384                                         chan->dtmf_tv = now;
2385                                         ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2386                                         chan->emulate_dtmf_digit = 0;
2387                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2388                                 }
2389                         }
2390                         break;
2391                 case AST_FRAME_VOICE:
2392                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2393                          * is reached , because we want to make sure we pass at least one
2394                          * voice frame through before starting the next digit, to ensure a gap
2395                          * between DTMF digits. */
2396                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) {
2397                                 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2398                                 chan->emulate_dtmf_digit = 0;
2399                         }
2400
2401                         if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2402                                 if (dropaudio)
2403                                         ast_read_generator_actions(chan, f);
2404                                 ast_frfree(f);
2405                                 f = &ast_null_frame;
2406                         }
2407
2408                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2409                                 struct timeval now = ast_tvnow();
2410                                 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2411                                         chan->emulate_dtmf_duration = 0;
2412                                         ast_frfree(f);
2413                                         f = &chan->dtmff;
2414                                         f->frametype = AST_FRAME_DTMF_END;
2415                                         f->subclass = chan->emulate_dtmf_digit;
2416                                         f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2417                                         chan->dtmf_tv = now;
2418                                         if (chan->audiohooks) {
2419                                                 struct ast_frame *old_frame = f;
2420                                                 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2421                                                 if (old_frame != f)
2422                                                         ast_frfree(old_frame);
2423                                         }
2424                                         ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2425                                 } else {
2426                                         /* Drop voice frames while we're still in the middle of the digit */
2427                                         ast_frfree(f);
2428                                         f = &ast_null_frame;
2429                                 }
2430                         } else if ((f->frametype == AST_FRAME_VOICE) && !(f->subclass & chan->nativeformats)) {
2431                                 /* This frame can't be from the current native formats -- drop it on the
2432                                    floor */
2433                                 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2434                                         chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
2435                                 ast_frfree(f);
2436                                 f = &ast_null_frame;
2437                         } else if ((f->frametype == AST_FRAME_VOICE)) {
2438                                 /* Send frame to audiohooks if present */
2439                                 if (chan->audiohooks) {
2440                                         struct ast_frame *old_frame = f;
2441                                         f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2442                                         if (old_frame != f)
2443                                                 ast_frfree(old_frame);
2444                                 }
2445                                 if (chan->monitor && chan->monitor->read_stream ) {
2446                                         /* XXX what does this do ? */
2447 #ifndef MONITOR_CONSTANT_DELAY
2448                                         int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2449                                         if (jump >= 0) {
2450                                                 jump = chan->outsmpl - chan->insmpl;
2451                                                 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1)
2452                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2453                                                 chan->insmpl += jump + f->samples;
2454                                         } else
2455                                                 chan->insmpl+= f->samples;
2456 #else
2457                                         int jump = chan->outsmpl - chan->insmpl;
2458                                         if (jump - MONITOR_DELAY >= 0) {
2459                                                 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2460                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2461                                                 chan->insmpl += jump;
2462                                         } else
2463                                                 chan->insmpl += f->samples;
2464 #endif
2465                                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2466                                                 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2467                                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2468                                         }
2469                                 }
2470
2471                                 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
2472                                         f = &ast_null_frame;
2473                                 else
2474                                         /* Run generator sitting on the line if timing device not available
2475                                          * and synchronous generation of outgoing frames is necessary       */
2476                                         ast_read_generator_actions(chan, f);
2477                         }
2478                 default:
2479                         /* Just pass it on! */
2480                         break;
2481                 }
2482         } else {
2483                 /* Make sure we always return NULL in the future */
2484                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2485                 if (chan->generator)
2486                         ast_deactivate_generator(chan);
2487                 /* End the CDR if appropriate */
2488                 if (chan->cdr)
2489                         ast_cdr_end(chan->cdr);
2490         }
2491
2492         /* High bit prints debugging */
2493         if (chan->fin & DEBUGCHAN_FLAG)
2494                 ast_frame_dump(chan->name, f, "<<");
2495         chan->fin = FRAMECOUNT_INC(chan->fin);
2496
2497 done:
2498         if (chan->music_state && chan->generator && chan->generator->digit && f && f->frametype == AST_FRAME_DTMF_END)
2499                 chan->generator->digit(chan, f->subclass);
2500
2501         ast_channel_unlock(chan);
2502         return f;
2503 }
2504
2505 int ast_internal_timing_enabled(struct ast_channel *chan)
2506 {
2507         int ret = ast_opt_internal_timing && chan->timingfd > -1;
2508         ast_debug(5, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
2509         return ret;
2510 }
2511
2512 struct ast_frame *ast_read(struct ast_channel *chan)
2513 {
2514         return __ast_read(chan, 0);
2515 }
2516
2517 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2518 {
2519         return __ast_read(chan, 1);
2520 }
2521
2522 int ast_indicate(struct ast_channel *chan, int condition)
2523 {
2524         return ast_indicate_data(chan, condition, NULL, 0);
2525 }
2526
2527 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
2528 {
2529         int res = -1;
2530
2531         ast_channel_lock(chan);
2532         /* Stop if we're a zombie or need a soft hangup */
2533         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2534                 ast_channel_unlock(chan);
2535                 return -1;
2536         }
2537         if (chan->tech->indicate)
2538                 res = chan->tech->indicate(chan, condition, data, datalen);
2539         ast_channel_unlock(chan);
2540         if (!chan->tech->indicate || res) {
2541                 /*
2542                  * Device does not support (that) indication, lets fake
2543                  * it by doing our own tone generation. (PM2002)
2544                  */
2545                 if (condition < 0)
2546                         ast_playtones_stop(chan);
2547                 else {
2548                         const struct ind_tone_zone_sound *ts = NULL;
2549                         switch (condition) {
2550                         case AST_CONTROL_RINGING:
2551                                 ts = ast_get_indication_tone(chan->zone, "ring");
2552                                 break;
2553                         case AST_CONTROL_BUSY:
2554                                 ts = ast_get_indication_tone(chan->zone, "busy");
2555                                 break;
2556                         case AST_CONTROL_CONGESTION:
2557                                 ts = ast_get_indication_tone(chan->zone, "congestion");
2558                                 break;
2559                         }
2560                         if (ts && ts->data[0]) {
2561                                 ast_debug(1, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2562                                 ast_playtones_start(chan,0,ts->data, 1);
2563                                 res = 0;
2564                         } else if (condition == AST_CONTROL_PROGRESS) {
2565                                 /* ast_playtones_stop(chan); */
2566                         } else if (condition == AST_CONTROL_PROCEEDING) {
2567                                 /* Do nothing, really */
2568                         } else if (condition == AST_CONTROL_HOLD) {
2569                                 /* Do nothing.... */
2570                         } else if (condition == AST_CONTROL_UNHOLD) {
2571                                 /* Do nothing.... */
2572                         } else if (condition == AST_CONTROL_VIDUPDATE) {
2573                                 /* Do nothing.... */
2574                         } else {
2575                                 /* not handled */
2576                                 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2577                                 res = -1;
2578                         }
2579                 }
2580         }
2581         return res;
2582 }
2583
2584 int ast_recvchar(struct ast_channel *chan, int timeout)
2585 {
2586         int c;
2587         char *buf = ast_recvtext(chan, timeout);
2588         if (buf == NULL)
2589                 return -1;      /* error or timeout */
2590         c = *(unsigned char *)buf;
2591         ast_free(buf);
2592         return c;
2593 }
2594
2595 char *ast_recvtext(struct ast_channel *chan, int timeout)
2596 {
2597         int res, done = 0;
2598         char *buf = NULL;
2599         
2600         while (!done) {
2601                 struct ast_frame *f;
2602                 if (ast_check_hangup(chan))
2603                         break;
2604                 res = ast_waitfor(chan, timeout);
2605                 if (res <= 0) /* timeout or error */
2606                         break;
2607                 timeout = res;  /* update timeout */
2608                 f = ast_read(chan);
2609                 if (f == NULL)
2610                         break; /* no frame */
2611                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2612                         done = 1;       /* force a break */
2613                 else if (f->frametype == AST_FRAME_TEXT) {              /* what we want */
2614                         buf = ast_strndup((char *) f->data, f->datalen);        /* dup and break */
2615                         done = 1;
2616                 }
2617                 ast_frfree(f);
2618         }
2619         return buf;
2620 }
2621
2622 int ast_sendtext(struct ast_channel *chan, const char *text)
2623 {
2624         int res = 0;
2625         /* Stop if we're a zombie or need a soft hangup */
2626         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2627                 return -1;
2628         CHECK_BLOCKING(chan);
2629         if (chan->tech->send_text)
2630                 res = chan->tech->send_text(chan, text);
2631         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2632         return res;
2633 }
2634
2635 int ast_senddigit_begin(struct ast_channel *chan, char digit)
2636 {
2637         /* Device does not support DTMF tones, lets fake
2638          * it by doing our own generation. */
2639         static const char* dtmf_tones[] = {
2640                 "941+1336", /* 0 */
2641                 "697+1209", /* 1 */
2642                 "697+1336", /* 2 */
2643                 "697+1477", /* 3 */
2644                 "770+1209", /* 4 */
2645                 "770+1336", /* 5 */
2646                 "770+1477", /* 6 */
2647                 "852+1209", /* 7 */
2648                 "852+1336", /* 8 */
2649                 "852+1477", /* 9 */
2650                 "697+1633", /* A */
2651                 "770+1633", /* B */
2652                 "852+1633", /* C */
2653                 "941+1633", /* D */
2654                 "941+1209", /* * */
2655                 "941+1477"  /* # */
2656         };
2657
2658         if (!chan->tech->send_digit_begin)
2659                 return 0;
2660
2661         if (!chan->tech->send_digit_begin(chan, digit))
2662                 return 0;
2663
2664         if (digit >= '0' && digit <='9')
2665                 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2666         else if (digit >= 'A' && digit <= 'D')
2667                 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2668         else if (digit == '*')
2669                 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2670         else if (digit == '#')
2671                 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2672         else {
2673                 /* not handled */
2674                 ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2675         }
2676
2677         return 0;
2678 }
2679
2680 int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
2681 {
2682         int res = -1;
2683
2684         if (chan->tech->send_digit_end)
2685                 res = chan->tech->send_digit_end(chan, digit, duration);
2686
2687         if (res && chan->generator)
2688                 ast_playtones_stop(chan);
2689         
2690         return 0;
2691 }
2692
2693 int ast_senddigit(struct ast_channel *chan, char digit, unsigned int duration)
2694 {
2695         if (chan->tech->send_digit_begin) {
2696                 ast_senddigit_begin(chan, digit);
2697                 ast_safe_sleep(chan, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2698         }
2699         
2700         return ast_senddigit_end(chan, digit, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
2701 }
2702
2703 int ast_prod(struct ast_channel *chan)
2704 {
2705         struct ast_frame a = { AST_FRAME_VOICE };
2706         char nothing[128];
2707
2708         /* Send an empty audio frame to get things moving */
2709         if (chan->_state != AST_STATE_UP) {
2710                 ast_debug(1, "Prodding channel '%s'\n", chan->name);
2711                 a.subclass = chan->rawwriteformat;
2712                 a.data = nothing + AST_FRIENDLY_OFFSET;
2713                 a.src = "ast_prod";
2714                 if (ast_write(chan, &a))
2715                         ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2716         }
2717         return 0;
2718 }
2719
2720 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2721 {
2722         int res;
2723         if (!chan->tech->write_video)
2724                 return 0;
2725         res = ast_write(chan, fr);
2726         if (!res)
2727                 res = 1;
2728         return res;
2729 }
2730
2731 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2732 {
2733         int res = -1;
2734         struct ast_frame *f = NULL, *f2 = NULL;
2735
2736         /* Stop if we're a zombie or need a soft hangup */
2737         ast_channel_lock(chan);
2738         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2739                 goto done;
2740
2741         /* Handle any pending masquerades */
2742         if (chan->masq && ast_do_masquerade(chan)) {
2743                 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2744                 goto done;
2745         }
2746         if (chan->masqr) {
2747                 res = 0;        /* XXX explain, why 0 ? */
2748                 goto done;
2749         }
2750         if (chan->generatordata) {
2751                 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
2752                         ast_deactivate_generator(chan);
2753                 else {
2754                         if (fr->frametype == AST_FRAME_DTMF_END) {
2755                                 /* There is a generator running while we're in the middle of a digit.
2756                                  * It's probably inband DTMF, so go ahead and pass it so it can
2757                                  * stop the generator */
2758                                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2759                                 ast_channel_unlock(chan);
2760                                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
2761                                 ast_channel_lock(chan);
2762                                 CHECK_BLOCKING(chan);
2763                         } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
2764                                 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
2765                                 res = (chan->tech->indicate == NULL) ? 0 :
2766                                         chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2767                         }
2768                         res = 0;        /* XXX explain, why 0 ? */
2769                         goto done;
2770                 }
2771         }
2772         /* High bit prints debugging */
2773         if (chan->fout & DEBUGCHAN_FLAG)
2774                 ast_frame_dump(chan->name, fr, ">>");
2775         CHECK_BLOCKING(chan);
2776         switch (fr->frametype) {
2777         case AST_FRAME_CONTROL:
2778                 res = (chan->tech->indicate == NULL) ? 0 :
2779                         chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2780                 break;
2781         case AST_FRAME_DTMF_BEGIN:
2782                 if (chan->audiohooks) {
2783                         struct ast_frame *old_frame = fr;
2784                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2785                         if (old_frame != fr)
2786                                 f = fr;
2787                 }
2788                 send_dtmf_event(chan, "Sent", fr->subclass, "Yes", "No");
2789                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2790                 ast_channel_unlock(chan);
2791                 res = ast_senddigit_begin(chan, fr->subclass);
2792                 ast_channel_lock(chan);
2793                 CHECK_BLOCKING(chan);
2794                 break;
2795         case AST_FRAME_DTMF_END:
2796                 if (chan->audiohooks) {
2797                         struct ast_frame *old_frame = fr;
2798                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2799                         if (old_frame != fr)
2800                                 f = fr;
2801                 }
2802                 send_dtmf_event(chan, "Sent", fr->subclass, "No", "Yes");
2803                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2804                 ast_channel_unlock(chan);
2805                 res = ast_senddigit_end(chan, fr->subclass, fr->len);
2806                 ast_channel_lock(chan);
2807                 CHECK_BLOCKING(chan);
2808                 break;
2809         case AST_FRAME_TEXT:
2810                 if (fr->subclass == AST_FORMAT_T140) {
2811                         res = (chan->tech->write_text == NULL) ? 0 :
2812                                 chan->tech->write_text(chan, fr);
2813                 } else {
2814                         res = (chan->tech->send_text == NULL) ? 0 :
2815                                 chan->tech->send_text(chan, (char *) fr->data);
2816                 }
2817                 break;
2818         case AST_FRAME_HTML:
2819                 res = (chan->tech->send_html == NULL) ? 0 :
2820                         chan->tech->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen);
2821                 break;
2822         case AST_FRAME_VIDEO:
2823                 /* XXX Handle translation of video codecs one day XXX */
2824                 res = (chan->tech->write_video == NULL) ? 0 :
2825                         chan->tech->write_video(chan, fr);
2826                 break;
2827         case AST_FRAME_MODEM:
2828                 res = (chan->tech->write == NULL) ? 0 :
2829                         chan->tech->write(chan, fr);
2830                 break;
2831         case AST_FRAME_VOICE:
2832                 if (chan->tech->write == NULL)
2833                         break;  /*! \todo XXX should return 0 maybe ? */
2834
2835                 /* If audiohooks are present, write the frame out */
2836                 if (chan->audiohooks) {
2837                         struct ast_frame *old_frame = fr;
2838                         fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2839                         if (old_frame != fr)
2840                                 f2 = fr;
2841                 }
2842
2843                 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
2844                 if (fr->subclass == chan->rawwriteformat)
2845                         f = fr;
2846                 else
2847                         f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
2848
2849                 if (!f) {
2850                         res = 0;
2851                         break;
2852                 }
2853
2854                 /* If Monitor is running on this channel, then we have to write frames out there too */
2855                 if (chan->monitor && chan->monitor->write_stream) {
2856                         /* XXX must explain this code */
2857 #ifndef MONITOR_CONSTANT_DELAY
2858                         int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
2859                         if (jump >= 0) {
2860                                 jump = chan->insmpl - chan->outsmpl;
2861                                 if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
2862                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2863                                 chan->outsmpl += jump + f->samples;
2864                         } else
2865                                 chan->outsmpl += f->samples;
2866 #else
2867                         int jump = chan->insmpl - chan->outsmpl;
2868                         if (jump - MONITOR_DELAY >= 0) {
2869                                 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2870                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2871                                 chan->outsmpl += jump;
2872                         } else
2873                                 chan->outsmpl += f->samples;
2874 #endif
2875                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2876                                 if (ast_writestream(chan->monitor->write_stream, f) < 0)
2877                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
2878                         }
2879                 }
2880
2881                 if (f) {
2882                         struct ast_channel *base = NULL;
2883                         if (!chan->tech->get_base_channel || chan == chan->tech->get_base_channel(chan))
2884                                 res = chan->tech->write(chan, f);
2885                         else {
2886                                 while (chan->tech->get_base_channel && (((base = chan->tech->get_base_channel(chan)) && ast_channel_trylock(base)) || base == NULL)) {
2887                                         ast_channel_unlock(chan);
2888                                         usleep(1);
2889                                         ast_channel_lock(chan);
2890                                 }
2891                                 res = base->tech->write(base, f);
2892                                 ast_channel_unlock(base);
2893                         }
2894                 } else
2895                         res = 0;
2896                 break;
2897         case AST_FRAME_NULL:
2898         case AST_FRAME_IAX:
2899                 /* Ignore these */
2900                 res = 0;
2901                 break;
2902         default:
2903                 /* At this point, fr is the incoming frame and f is NULL.  Channels do
2904                  * not expect to get NULL as a frame pointer and will segfault.  Hence,
2905                  * we output the original frame passed in. */
2906                 res = chan->tech->write(chan, fr);
2907                 break;
2908         }
2909
2910         if (f && f != fr)
2911                 ast_frfree(f);
2912         if (f2)
2913                 ast_frfree(f2);
2914         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2915         /* Consider a write failure to force a soft hangup */
2916         if (res < 0)
2917                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2918         else {
2919                 chan->fout = FRAMECOUNT_INC(chan->fout);
2920         }
2921 done:
2922         ast_channel_unlock(chan);
2923         return res;
2924 }
2925
2926 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
2927                       struct ast_trans_pvt **trans, const int direction)
2928 {
2929         int native;
2930         int res;
2931         
2932         /* Make sure we only consider audio */
2933         fmt &= AST_FORMAT_AUDIO_MASK;
2934         
2935         native = chan->nativeformats;
2936         /* Find a translation path from the native format to one of the desired formats */
2937         if (!direction)
2938                 /* reading */
2939                 res = ast_translator_best_choice(&fmt, &native);
2940         else
2941                 /* writing */
2942                 res = ast_translator_best_choice(&native, &fmt);
2943
2944         if (res < 0) {
2945                 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
2946                         ast_getformatname(native), ast_getformatname(fmt));
2947                 return -1;
2948         }
2949         
2950         /* Now we have a good choice for both. */
2951         ast_channel_lock(chan);
2952
2953         if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
2954                 /* the channel is already in these formats, so nothing to do */
2955                 ast_channel_unlock(chan);
2956                 return 0;
2957         }
2958
2959         *rawformat = native;
2960         /* User perspective is fmt */
2961         *format = fmt;
2962         /* Free any read translation we have right now */
2963         if (*trans)
2964                 ast_translator_free_path(*trans);
2965         /* Build a translation path from the raw format to the desired format */
2966         if (!direction)
2967                 /* reading */
2968                 *trans = ast_translator_build_path(*format, *rawformat);
2969         else
2970                 /* writing */
2971                 *trans = ast_translator_build_path(*rawformat, *format);
2972         ast_channel_unlock(chan);
2973         ast_debug(1, "Set channel %s to %s format %s\n", chan->name,
2974                 direction ? "write" : "read", ast_getformatname(fmt));
2975         return 0;
2976 }
2977
2978 int ast_set_read_format(struct ast_channel *chan, int fmt)
2979 {
2980         return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
2981                           &chan->readtrans, 0);
2982 }
2983
2984 int ast_set_write_format(struct ast_channel *chan, int fmt)
2985 {
2986         return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
2987                           &chan->writetrans, 1);
2988 }
2989
2990 const char *ast_channel_reason2str(int reason)
2991 {
2992         switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */
2993         {
2994         case 0:
2995                 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
2996         case AST_CONTROL_HANGUP:
2997                 return "Hangup";
2998         case AST_CONTROL_RING:
2999                 return "Local Ring";
3000         case AST_CONTROL_RINGING:
3001                 return "Remote end Ringing";
3002         case AST_CONTROL_ANSWER:
3003                 return "Remote end has Answered";
3004         case AST_CONTROL_BUSY:
3005                 return "Remote end is Busy";
3006         case AST_CONTROL_CONGESTION:
3007                 return "Congestion (circuits busy)";
3008         default:
3009                 return "Unknown Reason!!";
3010         }
3011 }
3012
3013 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)
3014 {
3015         int dummy_outstate;
3016         int cause = 0;
3017         struct ast_channel *chan;
3018         int res = 0;
3019         
3020         if (outstate)
3021                 *outstate = 0;
3022         else
3023                 outstate = &dummy_outstate;     /* make outstate always a valid pointer */
3024
3025         chan = ast_request(type, format, data, &cause);
3026         if (!chan) {
3027                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
3028                 /* compute error and return */
3029                 if (cause == AST_CAUSE_BUSY)
3030                         *outstate = AST_CONTROL_BUSY;
3031                 else if (cause == AST_CAUSE_CONGESTION)
3032                         *outstate = AST_CONTROL_CONGESTION;
3033                 return NULL;
3034         }
3035
3036         if (oh) {
3037                 if (oh->vars)   
3038                         ast_set_variables(chan, oh->vars);
3039                 /* XXX why is this necessary, for the parent_channel perhaps ? */
3040                 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
3041                         ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
3042                 if (oh->parent_channel) {
3043                         ast_channel_inherit_variables(oh->parent_channel, chan);
3044                         ast_channel_datastore_inherit(oh->parent_channel, chan);
3045                 }
3046                 if (oh->account)
3047                         ast_cdr_setaccount(chan, oh->account);  
3048         }
3049         ast_set_callerid(chan, cid_num, cid_name, cid_num);
3050
3051         
3052
3053         if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
3054                                 to keep from throwing off the basic order of the universe,
3055                                 we will try to keep this cdr from getting posted. */
3056                 chan->cdr = ast_cdr_alloc();
3057                 ast_cdr_init(chan->cdr, chan);
3058                 ast_cdr_start(chan->cdr);
3059         }
3060         if (ast_call(chan, data, 0)) {  /* ast_call failed... */
3061                 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
3062         } else {
3063                 res = 1;        /* mark success in case chan->_state is already AST_STATE_UP */
3064                 while (timeout && chan->_state != AST_STATE_UP) {
3065                         struct ast_frame *f;
3066                         res = ast_waitfor(chan, timeout);
3067                         if (res <= 0) /* error, timeout, or done */
3068                                 break;
3069                         if (timeout > -1)
3070                                 timeout = res;
3071                         f = ast_read(chan);
3072                         if (!f) {
3073                                 *outstate = AST_CONTROL_HANGUP;
3074                                 res = 0;
3075                                 break;
3076                         }
3077                         if (f->frametype == AST_FRAME_CONTROL) {
3078                                 switch (f->subclass) {
3079                                 case AST_CONTROL_RINGING:       /* record but keep going */
3080                                         *outstate = f->subclass;
3081                                         break;
3082
3083                                 case AST_CONTROL_BUSY:
3084                                 case AST_CONTROL_CONGESTION:
3085                                 case AST_CONTROL_ANSWER:
3086                                         *outstate = f->subclass;
3087                                         timeout = 0;            /* trick to force exit from the while() */
3088                                         break;
3089
3090                                 /* Ignore these */
3091                                 case AST_CONTROL_PROGRESS:
3092                                 case AST_CONTROL_PROCEEDING:
3093                                 case AST_CONTROL_HOLD:
3094                                 case AST_CONTROL_UNHOLD:
3095                                 case AST_CONTROL_VIDUPDATE:
3096                                 case -1:                        /* Ignore -- just stopping indications */
3097                                         break;
3098
3099                                 default:
3100                                         ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
3101                                 }
3102                         }
3103                         ast_frfree(f);
3104                 }
3105         }
3106
3107         /* Final fixups */
3108         if (oh) {
3109                 if (!ast_strlen_zero(oh->context))
3110                         ast_copy_string(chan->context, oh->context, sizeof(chan->context));
3111                 if (!ast_strlen_zero(oh->exten))
3112                         ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
3113                 if (oh->priority)       
3114                         chan->priority = oh->priority;
3115         }
3116         if (chan->_state == AST_STATE_UP)
3117                 *outstate = AST_CONTROL_ANSWER;
3118
3119         if (res <= 0) {
3120                 if (!chan->cdr && (chan->cdr = ast_cdr_alloc()))
3121                         ast_cdr_init(chan->cdr, chan);
3122                 if (chan->cdr) {
3123                         char tmp[256];
3124                         snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data);
3125                         ast_cdr_setapp(chan->cdr,"Dial",tmp);
3126                         ast_cdr_update(chan);
3127                         ast_cdr_start(chan->cdr);
3128                         ast_cdr_end(chan->cdr);
3129                         /* If the cause wasn't handled properly */
3130                         if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
3131                                 ast_cdr_failed(chan->cdr);
3132                 }
3133                 ast_hangup(chan);
3134                 chan = NULL;
3135         }
3136         return chan;
3137 }
3138
3139 struct ast_channel *ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname)
3140 {
3141         return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
3142 }
3143
3144 struct ast_channel *ast_request(const char *type, int format, void *data, int *cause)
3145 {
3146         struct chanlist *chan;
3147         struct ast_channel *c;
3148         int capabilities;
3149         int fmt;
3150         int res;
3151         int foo;
3152         int videoformat = format & AST_FORMAT_VIDEO_MASK;
3153         int textformat = format & AST_FORMAT_TEXT_MASK;
3154
3155         if (!cause)
3156                 cause = &foo;
3157         *cause = AST_CAUSE_NOTDEFINED;
3158
3159         if (AST_RWLIST_RDLOCK(&channels)) {
3160                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
3161                 return NULL;
3162         }
3163
3164         AST_LIST_TRAVERSE(&backends, chan, list) {
3165                 if (strcasecmp(type, chan->tech->type))
3166                         continue;
3167
3168                 capabilities = chan->tech->capabilities;
3169                 fmt = format & AST_FORMAT_AUDIO_MASK;
3170                 res = ast_translator_best_choice(&fmt, &capabilities);
3171                 if (res < 0) {
3172                         ast_log(LOG_WARNING, "No translator path exists for channel type %s (native 0x%x) to 0x%x\n", type, chan->tech->capabilities, format);
3173                         *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
3174                         AST_RWLIST_UNLOCK(&channels);
3175                         return NULL;
3176                 }
3177                 AST_RWLIST_UNLOCK(&channels);
3178                 if (!chan->tech->requester)
3179                         return NULL;
3180                 
3181                 if (!(c = chan->tech->requester(type, capabilities | videoformat | textformat, data, cause)))
3182                         return NULL;
3183                 
3184                 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
3185                 return c;
3186         }
3187
3188         ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
3189         *cause = AST_CAUSE_NOSUCHDRIVER;
3190         AST_RWLIST_UNLOCK(&channels);
3191
3192         return NULL;
3193 }
3194
3195 int ast_call(struct ast_channel *chan, char *addr, int timeout)
3196 {
3197         /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
3198            If the remote end does not answer within the timeout, then do NOT hang up, but
3199            return anyway.  */
3200         int res = -1;
3201         /* Stop if we're a zombie or need a soft hangup */
3202         ast_channel_lock(chan);
3203         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
3204                 if (chan->tech->call)
3205                         res = chan->tech->call(chan, addr, timeout);
3206                 ast_set_flag(chan, AST_FLAG_OUTGOING);
3207         }
3208         ast_channel_unlock(chan);
3209         return res;
3210 }
3211
3212 /*!
3213   \brief Transfer a call to dest, if the channel supports transfer
3214
3215   Called by:
3216     \arg app_transfer
3217     \arg the manager interface
3218 */
3219 int ast_transfer(struct ast_channel *chan, char *dest)
3220 {
3221         int res = -1;
3222
3223         /* Stop if we're a zombie or need a soft hangup */
3224         ast_channel_lock(chan);
3225         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
3226                 if (chan->tech->transfer) {
3227                         res = chan->tech->transfer(chan, dest);
3228                         if (!res)
3229                                 res = 1;
3230                 } else
3231                         res = 0;
3232         }
3233         ast_channel_unlock(chan);
3234         return res;
3235 }
3236
3237 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
3238 {
3239         return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
3240 }
3241
3242 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
3243 {
3244         int pos = 0;    /* index in the buffer where we accumulate digits */
3245         int to = ftimeout;
3246
3247         /* Stop if we're a zombie or need a soft hangup */
3248         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
3249                 return -1;
3250         if (!len)
3251                 return -1;
3252         for (;;) {
3253                 int d;
3254                 if (c->stream) {
3255                         d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
3256                         ast_stopstream(c);
3257                         usleep(1000);
3258                         if (!d)
3259                                 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
3260                 } else {
3261                         d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
3262                 }
3263                 if (d < 0)
3264                         return -1;
3265                 if (d == 0) {
3266                         s[pos]='\0';
3267                         return 1;
3268                 }
3269                 if (d == 1) {
3270                         s[pos]='\0';
3271                         return 2;
3272                 }
3273                 if (!strchr(enders, d))
3274                         s[pos++] = d;
3275                 if (strchr(enders, d) || (pos >= len)) {
3276                         s[pos]='\0';
3277                         return 0;
3278                 }
3279                 to = timeout;
3280         }
3281         /* Never reached */
3282         return 0;
3283 }
3284
3285 int ast_channel_supports_html(struct ast_channel *chan)
3286 {
3287         return (chan->tech->send_html) ? 1 : 0;
3288 }
3289
3290 int ast_channel_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen)
3291 {
3292         if (chan->tech->send_html)
3293                 return chan->tech->send_html(chan, subclass, data, datalen);
3294         return -1;
3295 }
3296
3297 int ast_channel_sendurl(struct ast_channel *chan, const char *url)
3298 {
3299         return ast_channel_sendhtml(chan, AST_HTML_URL, url, strlen(url) + 1);
3300 }
3301
3302 /*! \brief Set up translation from one channel to another */
3303 static int ast_channel_make_compatible_helper(struct ast_channel *from, struct ast_channel *to)
3304 {
3305         int src;
3306         int dst;
3307
3308         if (from->readformat == to->writeformat && from->writeformat == to->readformat) {
3309                 /* Already compatible!  Moving on ... */
3310                 return 0;
3311         }
3312
3313         /* Set up translation from the 'from' channel to the 'to' channel */
3314         src = from->nativeformats;
3315         dst = to->nativeformats;
3316         if (ast_translator_best_choice(&dst, &src) < 0) {
3317                 ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", from->name, src, to->name, dst);
3318                 return -1;
3319         }
3320
3321         /* if the best path is not 'pass through', then
3322            transcoding is needed; if desired, force transcode path
3323            to use SLINEAR between channels, but only if there is
3324            no direct conversion available */
3325         if ((src != dst) && ast_opt_transcode_via_slin &&
3326             (ast_translate_path_steps(dst, src) != 1))
3327                 dst = AST_FORMAT_SLINEAR;
3328         if (ast_set_read_format(from, dst) < 0) {
3329                 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", from->name, dst);
3330                 return -1;
3331         }
3332         if (ast_set_write_format(to, dst) < 0) {
3333                 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", to->name, dst);
3334                 return -1;
3335         }
3336         return 0;
3337 }
3338
3339 int ast_channel_make_compatible(struct ast_channel *chan, struct ast_channel *peer)
3340 {
3341         /* Some callers do not check return code, and we must try to set all call legs correctly */
3342         int rc = 0;
3343
3344         /* Set up translation from the chan to the peer */
3345         rc = ast_channel_make_compatible_helper(chan, peer);
3346
3347         if (rc < 0)
3348                 return rc;
3349
3350         /* Set up translation from the peer to the chan */
3351         rc = ast_channel_make_compatible_helper(peer, chan);
3352
3353         return rc;
3354 }
3355
3356 int ast_channel_masquerade(struct ast_channel *original, struct ast_channel *clone)
3357 {
3358         int res = -1;
3359         struct ast_channel *final_orig, *final_clone, *base;
3360
3361 retrymasq:
3362         final_orig = original;
3363         final_clone = clone;
3364
3365         ast_channel_lock(original);
3366         while (ast_channel_trylock(clone)) {
3367                 ast_channel_unlock(original);
3368                 usleep(1);
3369                 ast_channel_lock(original);
3370         }
3371
3372         /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent)
3373            and if so, we don't really want to masquerade it, but its proxy */
3374         if (original->_bridge && (original->_bridge != ast_bridged_channel(original)) && (original->_bridge->_bridge != original))
3375                 final_orig = original->_bridge;
3376
3377         if (clone->_bridge && (clone->_bridge != ast_bridged_channel(clone)) && (clone->_bridge->_bridge != clone))
3378                 final_clone = clone->_bridge;
3379         
3380         if (final_clone->tech->get_base_channel && (base = final_clone->tech->get_base_channel(final_clone))) {
3381                 final_clone = base;
3382         }
3383
3384         if ((final_orig != original) || (final_clone != clone)) {
3385                 /* Lots and lots of deadlock avoidance.  The main one we're competing with
3386                  * is ast_write(), which locks channels recursively, when working with a
3387                  * proxy channel. */
3388                 if (ast_channel_trylock(final_orig)) {
3389                         ast_channel_unlock(clone);
3390                         ast_channel_unlock(original);
3391                         goto retrymasq;
3392                 }
3393                 if (ast_channel_trylock(final_clone)) {
3394                         ast_channel_unlock(final_orig);
3395                         ast_channel_unlock(clone);
3396                         ast_channel_unlock(original);
3397                         goto retrymasq;
3398                 }
3399                 ast_channel_unlock(clone);
3400                 ast_channel_unlock(original);
3401                 original = final_orig;
3402                 clone = final_clone;
3403         }
3404
3405         if (original == clone) {
3406                 ast_log(LOG_WARNING, "Can't masquerade channel '%s' into itself!\n", original->name);
3407                 ast_channel_unlock(clone);
3408                 ast_channel_unlock(original);
3409                 return -1;
3410         }
3411
3412         ast_debug(1, "Planning to masquerade channel %s into the structure of %s\n",
3413                 clone->name, original->name);
3414         if (original->masq) {
3415                 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
3416                         original->masq->name, original->name);
3417         } else if (clone->masqr) {
3418                 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
3419                         clone->name, clone->masqr->name);
3420         } else {
3421                 original->masq = clone;
3422                 clone->masqr = original;
3423                 ast_queue_frame(original, &ast_null_frame);
3424                 ast_queue_frame(clone, &ast_null_frame);
3425                 ast_debug(1, "Done planning to masquerade channel %s into the structure of %s\n", clone->name, original->name);
3426                 res = 0;
3427         }
3428
3429         ast_channel_unlock(clone);
3430         ast_channel_unlock(original);
3431
3432         return res;
3433 }
3434
3435 void ast_change_name(struct ast_channel *chan, char *newname)
3436 {
3437         manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan->name, newname, chan->uniqueid);
3438         ast_string_field_set(chan, name, newname);
3439 }
3440
3441 void ast_channel_inherit_variables(const struct ast_channel *parent, struct ast_channel *child)
3442 {
3443         struct ast_var_t *current, *newvar;
3444         const char *varname;
3445
3446         AST_LIST_TRAVERSE(&parent->varshead, current, entries) {
3447                 int vartype = 0;
3448
3449                 varname = ast_var_full_name(current);
3450                 if (!varname)
3451                         continue;
3452
3453                 if (varname[0] == '_') {
3454                         vartype = 1;
3455                         if (varname[1] == '_')
3456                                 vartype = 2;
3457                 }
3458
3459                 switch (vartype) {
3460                 case 1:
3461                         newvar = ast_var_assign(&varname[1], ast_var_value(current));
3462                         if (newvar) {
3463                                 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
3464                                 ast_debug(1, "Copying soft-transferable variable %s.\n", ast_var_name(newvar));
3465                         }
3466                         break;
3467                 case 2:
3468                         newvar = ast_var_assign(ast_var_full_name(current), ast_var_value(current));
3469                         if (newvar) {
3470                                 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
3471                                 ast_debug(1, "Copying hard-transferable variable %s.\n", ast_var_name(newvar));
3472                         }
3473                         break;
3474                 default:
3475                         ast_debug(1, "Not copying variable %s.\n", ast_var_name(current));
3476                         break;
3477                 }
3478         }
3479 }
3480
3481 /*!
3482   \brief Clone channel variables from 'clone' channel into 'original' channel
3483
3484   All variables except those related to app_groupcount are cloned.
3485   Variables are actually _removed_ from 'clone' channel, presumably
3486   because it will subsequently be destroyed.
3487
3488   \note Assumes locks will be in place on both channels when called.
3489 */
3490 static void clone_variables(struct ast_channel *original, struct ast_channel *clone)
3491 {
3492         struct ast_var_t *current, *newvar;
3493         /* Append variables from clone channel into original channel */
3494         /* XXX Is this always correct?  We have to in order to keep MACROS working XXX */
3495         if (AST_LIST_FIRST(&clone->varshead))
3496                 AST_LIST_APPEND_LIST(&original->varshead, &clone->varshead, entries);
3497
3498         /* then, dup the varshead list into the clone */
3499         
3500         AST_LIST_TRAVERSE(&original->varshead, current, entries) {
3501                 newvar = ast_var_assign(current->name, current->value);
3502                 if (newvar)
3503                         AST_LIST_INSERT_TAIL(&clone->varshead, newvar, entries);
3504         }
3505 }
3506
3507 /*!
3508   \brief Masquerade a channel
3509
3510   \note Assumes channel will be locked when called
3511 */
3512 int ast_do_masquerade(struct ast_channel *original)
3513 {
3514         int x,i;
3515         int res=0;
3516         int origstate;
3517         struct ast_frame *cur;
3518         const struct ast_channel_tech *t;
3519         void *t_pvt;
3520         struct ast_callerid tmpcid;
3521         struct ast_channel *clone = original->masq;
3522         struct ast_cdr *cdr;
3523         int rformat = original->readformat;
3524         int wformat = original->writeformat;
3525         char newn[100];
3526         char orig[100];
3527         char masqn[100];
3528         char zombn[100];
3529
3530         ast_debug(4, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
3531                 clone->name, clone->_state, original->name, original->_state);
3532
3533         manager_event(EVENT_FLAG_CALL, "Masquerade", "Clone: %s\r\nCloneState: %s\r\nOriginal: %s\r\nOriginalState: %s\r\n",
3534                       clone->name, ast_state2str(clone->_state), original->name, ast_state2str(original->_state));
3535