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