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