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