Don't hold channel lock while sleeping/waiting for audio stream to get setup. (issue...
[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                 ast_channel_unlock(chan);
1641                 if (delay)
1642                         ast_safe_sleep(chan, delay);
1643                 return res;
1644                 break;
1645         case AST_STATE_UP:
1646                 ast_cdr_answer(chan->cdr);
1647                 break;
1648         default:
1649                 break;
1650         }
1651
1652         ast_channel_unlock(chan);
1653
1654         return res;
1655 }
1656
1657 int ast_answer(struct ast_channel *chan)
1658 {
1659         return __ast_answer(chan, 500);
1660 }
1661
1662 void ast_deactivate_generator(struct ast_channel *chan)
1663 {
1664         ast_channel_lock(chan);
1665         if (chan->generatordata) {
1666                 if (chan->generator && chan->generator->release)
1667                         chan->generator->release(chan, chan->generatordata);
1668                 chan->generatordata = NULL;
1669                 chan->generator = NULL;
1670                 chan->fds[AST_GENERATOR_FD] = -1;
1671                 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1672                 ast_settimeout(chan, 0, NULL, NULL);
1673         }
1674         ast_channel_unlock(chan);
1675 }
1676
1677 static int generator_force(void *data)
1678 {
1679         /* Called if generator doesn't have data */
1680         void *tmp;
1681         int res;
1682         int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
1683         struct ast_channel *chan = data;
1684         tmp = chan->generatordata;
1685         chan->generatordata = NULL;
1686         generate = chan->generator->generate;
1687         res = generate(chan, tmp, 0, 160);
1688         chan->generatordata = tmp;
1689         if (res) {
1690                 if (option_debug)
1691                         ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
1692                 ast_deactivate_generator(chan);
1693         }
1694         return 0;
1695 }
1696
1697 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1698 {
1699         int res = 0;
1700
1701         ast_channel_lock(chan);
1702
1703         if (chan->generatordata) {
1704                 if (chan->generator && chan->generator->release)
1705                         chan->generator->release(chan, chan->generatordata);
1706                 chan->generatordata = NULL;
1707         }
1708
1709         ast_prod(chan);
1710         if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1711                 res = -1;
1712         }
1713         
1714         if (!res) {
1715                 ast_settimeout(chan, 160, generator_force, chan);
1716                 chan->generator = gen;
1717         }
1718
1719         ast_channel_unlock(chan);
1720
1721         return res;
1722 }
1723
1724 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1725 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1726 {
1727         int winner = -1;
1728         ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1729         return winner;
1730 }
1731
1732 /*! \brief Wait for x amount of time on a file descriptor to have input.  */
1733 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1734         int *exception, int *outfd, int *ms)
1735 {
1736         struct timeval start = { 0 , 0 };
1737         struct pollfd *pfds;
1738         int res;
1739         long rms;
1740         int x, y, max;
1741         int sz;
1742         time_t now = 0;
1743         long whentohangup = 0, diff;
1744         struct ast_channel *winner = NULL;
1745         struct fdmap {
1746                 int chan;
1747                 int fdno;
1748         } *fdmap;
1749
1750         sz = n * AST_MAX_FDS + nfds;
1751         pfds = alloca(sizeof(*pfds) * sz);
1752         fdmap = alloca(sizeof(*fdmap) * sz);
1753
1754         if (outfd)
1755                 *outfd = -99999;
1756         if (exception)
1757                 *exception = 0;
1758         
1759         /* Perform any pending masquerades */
1760         for (x=0; x < n; x++) {
1761                 ast_channel_lock(c[x]);
1762                 if (c[x]->masq) {
1763                         if (ast_do_masquerade(c[x])) {
1764                                 ast_log(LOG_WARNING, "Masquerade failed\n");
1765                                 *ms = -1;
1766                                 ast_channel_unlock(c[x]);
1767                                 return NULL;
1768                         }
1769                 }
1770                 if (c[x]->whentohangup) {
1771                         if (!whentohangup)
1772                                 time(&now);
1773                         diff = c[x]->whentohangup - now;
1774                         if (diff < 1) {
1775                                 /* Should already be hungup */
1776                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1777                                 ast_channel_unlock(c[x]);
1778                                 return c[x];
1779                         }
1780                         if (!whentohangup || (diff < whentohangup))
1781                                 whentohangup = diff;
1782                 }
1783                 ast_channel_unlock(c[x]);
1784         }
1785         /* Wait full interval */
1786         rms = *ms;
1787         if (whentohangup) {
1788                 rms = whentohangup * 1000;              /* timeout in milliseconds */
1789                 if (*ms >= 0 && *ms < rms)              /* original *ms still smaller */
1790                         rms =  *ms;
1791         }
1792         /*
1793          * Build the pollfd array, putting the channels' fds first,
1794          * followed by individual fds. Order is important because
1795          * individual fd's must have priority over channel fds.
1796          */
1797         max = 0;
1798         for (x=0; x<n; x++) {
1799                 for (y=0; y<AST_MAX_FDS; y++) {
1800                         fdmap[max].fdno = y;  /* fd y is linked to this pfds */
1801                         fdmap[max].chan = x;  /* channel x is linked to this pfds */
1802                         max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1803                 }
1804                 CHECK_BLOCKING(c[x]);
1805         }
1806         /* Add the individual fds */
1807         for (x=0; x<nfds; x++) {
1808                 fdmap[max].chan = -1;
1809                 max += ast_add_fd(&pfds[max], fds[x]);
1810         }
1811
1812         if (*ms > 0)
1813                 start = ast_tvnow();
1814         
1815         if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1816                 do {
1817                         int kbrms = rms;
1818                         if (kbrms > 600000)
1819                                 kbrms = 600000;
1820                         res = poll(pfds, max, kbrms);
1821                         if (!res)
1822                                 rms -= kbrms;
1823                 } while (!res && (rms > 0));
1824         } else {
1825                 res = poll(pfds, max, rms);
1826         }
1827         for (x=0; x<n; x++)
1828                 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1829         if (res < 0) { /* Simulate a timeout if we were interrupted */
1830                 if (errno != EINTR)
1831                         *ms = -1;
1832                 return NULL;
1833         }
1834         if (whentohangup) {   /* if we have a timeout, check who expired */
1835                 time(&now);
1836                 for (x=0; x<n; x++) {
1837                         if (c[x]->whentohangup && now >= c[x]->whentohangup) {
1838                                 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1839                                 if (winner == NULL)
1840                                         winner = c[x];
1841                         }
1842                 }
1843         }
1844         if (res == 0) { /* no fd ready, reset timeout and done */
1845                 *ms = 0;        /* XXX use 0 since we may not have an exact timeout. */
1846                 return winner;
1847         }
1848         /*
1849          * Then check if any channel or fd has a pending event.
1850          * Remember to check channels first and fds last, as they
1851          * must have priority on setting 'winner'
1852          */
1853         for (x = 0; x < max; x++) {
1854                 res = pfds[x].revents;
1855                 if (res == 0)
1856                         continue;
1857                 if (fdmap[x].chan >= 0) {       /* this is a channel */
1858                         winner = c[fdmap[x].chan];      /* override previous winners */
1859                         if (res & POLLPRI)
1860                                 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1861                         else
1862                                 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1863                         winner->fdno = fdmap[x].fdno;
1864                 } else {                        /* this is an fd */
1865                         if (outfd)
1866                                 *outfd = pfds[x].fd;
1867                         if (exception)
1868                                 *exception = (res & POLLPRI) ? -1 : 0;
1869                         winner = NULL;
1870                 }
1871         }
1872         if (*ms > 0) {
1873                 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1874                 if (*ms < 0)
1875                         *ms = 0;
1876         }
1877         return winner;
1878 }
1879
1880 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
1881 {
1882         return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
1883 }
1884
1885 int ast_waitfor(struct ast_channel *c, int ms)
1886 {
1887         int oldms = ms; /* -1 if no timeout */
1888
1889         ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
1890         if ((ms < 0) && (oldms < 0))
1891                 ms = 0;
1892         return ms;
1893 }
1894
1895 /* XXX never to be called with ms = -1 */
1896 int ast_waitfordigit(struct ast_channel *c, int ms)
1897 {
1898         return ast_waitfordigit_full(c, ms, -1, -1);
1899 }
1900
1901 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(void *data), void *data)
1902 {
1903         int res = -1;
1904 #ifdef HAVE_ZAPTEL
1905         if (c->timingfd > -1) {
1906                 if (!func) {
1907                         samples = 0;
1908                         data = 0;
1909                 }
1910                 if (option_debug)
1911                         ast_log(LOG_DEBUG, "Scheduling timer at %d sample intervals\n", samples);
1912                 res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
1913                 c->timingfunc = func;
1914                 c->timingdata = data;
1915         }
1916 #endif  
1917         return res;
1918 }
1919
1920 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
1921 {
1922
1923         /* Stop if we're a zombie or need a soft hangup */
1924         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
1925                 return -1;
1926         /* Wait for a digit, no more than ms milliseconds total. */
1927         while (ms) {
1928                 struct ast_channel *rchan;
1929                 int outfd;
1930
1931                 errno = 0;
1932                 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
1933                 if (!rchan && outfd < 0 && ms) {
1934                         if (errno == 0 || errno == EINTR)
1935                                 continue;
1936                         ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
1937                         return -1;
1938                 } else if (outfd > -1) {
1939                         /* The FD we were watching has something waiting */
1940                         return 1;
1941                 } else if (rchan) {
1942                         int res;
1943                         struct ast_frame *f = ast_read(c);
1944                         if (!f)
1945                                 return -1;
1946
1947                         switch(f->frametype) {
1948                         case AST_FRAME_DTMF:
1949                                 res = f->subclass;
1950                                 ast_frfree(f);
1951                                 return res;
1952                         case AST_FRAME_CONTROL:
1953                                 switch(f->subclass) {
1954                                 case AST_CONTROL_HANGUP:
1955                                         ast_frfree(f);
1956                                         return -1;
1957                                 case AST_CONTROL_RINGING:
1958                                 case AST_CONTROL_ANSWER:
1959                                         /* Unimportant */
1960                                         break;
1961                                 default:
1962                                         ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
1963                                         break;
1964                                 }
1965                                 break;
1966                         case AST_FRAME_VOICE:
1967                                 /* Write audio if appropriate */
1968                                 if (audiofd > -1)
1969                                         write(audiofd, f->data, f->datalen);
1970                         default:
1971                                 /* Ignore */
1972                                 break;
1973                         }
1974                         ast_frfree(f);
1975                 }
1976         }
1977         return 0; /* Time is up */
1978 }
1979
1980 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
1981 {
1982         struct ast_frame *f = NULL;     /* the return value */
1983         int blah;
1984         int prestate;
1985
1986         /* this function is very long so make sure there is only one return
1987          * point at the end (there is only one exception to this).
1988          */
1989         ast_channel_lock(chan);
1990         if (chan->masq) {
1991                 if (ast_do_masquerade(chan))
1992                         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1993                 else
1994                         f =  &ast_null_frame;
1995                 goto done;
1996         }
1997
1998         /* Stop if we're a zombie or need a soft hangup */
1999         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2000                 if (chan->generator)
2001                         ast_deactivate_generator(chan);
2002                 goto done;
2003         }
2004         prestate = chan->_state;
2005
2006         if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) && 
2007             !ast_strlen_zero(chan->dtmfq)) {
2008                 /* We have DTMF that has been deferred.  Return it now */
2009                 chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
2010                 chan->dtmff.subclass = chan->dtmfq[0];
2011                 /* Drop first digit from the buffer */
2012                 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
2013                 f = &chan->dtmff;
2014                 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2015                 chan->emulate_dtmf_digit = f->subclass;
2016                 chan->emulate_dtmf_samples = AST_DEFAULT_EMULATE_DTMF_SAMPLES;
2017                 goto done;
2018         }
2019         
2020         /* Read and ignore anything on the alertpipe, but read only
2021            one sizeof(blah) per frame that we send from it */
2022         if (chan->alertpipe[0] > -1)
2023                 read(chan->alertpipe[0], &blah, sizeof(blah));
2024
2025 #ifdef HAVE_ZAPTEL
2026         if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2027                 int res;
2028
2029                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2030                 blah = -1;
2031                 /* IF we can't get event, assume it's an expired as-per the old interface */
2032                 res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
2033                 if (res)
2034                         blah = ZT_EVENT_TIMER_EXPIRED;
2035
2036                 if (blah == ZT_EVENT_TIMER_PING) {
2037                         if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
2038                                 /* Acknowledge PONG unless we need it again */
2039                                 if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
2040                                         ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
2041                                 }
2042                         }
2043                 } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
2044                         ioctl(chan->timingfd, ZT_TIMERACK, &blah);
2045                         if (chan->timingfunc) {
2046                                 /* save a copy of func/data before unlocking the channel */
2047                                 int (*func)(void *) = chan->timingfunc;
2048                                 void *data = chan->timingdata;
2049                                 ast_channel_unlock(chan);
2050                                 func(data);
2051                         } else {
2052                                 blah = 0;
2053                                 ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
2054                                 chan->timingdata = NULL;
2055                                 ast_channel_unlock(chan);
2056                         }
2057                         /* cannot 'goto done' because the channel is already unlocked */
2058                         return &ast_null_frame;
2059                 } else
2060                         ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
2061         } else
2062 #endif
2063         if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
2064                 /* if the AST_GENERATOR_FD is set, call the generator with args
2065                  * set to -1 so it can do whatever it needs to.
2066                  */
2067                 void *tmp = chan->generatordata;
2068                 chan->generatordata = NULL;     /* reset to let ast_write get through */
2069                 chan->generator->generate(chan, tmp, -1, -1);
2070                 chan->generatordata = tmp;
2071                 f = &ast_null_frame;
2072                 goto done;
2073         }
2074
2075         /* Check for pending read queue */
2076         if (!AST_LIST_EMPTY(&chan->readq)) {
2077                 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
2078                 /* Interpret hangup and return NULL */
2079                 /* XXX why not the same for frames from the channel ? */
2080                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
2081                         ast_frfree(f);
2082                         f = NULL;
2083                 }
2084         } else {
2085                 chan->blocker = pthread_self();
2086                 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2087                         if (chan->tech->exception)
2088                                 f = chan->tech->exception(chan);
2089                         else {
2090                                 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
2091                                 f = &ast_null_frame;
2092                         }
2093                         /* Clear the exception flag */
2094                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2095                 } else if (chan->tech->read)
2096                         f = chan->tech->read(chan);
2097                 else
2098                         ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
2099         }
2100
2101         if (f) {
2102                 /* if the channel driver returned more than one frame, stuff the excess
2103                    into the readq for the next ast_read call (note that we can safely assume
2104                    that the readq is empty, because otherwise we would not have called into
2105                    the channel driver and f would be only a single frame)
2106                 */
2107                 if (AST_LIST_NEXT(f, frame_list)) {
2108                         AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
2109                         AST_LIST_NEXT(f, frame_list) = NULL;
2110                 }
2111
2112                 switch (f->frametype) {
2113                 case AST_FRAME_CONTROL:
2114                         if (f->subclass == AST_CONTROL_ANSWER) {
2115                                 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
2116                                         if (option_debug)
2117                                                 ast_log(LOG_DEBUG, "Ignoring answer on an inbound call!\n");
2118                                         ast_frfree(f);
2119                                         f = &ast_null_frame;
2120                                 } else if (prestate == AST_STATE_UP) {
2121                                         if (option_debug)
2122                                                 ast_log(LOG_DEBUG, "Dropping duplicate answer!\n");
2123                                         ast_frfree(f);
2124                                         f = &ast_null_frame;
2125                                 } else {
2126                                         /* Answer the CDR */
2127                                         ast_setstate(chan, AST_STATE_UP);
2128                                         ast_cdr_answer(chan->cdr);
2129                                 }
2130                         }
2131                         break;
2132                 case AST_FRAME_DTMF_END:
2133                         ast_log(LOG_DTMF, "DTMF end '%c' received on %s\n", f->subclass, chan->name);
2134                         if (ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF)) {
2135                                 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2)
2136                                         chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2137                                 else
2138                                         ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2139                                 ast_frfree(f);
2140                                 f = &ast_null_frame;
2141                         } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2142                                 f->frametype = AST_FRAME_DTMF_BEGIN;
2143                                 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2144                                 chan->emulate_dtmf_digit = f->subclass;
2145                                 if (f->samples)
2146                                         chan->emulate_dtmf_samples = f->samples;
2147                                 else
2148                                         chan->emulate_dtmf_samples = AST_DEFAULT_EMULATE_DTMF_SAMPLES;
2149                         } else 
2150                                 ast_clear_flag(chan, AST_FLAG_IN_DTMF);
2151                         break;
2152                 case AST_FRAME_DTMF_BEGIN:
2153                         ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2154                         if (ast_test_flag(chan, AST_FLAG_DEFER_DTMF)) {
2155                                 ast_frfree(f);
2156                                 f = &ast_null_frame;
2157                         } else 
2158                                 ast_set_flag(chan, AST_FLAG_IN_DTMF);
2159                         break;
2160                 case AST_FRAME_VOICE:
2161                         /* The EMULATE_DTMF flag must be cleared here as opposed to when the samples
2162                          * first get to zero, because we want to make sure we pass at least one
2163                          * voice frame through before starting the next digit, to ensure a gap
2164                          * between DTMF digits. */
2165                         if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_samples) {
2166                                 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2167                                 chan->emulate_dtmf_digit = 0;
2168                         }
2169
2170                         if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2171                                 ast_frfree(f);
2172                                 f = &ast_null_frame;
2173                         } else if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2174                                 if (f->samples >= chan->emulate_dtmf_samples) {
2175                                         chan->emulate_dtmf_samples = 0;
2176                                         f->frametype = AST_FRAME_DTMF_END;
2177                                         f->subclass = chan->emulate_dtmf_digit;
2178                                 } else {
2179                                         chan->emulate_dtmf_samples -= f->samples;
2180                                         ast_frfree(f);
2181                                         f = &ast_null_frame;
2182                                 }
2183                         } else if (!(f->subclass & chan->nativeformats)) {
2184                                 /* This frame can't be from the current native formats -- drop it on the
2185                                    floor */
2186                                 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2187                                         chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
2188                                 ast_frfree(f);
2189                                 f = &ast_null_frame;
2190                         } else {
2191                                 if (chan->spies)
2192                                         queue_frame_to_spies(chan, f, SPY_READ);
2193                                 
2194                                 if (chan->monitor && chan->monitor->read_stream ) {
2195                                         /* XXX what does this do ? */
2196 #ifndef MONITOR_CONSTANT_DELAY
2197                                         int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2198                                         if (jump >= 0) {
2199                                                 if (ast_seekstream(chan->monitor->read_stream, jump + f->samples, SEEK_FORCECUR) == -1)
2200                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2201                                                 chan->insmpl += jump + 4 * f->samples;
2202                                         } else
2203                                                 chan->insmpl+= f->samples;
2204 #else
2205                                         int jump = chan->outsmpl - chan->insmpl;
2206                                         if (jump - MONITOR_DELAY >= 0) {
2207                                                 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2208                                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2209                                                 chan->insmpl += jump;
2210                                         } else
2211                                                 chan->insmpl += f->samples;
2212 #endif
2213                                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2214                                                 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2215                                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2216                                         }
2217                                 }
2218
2219                                 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
2220                                         f = &ast_null_frame;
2221
2222                                 /* Run generator sitting on the line if timing device not available
2223                                 * and synchronous generation of outgoing frames is necessary       */
2224                                 if (chan->generatordata &&  !ast_internal_timing_enabled(chan)) {
2225                                         void *tmp = chan->generatordata;
2226                                         int res;
2227
2228                                         if (chan->timingfunc) {
2229                                                 if (option_debug > 1)
2230                                                         ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n");
2231                                                 ast_settimeout(chan, 0, NULL, NULL);
2232                                         }
2233
2234                                         chan->generatordata = NULL;     /* reset, to let writes go through */
2235                                         res = chan->generator->generate(chan, tmp, f->datalen, f->samples);
2236                                         chan->generatordata = tmp;
2237                                         if (res) {
2238                                                 if (option_debug > 1)
2239                                                         ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
2240                                                 ast_deactivate_generator(chan);
2241                                         }
2242
2243                                 } else if (f->frametype == AST_FRAME_CNG) {
2244                                         if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
2245                                                 if (option_debug > 1)
2246                                                         ast_log(LOG_DEBUG, "Generator got CNG, switching to timed mode\n");
2247                                                 ast_settimeout(chan, 160, generator_force, chan);
2248                                         }
2249                                 }
2250                         }
2251                 default:
2252                         /* Just pass it on! */
2253                         break;
2254                 }
2255         } else {
2256                 /* Make sure we always return NULL in the future */
2257                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2258                 if (chan->generator)
2259                         ast_deactivate_generator(chan);
2260                 /* End the CDR if appropriate */
2261                 if (chan->cdr)
2262                         ast_cdr_end(chan->cdr);
2263         }
2264
2265         /* High bit prints debugging */
2266         if (chan->fin & DEBUGCHAN_FLAG)
2267                 ast_frame_dump(chan->name, f, "<<");
2268         chan->fin = FRAMECOUNT_INC(chan->fin);
2269
2270 done:
2271         ast_channel_unlock(chan);
2272         return f;
2273 }
2274
2275 int ast_internal_timing_enabled(struct ast_channel *chan)
2276 {
2277         int ret = ast_opt_internal_timing && chan->timingfd > -1;
2278         if (option_debug > 4)
2279                 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);
2280         return ret;
2281 }
2282
2283 struct ast_frame *ast_read(struct ast_channel *chan)
2284 {
2285         return __ast_read(chan, 0);
2286 }
2287
2288 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2289 {
2290         return __ast_read(chan, 1);
2291 }
2292
2293 int ast_indicate(struct ast_channel *chan, int condition)
2294 {
2295         return ast_indicate_data(chan, condition, NULL, 0);
2296 }
2297
2298 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
2299 {
2300         int res = -1;
2301
2302         ast_channel_lock(chan);
2303         /* Stop if we're a zombie or need a soft hangup */
2304         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2305                 ast_channel_unlock(chan);
2306                 return -1;
2307         }
2308         if (chan->tech->indicate)
2309                 res = chan->tech->indicate(chan, condition, data, datalen);
2310         ast_channel_unlock(chan);
2311         if (!chan->tech->indicate || res) {
2312                 /*
2313                  * Device does not support (that) indication, lets fake
2314                  * it by doing our own tone generation. (PM2002)
2315                  */
2316                 if (condition < 0)
2317                         ast_playtones_stop(chan);
2318                 else {
2319                         const struct ind_tone_zone_sound *ts = NULL;
2320                         switch (condition) {
2321                         case AST_CONTROL_RINGING:
2322                                 ts = ast_get_indication_tone(chan->zone, "ring");
2323                                 break;
2324                         case AST_CONTROL_BUSY:
2325                                 ts = ast_get_indication_tone(chan->zone, "busy");
2326                                 break;
2327                         case AST_CONTROL_CONGESTION:
2328                                 ts = ast_get_indication_tone(chan->zone, "congestion");
2329                                 break;
2330                         }
2331                         if (ts && ts->data[0]) {
2332                                 if (option_debug)
2333                                         ast_log(LOG_DEBUG, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2334                                 ast_playtones_start(chan,0,ts->data, 1);
2335                                 res = 0;
2336                         } else if (condition == AST_CONTROL_PROGRESS) {
2337                                 /* ast_playtones_stop(chan); */
2338                         } else if (condition == AST_CONTROL_PROCEEDING) {
2339                                 /* Do nothing, really */
2340                         } else if (condition == AST_CONTROL_HOLD) {
2341                                 /* Do nothing.... */
2342                         } else if (condition == AST_CONTROL_UNHOLD) {
2343                                 /* Do nothing.... */
2344                         } else if (condition == AST_CONTROL_VIDUPDATE) {
2345                                 /* Do nothing.... */
2346                         } else {
2347                                 /* not handled */
2348                                 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2349                                 res = -1;
2350                         }
2351                 }
2352         }
2353         return res;
2354 }
2355
2356 int ast_recvchar(struct ast_channel *chan, int timeout)
2357 {
2358         int c;
2359         char *buf = ast_recvtext(chan, timeout);
2360         if (buf == NULL)
2361                 return -1;      /* error or timeout */
2362         c = *(unsigned char *)buf;
2363         free(buf);
2364         return c;
2365 }
2366
2367 char *ast_recvtext(struct ast_channel *chan, int timeout)
2368 {
2369         int res, done = 0;
2370         char *buf = NULL;
2371         
2372         while (!done) {
2373                 struct ast_frame *f;
2374                 if (ast_check_hangup(chan))
2375                         break;
2376                 res = ast_waitfor(chan, timeout);
2377                 if (res <= 0) /* timeout or error */
2378                         break;
2379                 timeout = res;  /* update timeout */
2380                 f = ast_read(chan);
2381                 if (f == NULL)
2382                         break; /* no frame */
2383                 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2384                         done = 1;       /* force a break */
2385                 else if (f->frametype == AST_FRAME_TEXT) {              /* what we want */
2386                         buf = ast_strndup((char *) f->data, f->datalen);        /* dup and break */
2387                         done = 1;
2388                 }
2389                 ast_frfree(f);
2390         }
2391         return buf;
2392 }
2393
2394 int ast_sendtext(struct ast_channel *chan, const char *text)
2395 {
2396         int res = 0;
2397         /* Stop if we're a zombie or need a soft hangup */
2398         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2399                 return -1;
2400         CHECK_BLOCKING(chan);
2401         if (chan->tech->send_text)
2402                 res = chan->tech->send_text(chan, text);
2403         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2404         return res;
2405 }
2406
2407 int ast_senddigit_begin(struct ast_channel *chan, char digit)
2408 {
2409         int res = -1;
2410
2411         if (chan->tech->send_digit_begin)
2412                 res = chan->tech->send_digit_begin(chan, digit);
2413
2414         if (res) {
2415                 /*
2416                  * Device does not support DTMF tones, lets fake
2417                  * it by doing our own generation. (PM2002)
2418                  */
2419                 static const char* dtmf_tones[] = {
2420                         "!941+1336/100,!0/100", /* 0 */
2421                         "!697+1209/100,!0/100", /* 1 */
2422                         "!697+1336/100,!0/100", /* 2 */
2423                         "!697+1477/100,!0/100", /* 3 */
2424                         "!770+1209/100,!0/100", /* 4 */
2425                         "!770+1336/100,!0/100", /* 5 */
2426                         "!770+1477/100,!0/100", /* 6 */
2427                         "!852+1209/100,!0/100", /* 7 */
2428                         "!852+1336/100,!0/100", /* 8 */
2429                         "!852+1477/100,!0/100", /* 9 */
2430                         "!697+1633/100,!0/100", /* A */
2431                         "!770+1633/100,!0/100", /* B */
2432                         "!852+1633/100,!0/100", /* C */
2433                         "!941+1633/100,!0/100", /* D */
2434                         "!941+1209/100,!0/100", /* * */
2435                         "!941+1477/100,!0/100" };       /* # */
2436                 if (digit >= '0' && digit <='9')
2437                         ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2438                 else if (digit >= 'A' && digit <= 'D')
2439                         ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2440                 else if (digit == '*')
2441                         ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2442                 else if (digit == '#')
2443                         ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2444                 else {
2445                         /* not handled */
2446                         if (option_debug)
2447                                 ast_log(LOG_DEBUG, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2448                 }
2449         }
2450
2451         return 0;
2452 }
2453
2454 int ast_senddigit_end(struct ast_channel *chan, char digit)
2455 {
2456         int res = -1;
2457
2458         if (chan->tech->send_digit_end)
2459                 res = chan->tech->send_digit_end(chan, digit);
2460
2461         if (res && chan->generator)
2462                 ast_playtones_stop(chan);
2463         
2464         return 0;
2465 }
2466
2467 int ast_senddigit(struct ast_channel *chan, char digit)
2468 {
2469         ast_senddigit_begin(chan, digit);
2470         
2471         ast_safe_sleep(chan, 100); /* XXX 100ms ... probably should be configurable */
2472         
2473         return ast_senddigit_end(chan, digit);
2474 }
2475
2476 int ast_prod(struct ast_channel *chan)
2477 {
2478         struct ast_frame a = { AST_FRAME_VOICE };
2479         char nothing[128];
2480
2481         /* Send an empty audio frame to get things moving */
2482         if (chan->_state != AST_STATE_UP) {
2483                 if (option_debug)
2484                         ast_log(LOG_DEBUG, "Prodding channel '%s'\n", chan->name);
2485                 a.subclass = chan->rawwriteformat;
2486                 a.data = nothing + AST_FRIENDLY_OFFSET;
2487                 a.src = "ast_prod";
2488                 if (ast_write(chan, &a))
2489                         ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2490         }
2491         return 0;
2492 }
2493
2494 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2495 {
2496         int res;
2497         if (!chan->tech->write_video)
2498                 return 0;
2499         res = ast_write(chan, fr);
2500         if (!res)
2501                 res = 1;
2502         return res;
2503 }
2504
2505 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2506 {
2507         int res = -1;
2508         struct ast_frame *f = NULL;
2509
2510         /* Stop if we're a zombie or need a soft hangup */
2511         ast_channel_lock(chan);
2512         if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2513                 goto done;
2514
2515         /* Handle any pending masquerades */
2516         if (chan->masq && ast_do_masquerade(chan)) {
2517                 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2518                 goto done;
2519         }
2520         if (chan->masqr) {
2521                 res = 0;        /* XXX explain, why 0 ? */
2522                 goto done;
2523         }
2524         if (chan->generatordata) {
2525                 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
2526                         ast_deactivate_generator(chan);
2527                 else {
2528                         res = 0;        /* XXX explain, why 0 ? */
2529                         goto done;
2530                 }
2531         }
2532         /* High bit prints debugging */
2533         if (chan->fout & DEBUGCHAN_FLAG)
2534                 ast_frame_dump(chan->name, fr, ">>");
2535         CHECK_BLOCKING(chan);
2536         switch(fr->frametype) {
2537         case AST_FRAME_CONTROL:
2538                 res = (chan->tech->indicate == NULL) ? 0 :
2539                         chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2540                 break;
2541         case AST_FRAME_DTMF_BEGIN:
2542                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2543                 ast_channel_unlock(chan);
2544                 res = ast_senddigit_begin(chan, fr->subclass);
2545                 ast_channel_lock(chan);
2546                 CHECK_BLOCKING(chan);
2547                 break;
2548         case AST_FRAME_DTMF_END:
2549                 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2550                 ast_channel_unlock(chan);
2551                 res = ast_senddigit_end(chan, fr->subclass);
2552                 ast_channel_lock(chan);
2553                 CHECK_BLOCKING(chan);
2554                 break;
2555         case AST_FRAME_TEXT:
2556                 res = (chan->tech->send_text == NULL) ? 0 :
2557                         chan->tech->send_text(chan, (char *) fr->data);
2558                 break;
2559         case AST_FRAME_HTML:
2560                 res = (chan->tech->send_html == NULL) ? 0 :
2561                         chan->tech->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen);
2562                 break;
2563         case AST_FRAME_VIDEO:
2564                 /* XXX Handle translation of video codecs one day XXX */
2565                 res = (chan->tech->write_video == NULL) ? 0 :
2566                         chan->tech->write_video(chan, fr);
2567                 break;
2568         case AST_FRAME_MODEM:
2569                 res = (chan->tech->write == NULL) ? 0 :
2570                         chan->tech->write(chan, fr);
2571                 break;
2572         case AST_FRAME_VOICE:
2573                 if (chan->tech->write == NULL)
2574                         break;  /*! \todo XXX should return 0 maybe ? */
2575
2576                 /* If someone is whispering on this channel then we must ensure that we are always getting signed linear frames */
2577                 if (ast_test_flag(chan, AST_FLAG_WHISPER)) {
2578                         if (fr->subclass == AST_FORMAT_SLINEAR)
2579                                 f = fr;
2580                         else {
2581                                 ast_mutex_lock(&chan->whisper->lock);
2582                                 if (chan->writeformat != AST_FORMAT_SLINEAR) {
2583                                         /* Rebuild the translation path and set our write format back to signed linear */
2584                                         chan->whisper->original_format = chan->writeformat;
2585                                         ast_set_write_format(chan, AST_FORMAT_SLINEAR);
2586                                         if (chan->whisper->path)
2587                                                 ast_translator_free_path(chan->whisper->path);
2588                                         chan->whisper->path = ast_translator_build_path(AST_FORMAT_SLINEAR, chan->whisper->original_format);
2589                                 }
2590                                 /* Translate frame using the above translation path */
2591                                 f = (chan->whisper->path) ? ast_translate(chan->whisper->path, fr, 0) : fr;
2592                                 ast_mutex_unlock(&chan->whisper->lock);
2593                         }
2594                 } else {
2595                         /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
2596                         if (fr->subclass == chan->rawwriteformat)
2597                                 f = fr;
2598                         else
2599                                 f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
2600                 }
2601
2602                 /* If we have no frame of audio, then we have to bail out */
2603                 if (f == NULL) {
2604                         res = 0;
2605                         break;
2606                 }
2607
2608                 /* If spies are on the channel then queue the frame out to them */
2609                 if (chan->spies)
2610                         queue_frame_to_spies(chan, f, SPY_WRITE);
2611
2612                 /* If Monitor is running on this channel, then we have to write frames out there too */
2613                 if (chan->monitor && chan->monitor->write_stream) {
2614                         /* XXX must explain this code */
2615 #ifndef MONITOR_CONSTANT_DELAY
2616                         int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
2617                         if (jump >= 0) {
2618                                 if (ast_seekstream(chan->monitor->write_stream, jump + f->samples, SEEK_FORCECUR) == -1)
2619                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2620                                 chan->outsmpl += jump + 4 * f->samples;
2621                         } else
2622                                 chan->outsmpl += f->samples;
2623 #else
2624                         int jump = chan->insmpl - chan->outsmpl;
2625                         if (jump - MONITOR_DELAY >= 0) {
2626                                 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2627                                         ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2628                                 chan->outsmpl += jump;
2629                         } else
2630                                 chan->outsmpl += f->samples;
2631 #endif
2632                         if (chan->monitor->state == AST_MONITOR_RUNNING) {
2633                                 if (ast_writestream(chan->monitor->write_stream, f) < 0)
2634                                         ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
2635                         }
2636                 }
2637
2638                 /* Finally the good part! Write this out to the channel */
2639                 if (ast_test_flag(chan, AST_FLAG_WHISPER)) {
2640                         /* frame is assumed to be in SLINEAR, since that is
2641                            required for whisper mode */
2642                         ast_frame_adjust_volume(f, -2);
2643                         if (ast_slinfactory_available(&chan->whisper->sf) >= f->samples) {
2644                                 short buf[f->samples];
2645                                 struct ast_frame whisper = {
2646                                         .frametype = AST_FRAME_VOICE,
2647                                         .subclass = AST_FORMAT_SLINEAR,
2648                                         .data = buf,
2649                                         .datalen = sizeof(buf),
2650                                         .samples = f->samples,
2651                                 };
2652                                 
2653                                 ast_mutex_lock(&chan->whisper->lock);
2654                                 if (ast_slinfactory_read(&chan->whisper->sf, buf, f->samples))
2655                                         ast_frame_slinear_sum(f, &whisper);
2656                                 ast_mutex_unlock(&chan->whisper->lock);
2657                         }
2658                         /* and now put it through the regular translator */
2659                         f = (chan->writetrans) ? ast_translate(chan->writetrans, f, 0) : f;
2660                 }
2661                 if (f)
2662                         res = chan->tech->write(chan, f);
2663                 else
2664                         res = 0;
2665                 break;
2666         case AST_FRAME_NULL:
2667         case AST_FRAME_IAX:
2668                 /* Ignore these */
2669                 res = 0;
2670                 break;
2671         default:
2672                 /* At this point, fr is the incoming frame and f is NULL.  Channels do
2673                  * not expect to get NULL as a frame pointer and will segfault.  Hence,
2674                  * we output the original frame passed in. */
2675                 res = chan->tech->write(chan, fr);
2676                 break;
2677         }
2678
2679         if (f && f != fr)
2680                 ast_frfree(f);
2681         ast_clear_flag(chan, AST_FLAG_BLOCKING);
2682         /* Consider a write failure to force a soft hangup */
2683         if (res < 0)
2684                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2685         else {
2686                 chan->fout = FRAMECOUNT_INC(chan->fout);
2687         }
2688 done:
2689         ast_channel_unlock(chan);
2690         return res;
2691 }
2692
2693 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
2694                       struct ast_trans_pvt **trans, const int direction)
2695 {
2696         int native;
2697         int res;
2698         
2699         /* Make sure we only consider audio */
2700         fmt &= AST_FORMAT_AUDIO_MASK;
2701         
2702         native = chan->nativeformats;
2703         /* Find a translation path from the native format to one of the desired formats */
2704         if (!direction)
2705                 /* reading */
2706                 res = ast_translator_best_choice(&fmt, &native);
2707         else
2708                 /* writing */
2709                 res = ast_translator_best_choice(&native, &fmt);
2710
2711         if (res < 0) {
2712                 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
2713                         ast_getformatname(native), ast_getformatname(fmt));
2714                 return -1;
2715         }
2716         
2717         /* Now we have a good choice for both. */
2718         ast_channel_lock(chan);
2719
2720         if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
2721                 /* the channel is already in these formats, so nothing to do */
2722                 ast_channel_unlock(chan);
2723                 return 0;
2724         }
2725
2726         *rawformat = native;
2727         /* User perspective is fmt */
2728         *format = fmt;
2729         /* Free any read translation we have right now */
2730         if (*trans)
2731                 ast_translator_free_path(*trans);
2732         /* Build a translation path from the raw format to the desired format */
2733         if (!direction)
2734                 /* reading */
2735                 *trans = ast_translator_build_path(*format, *rawformat);
2736         else
2737                 /* writing */
2738                 *trans = ast_translator_build_path(*rawformat, *format);
2739         ast_channel_unlock(chan);
2740         if (option_debug)
2741                 ast_log(LOG_DEBUG, "Set channel %s to %s format %s\n", chan->name,
2742                         direction ? "write" : "read", ast_getformatname(fmt));
2743         return 0;
2744 }
2745
2746 int ast_set_read_format(struct ast_channel *chan, int fmt)
2747 {
2748         return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
2749                           &chan->readtrans, 0);
2750 }
2751
2752 int ast_set_write_format(struct ast_channel *chan, int fmt)
2753 {
2754         return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
2755                           &chan->writetrans, 1);
2756 }
2757
2758 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)
2759 {
2760         int dummy_outstate;
2761         int cause = 0;
2762         struct ast_channel *chan;
2763         int res = 0;
2764         
2765         if (outstate)
2766                 *outstate = 0;
2767         else
2768                 outstate = &dummy_outstate;     /* make outstate always a valid pointer */
2769
2770         chan = ast_request(type, format, data, &cause);
2771         if (!chan) {
2772                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
2773                 /* compute error and return */
2774                 if (cause == AST_CAUSE_BUSY)
2775                         *outstate = AST_CONTROL_BUSY;
2776                 else if (cause == AST_CAUSE_CONGESTION)
2777                         *outstate = AST_CONTROL_CONGESTION;
2778                 return NULL;
2779         }
2780
2781         if (oh) {
2782                 if (oh->vars)   
2783                         ast_set_variables(chan, oh->vars);
2784                 /* XXX why is this necessary, for the parent_channel perhaps ? */
2785                 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
2786                         ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
2787                 if (oh->parent_channel)
2788                         ast_channel_inherit_variables(oh->parent_channel, chan);
2789                 if (oh->account)
2790                         ast_cdr_setaccount(chan, oh->account);  
2791         }
2792         ast_set_callerid(chan, cid_num, cid_name, cid_num);
2793
2794         if (ast_call(chan, data, 0)) {  /* ast_call failed... */
2795                 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
2796         } else {
2797                 res = 1;        /* mark success in case chan->_state is already AST_STATE_UP */
2798                 while (timeout && chan->_state != AST_STATE_UP) {
2799                         struct ast_frame *f;
2800                         res = ast_waitfor(chan, timeout);
2801                         if (res <= 0) /* error, timeout, or done */
2802                                 break;
2803                         if (timeout > -1)
2804                                 timeout = res;
2805                         f = ast_read(chan);
2806                         if (!f) {
2807                                 *outstate = AST_CONTROL_HANGUP;
2808                                 res = 0;
2809                                 break;
2810                         }
2811                         if (f->frametype == AST_FRAME_CONTROL) {
2812                                 switch (f->subclass) {
2813                                 case AST_CONTROL_RINGING:       /* record but keep going */
2814                                         *outstate = f->subclass;
2815                                         break;
2816
2817                                 case AST_CONTROL_BUSY:
2818                                 case AST_CONTROL_CONGESTION:
2819                                 case AST_CONTROL_ANSWER:
2820                                         *outstate = f->subclass;
2821                                         timeout = 0;            /* trick to force exit from the while() */
2822                                         break;
2823
2824                                 /* Ignore these */
2825                                 case AST_CONTROL_PROGRESS:
2826                                 case AST_CONTROL_PROCEEDING:
2827                                 case AST_CONTROL_HOLD:
2828                                 case AST_CONTROL_UNHOLD:
2829                                 case AST_CONTROL_VIDUPDATE:
2830                                 case -1:                        /* Ignore -- just stopping indications */
2831                                         break;
2832
2833                                 default:
2834                                         ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
2835                                 }
2836                         }
2837                         ast_frfree(f);
2838                 }
2839         }
2840
2841         /* Final fixups */
2842         if (oh) {
2843                 if (!ast_strlen_zero(oh->context))
2844                         ast_copy_string(chan->context, oh->context, sizeof(chan->context));
2845                 if (!ast_strlen_zero(oh->exten))
2846                         ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
2847                 if (oh->priority)       
2848                         chan->priority = oh->priority;
2849         }
2850         if (chan->_state == AST_STATE_UP)
2851                 *outstate = AST_CONTROL_ANSWER;
2852
2853         if (res <= 0) {
2854                 if (!chan->cdr && (chan->cdr = ast_cdr_alloc()))
2855                         ast_cdr_init(chan->cdr, chan);
2856                 if (chan->cdr) {
2857                         char tmp[256];
2858                         snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data);
2859                         ast_cdr_setapp(chan->cdr,"Dial",tmp);
2860                         ast_cdr_update(chan);
2861                         ast_cdr_start(chan->cdr);
2862                         ast_cdr_end(chan->cdr);
2863                         /* If the cause wasn't handled properly */
2864                         if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
2865                                 ast_cdr_failed(chan->cdr);
2866                 }
2867                 ast_hangup(chan);
2868                 chan = NULL;
2869         }
2870         return chan;
2871 }
2872
2873 struct ast_channel *ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname)
2874 {
2875         return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
2876 }
2877
2878 struct ast_channel *ast_request(const char *type, int format, void *data, int *cause)
2879 {
2880         struct chanlist *chan;
2881         struct ast_channel *c;
2882         int capabilities;
2883         int fmt;
2884         int res;
2885         int foo;
2886         int videoformat = format & AST_FORMAT_VIDEO_MASK;
2887
2888         if (!cause)
2889                 cause = &foo;
2890         *cause = AST_CAUSE_NOTDEFINED;
2891
2892         if (AST_LIST_LOCK(&channels)) {
2893                 ast_log(LOG_WARNING, "Unable to lock channel list\n");
2894                 return NULL;
2895         }
2896
2897         AST_LIST_TRAVERSE(&backends, chan, list) {
2898                 if (strcasecmp(type, chan->tech->type))
2899                         continue;
2900
2901                 capabilities = chan->tech->capabilities;
2902                 fmt = format & AST_FORMAT_AUDIO_MASK;
2903                 res = ast_translator_best_choice(&fmt, &capabilities);
2904                 if (res < 0) {
2905                         ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %d) to %d\n", type, chan->tech->capabilities, format);
2906                         AST_LIST_UNLOCK(&channels);
2907                         return NULL;
2908                 }
2909                 AST_LIST_UNLOCK(&channels);
2910                 if (!chan->tech->requester)
2911                         return NULL;
2912                 
2913                 if (!(c = chan->tech->requester(type, capabilities | videoformat, data, cause)))
2914                         return NULL;
2915                 
2916                 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
2917                 return c;
2918         }
2919
2920         ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
2921         *cause = AST_CAUSE_NOSUCHDRIVER;
2922         AST_LIST_UNLOCK(&channels);
2923
2924         return NULL;
2925 }
2926
2927 int ast_call(struct ast_channel *chan, char *addr, int timeout)
2928 {
2929         /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
2930            If the remote end does not answer within the timeout, then do NOT hang up, but
2931            return anyway.  */
2932         int res = -1;
2933         /* Stop if we're a zombie or need a soft hangup */
2934         ast_channel_lock(chan);
2935         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
2936                 if (chan->tech->call)
2937                         res = chan->tech->call(chan, addr, timeout);
2938                 ast_set_flag(chan, AST_FLAG_OUTGOING);
2939         }
2940         ast_channel_unlock(chan);
2941         return res;
2942 }
2943
2944 /*!
2945   \brief Transfer a call to dest, if the channel supports transfer
2946
2947   Called by:
2948     \arg app_transfer
2949     \arg the manager interface
2950 */
2951 int ast_transfer(struct ast_channel *chan, char *dest)
2952 {
2953         int res = -1;
2954
2955         /* Stop if we're a zombie or need a soft hangup */
2956         ast_channel_lock(chan);
2957         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
2958                 if (chan->tech->transfer) {
2959                         res = chan->tech->transfer(chan, dest);
2960                         if (!res)
2961                                 res = 1;
2962                 } else
2963                         res = 0;
2964         }
2965         ast_channel_unlock(chan);
2966         return res;
2967 }
2968
2969 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
2970 {
2971         return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
2972 }
2973
2974 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
2975 {
2976         int pos = 0;    /* index in the buffer where we accumulate digits */
2977         int to = ftimeout;
2978
2979         /* Stop if we're a zombie or need a soft hangup */
2980         if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
2981                 return -1;
2982         if (!len)
2983                 return -1;
2984         for (;;) {
2985                 int d;
2986                 if (c->stream) {
2987                         d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
2988                         ast_stopstream(c);
2989                         usleep(1000);
2990                         if (!d)
2991                                 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
2992                 } else {
2993                         d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
2994                 }
2995                 if (d < 0)
2996                         return -1;
2997                 if (d == 0) {
2998                         s[pos]='\0';
2999                         return 1;
3000                 }
3001                 if (d == 1) {
3002                         s[pos]='\0';
3003                         return 2;
3004                 }
3005                 if (!strchr(enders, d))
3006                         s[pos++] = d;
3007                 if (strchr(enders, d) || (pos >= len)) {
3008                         s[pos]='\0';
3009                         return 0;
3010                 }
3011                 to = timeout;
3012         }
3013         /* Never reached */
3014         return 0;
3015 }
3016
3017 int ast_channel_supports_html(struct ast_channel *chan)
3018 {
3019         return (chan->tech->send_html) ? 1 : 0;
3020 }
3021
3022 int ast_channel_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen)
3023 {
3024         if (chan->tech->send_html)
3025                 return chan->tech->send_html(chan, subclass, data, datalen);
3026         return -1;
3027 }
3028
3029 int ast_channel_sendurl(struct ast_channel *chan, const char *url)
3030 {
3031         return ast_channel_sendhtml(chan, AST_HTML_URL, url, strlen(url) + 1);
3032 }
3033
3034 /*! \brief Set up translation from one channel to another */
3035 static int ast_channel_make_compatible_helper(struct ast_channel *from, struct ast_channel *to)
3036 {
3037         int src;
3038         int dst;
3039
3040         /* Set up translation from the 'from' channel to the 'to' channel */
3041         src = from->nativeformats;
3042         dst = to->nativeformats;
3043         if (ast_translator_best_choice(&dst, &src) < 0) {
3044                 ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", from->name, src, to->name, dst);
3045                 return -1;
3046         }
3047
3048         /* if the best path is not 'pass through', then
3049            transcoding is needed; if desired, force transcode path
3050            to use SLINEAR between channels, but only if there is
3051            no direct conversion available */
3052         if ((src != dst) && ast_opt_transcode_via_slin &&
3053             (ast_translate_path_steps(dst, src) != 1))
3054                 dst = AST_FORMAT_SLINEAR;
3055         if (ast_set_read_format(from, dst) < 0) {
3056                 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", from->name, dst);
3057                 return -1;
3058         }
3059         if (ast_set_write_format(to, dst) < 0) {
3060                 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", to->name, dst);
3061                 return -1;
3062         }
3063         return 0;
3064 }
3065
3066 int ast_channel_make_compatible(struct ast_channel *chan, struct ast_channel *peer)
3067 {
3068         /* Some callers do not check return code, and we must try to set all call legs correctly */
3069         int rc = 0;
3070
3071         /* Set up translation from the chan to the peer */
3072         rc = ast_channel_make_compatible_helper(chan, peer);
3073
3074         if (rc < 0)
3075                 return rc;
3076
3077         /* Set up translation from the peer to the chan */
3078         rc = ast_channel_make_compatible_helper(peer, chan);
3079
3080         return rc;
3081 }
3082
3083 int ast_channel_masquerade(struct ast_channel *original, struct ast_channel *clone)
3084 {
3085         int res = -1;
3086         struct ast_channel *final_orig = original, *final_clone = clone;
3087
3088         ast_channel_lock(original);
3089         while (ast_channel_trylock(clone)) {
3090                 ast_channel_unlock(original);
3091                 usleep(1);
3092                 ast_channel_lock(original);
3093         }
3094
3095         /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent)