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