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