fix various other problems found by gcc 4.3
[asterisk-bristuff.git] / main / channel.c
bloba12c4ef441e09bccd238c6572752e860eb60c391
1 /*
2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 1999 - 2006, Digium, Inc.
6 * Mark Spencer <markster@digium.com>
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.
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.
19 /*! \file
21 * \brief Channel Management
23 * \author Mark Spencer <markster@digium.com>
26 #include "asterisk.h"
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <stdarg.h>
33 #include <string.h>
34 #include <sys/time.h>
35 #include <signal.h>
36 #include <errno.h>
37 #include <unistd.h>
38 #include <math.h>
40 #ifdef HAVE_ZAPTEL
41 #include <sys/ioctl.h>
42 #include <zaptel/zaptel.h>
43 #endif
45 #include "asterisk/pbx.h"
46 #include "asterisk/frame.h"
47 #include "asterisk/sched.h"
48 #include "asterisk/options.h"
49 #include "asterisk/channel.h"
50 #include "asterisk/audiohook.h"
51 #include "asterisk/musiconhold.h"
52 #include "asterisk/logger.h"
53 #include "asterisk/say.h"
54 #include "asterisk/file.h"
55 #include "asterisk/cli.h"
56 #include "asterisk/translate.h"
57 #include "asterisk/manager.h"
58 #include "asterisk/chanvars.h"
59 #include "asterisk/linkedlists.h"
60 #include "asterisk/indications.h"
61 #include "asterisk/monitor.h"
62 #include "asterisk/causes.h"
63 #include "asterisk/callerid.h"
64 #include "asterisk/utils.h"
65 #include "asterisk/lock.h"
66 #include "asterisk/app.h"
67 #include "asterisk/transcap.h"
68 #include "asterisk/devicestate.h"
69 #include "asterisk/sha1.h"
70 #include "asterisk/threadstorage.h"
71 #include "asterisk/slinfactory.h"
73 /* uncomment if you have problems with 'monitoring' synchronized files */
74 #if 0
75 #define MONITOR_CONSTANT_DELAY
76 #define MONITOR_DELAY 150 * 8 /* 150 ms of MONITORING DELAY */
77 #endif
79 /*! Prevent new channel allocation if shutting down. */
80 static int shutting_down;
82 static int uniqueint;
84 unsigned long global_fin, global_fout;
86 AST_THREADSTORAGE(state2str_threadbuf, state2str_threadbuf_init);
87 #define STATE2STR_BUFSIZE 32
89 /*! Default amount of time to use when emulating a digit as a begin and end
90 * 100ms */
91 #define AST_DEFAULT_EMULATE_DTMF_DURATION 100
93 /*! Minimum allowed digit length - 80ms */
94 #define AST_MIN_DTMF_DURATION 80
96 /*! Minimum amount of time between the end of the last digit and the beginning
97 * of a new one - 45ms */
98 #define AST_MIN_DTMF_GAP 45
100 struct chanlist {
101 const struct ast_channel_tech *tech;
102 AST_LIST_ENTRY(chanlist) list;
105 /*! the list of registered channel types */
106 static AST_LIST_HEAD_NOLOCK_STATIC(backends, chanlist);
108 /*! the list of channels we have. Note that the lock for this list is used for
109 both the channels list and the backends list. */
110 static AST_LIST_HEAD_STATIC(channels, ast_channel);
112 /*! map AST_CAUSE's to readable string representations */
113 const struct ast_cause {
114 int cause;
115 const char *name;
116 const char *desc;
117 } causes[] = {
118 { AST_CAUSE_UNALLOCATED, "UNALLOCATED", "Unallocated (unassigned) number" },
119 { AST_CAUSE_NO_ROUTE_TRANSIT_NET, "NO_ROUTE_TRANSIT_NET", "No route to specified transmit network" },
120 { AST_CAUSE_NO_ROUTE_DESTINATION, "NO_ROUTE_DESTINATION", "No route to destination" },
121 { AST_CAUSE_CHANNEL_UNACCEPTABLE, "CHANNEL_UNACCEPTABLE", "Channel unacceptable" },
122 { AST_CAUSE_CALL_AWARDED_DELIVERED, "CALL_AWARDED_DELIVERED", "Call awarded and being delivered in an established channel" },
123 { AST_CAUSE_NORMAL_CLEARING, "NORMAL_CLEARING", "Normal Clearing" },
124 { AST_CAUSE_USER_BUSY, "USER_BUSY", "User busy" },
125 { AST_CAUSE_NO_USER_RESPONSE, "NO_USER_RESPONSE", "No user responding" },
126 { AST_CAUSE_NO_ANSWER, "NO_ANSWER", "User alerting, no answer" },
127 { AST_CAUSE_CALL_REJECTED, "CALL_REJECTED", "Call Rejected" },
128 { AST_CAUSE_NUMBER_CHANGED, "NUMBER_CHANGED", "Number changed" },
129 { AST_CAUSE_DESTINATION_OUT_OF_ORDER, "DESTINATION_OUT_OF_ORDER", "Destination out of order" },
130 { AST_CAUSE_INVALID_NUMBER_FORMAT, "INVALID_NUMBER_FORMAT", "Invalid number format" },
131 { AST_CAUSE_FACILITY_REJECTED, "FACILITY_REJECTED", "Facility rejected" },
132 { AST_CAUSE_RESPONSE_TO_STATUS_ENQUIRY, "RESPONSE_TO_STATUS_ENQUIRY", "Response to STATus ENQuiry" },
133 { AST_CAUSE_NORMAL_UNSPECIFIED, "NORMAL_UNSPECIFIED", "Normal, unspecified" },
134 { AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, "NORMAL_CIRCUIT_CONGESTION", "Circuit/channel congestion" },
135 { AST_CAUSE_NETWORK_OUT_OF_ORDER, "NETWORK_OUT_OF_ORDER", "Network out of order" },
136 { AST_CAUSE_NORMAL_TEMPORARY_FAILURE, "NORMAL_TEMPORARY_FAILURE", "Temporary failure" },
137 { AST_CAUSE_SWITCH_CONGESTION, "SWITCH_CONGESTION", "Switching equipment congestion" },
138 { AST_CAUSE_ACCESS_INFO_DISCARDED, "ACCESS_INFO_DISCARDED", "Access information discarded" },
139 { AST_CAUSE_REQUESTED_CHAN_UNAVAIL, "REQUESTED_CHAN_UNAVAIL", "Requested channel not available" },
140 { AST_CAUSE_PRE_EMPTED, "PRE_EMPTED", "Pre-empted" },
141 { AST_CAUSE_FACILITY_NOT_SUBSCRIBED, "FACILITY_NOT_SUBSCRIBED", "Facility not subscribed" },
142 { AST_CAUSE_OUTGOING_CALL_BARRED, "OUTGOING_CALL_BARRED", "Outgoing call barred" },
143 { AST_CAUSE_INCOMING_CALL_BARRED, "INCOMING_CALL_BARRED", "Incoming call barred" },
144 { AST_CAUSE_BEARERCAPABILITY_NOTAUTH, "BEARERCAPABILITY_NOTAUTH", "Bearer capability not authorized" },
145 { AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, "BEARERCAPABILITY_NOTAVAIL", "Bearer capability not available" },
146 { AST_CAUSE_BEARERCAPABILITY_NOTIMPL, "BEARERCAPABILITY_NOTIMPL", "Bearer capability not implemented" },
147 { AST_CAUSE_CHAN_NOT_IMPLEMENTED, "CHAN_NOT_IMPLEMENTED", "Channel not implemented" },
148 { AST_CAUSE_FACILITY_NOT_IMPLEMENTED, "FACILITY_NOT_IMPLEMENTED", "Facility not implemented" },
149 { AST_CAUSE_INVALID_CALL_REFERENCE, "INVALID_CALL_REFERENCE", "Invalid call reference value" },
150 { AST_CAUSE_INCOMPATIBLE_DESTINATION, "INCOMPATIBLE_DESTINATION", "Incompatible destination" },
151 { AST_CAUSE_INVALID_MSG_UNSPECIFIED, "INVALID_MSG_UNSPECIFIED", "Invalid message unspecified" },
152 { AST_CAUSE_MANDATORY_IE_MISSING, "MANDATORY_IE_MISSING", "Mandatory information element is missing" },
153 { AST_CAUSE_MESSAGE_TYPE_NONEXIST, "MESSAGE_TYPE_NONEXIST", "Message type nonexist." },
154 { AST_CAUSE_WRONG_MESSAGE, "WRONG_MESSAGE", "Wrong message" },
155 { AST_CAUSE_IE_NONEXIST, "IE_NONEXIST", "Info. element nonexist or not implemented" },
156 { AST_CAUSE_INVALID_IE_CONTENTS, "INVALID_IE_CONTENTS", "Invalid information element contents" },
157 { AST_CAUSE_WRONG_CALL_STATE, "WRONG_CALL_STATE", "Message not compatible with call state" },
158 { AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, "RECOVERY_ON_TIMER_EXPIRE", "Recover on timer expiry" },
159 { AST_CAUSE_MANDATORY_IE_LENGTH_ERROR, "MANDATORY_IE_LENGTH_ERROR", "Mandatory IE length error" },
160 { AST_CAUSE_PROTOCOL_ERROR, "PROTOCOL_ERROR", "Protocol error, unspecified" },
161 { AST_CAUSE_INTERWORKING, "INTERWORKING", "Interworking, unspecified" },
164 struct ast_variable *ast_channeltype_list(void)
166 struct chanlist *cl;
167 struct ast_variable *var=NULL, *prev = NULL;
168 AST_LIST_TRAVERSE(&backends, cl, list) {
169 if (prev) {
170 if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description)))
171 prev = prev->next;
172 } else {
173 var = ast_variable_new(cl->tech->type, cl->tech->description);
174 prev = var;
177 return var;
180 static int show_channeltypes(int fd, int argc, char *argv[])
182 #define FORMAT "%-10.10s %-40.40s %-12.12s %-12.12s %-12.12s\n"
183 struct chanlist *cl;
184 int count_chan = 0;
186 ast_cli(fd, FORMAT, "Type", "Description", "Devicestate", "Indications", "Transfer");
187 ast_cli(fd, FORMAT, "----------", "-----------", "-----------", "-----------", "--------");
188 if (AST_LIST_LOCK(&channels)) {
189 ast_log(LOG_WARNING, "Unable to lock channel list\n");
190 return -1;
192 AST_LIST_TRAVERSE(&backends, cl, list) {
193 ast_cli(fd, FORMAT, cl->tech->type, cl->tech->description,
194 (cl->tech->devicestate) ? "yes" : "no",
195 (cl->tech->indicate) ? "yes" : "no",
196 (cl->tech->transfer) ? "yes" : "no");
197 count_chan++;
199 AST_LIST_UNLOCK(&channels);
200 ast_cli(fd, "----------\n%d channel drivers registered.\n", count_chan);
201 return RESULT_SUCCESS;
203 #undef FORMAT
207 static int show_channeltype_deprecated(int fd, int argc, char *argv[])
209 struct chanlist *cl = NULL;
211 if (argc != 3)
212 return RESULT_SHOWUSAGE;
214 if (AST_LIST_LOCK(&channels)) {
215 ast_log(LOG_WARNING, "Unable to lock channel list\n");
216 return RESULT_FAILURE;
219 AST_LIST_TRAVERSE(&backends, cl, list) {
220 if (!strncasecmp(cl->tech->type, argv[2], strlen(cl->tech->type))) {
221 break;
226 if (!cl) {
227 ast_cli(fd, "\n%s is not a registered channel driver.\n", argv[2]);
228 AST_LIST_UNLOCK(&channels);
229 return RESULT_FAILURE;
232 ast_cli(fd,
233 "-- Info about channel driver: %s --\n"
234 " Device State: %s\n"
235 " Indication: %s\n"
236 " Transfer : %s\n"
237 " Capabilities: %d\n"
238 " Digit Begin: %s\n"
239 " Digit End: %s\n"
240 " Send HTML : %s\n"
241 " Image Support: %s\n"
242 " Text Support: %s\n",
243 cl->tech->type,
244 (cl->tech->devicestate) ? "yes" : "no",
245 (cl->tech->indicate) ? "yes" : "no",
246 (cl->tech->transfer) ? "yes" : "no",
247 (cl->tech->capabilities) ? cl->tech->capabilities : -1,
248 (cl->tech->send_digit_begin) ? "yes" : "no",
249 (cl->tech->send_digit_end) ? "yes" : "no",
250 (cl->tech->send_html) ? "yes" : "no",
251 (cl->tech->send_image) ? "yes" : "no",
252 (cl->tech->send_text) ? "yes" : "no"
256 AST_LIST_UNLOCK(&channels);
257 return RESULT_SUCCESS;
260 static int show_channeltype(int fd, int argc, char *argv[])
262 struct chanlist *cl = NULL;
264 if (argc != 4)
265 return RESULT_SHOWUSAGE;
267 if (AST_LIST_LOCK(&channels)) {
268 ast_log(LOG_WARNING, "Unable to lock channel list\n");
269 return RESULT_FAILURE;
272 AST_LIST_TRAVERSE(&backends, cl, list) {
273 if (!strncasecmp(cl->tech->type, argv[3], strlen(cl->tech->type))) {
274 break;
279 if (!cl) {
280 ast_cli(fd, "\n%s is not a registered channel driver.\n", argv[3]);
281 AST_LIST_UNLOCK(&channels);
282 return RESULT_FAILURE;
285 ast_cli(fd,
286 "-- Info about channel driver: %s --\n"
287 " Device State: %s\n"
288 " Indication: %s\n"
289 " Transfer : %s\n"
290 " Capabilities: %d\n"
291 " Digit Begin: %s\n"
292 " Digit End: %s\n"
293 " Send HTML : %s\n"
294 " Image Support: %s\n"
295 " Text Support: %s\n",
296 cl->tech->type,
297 (cl->tech->devicestate) ? "yes" : "no",
298 (cl->tech->indicate) ? "yes" : "no",
299 (cl->tech->transfer) ? "yes" : "no",
300 (cl->tech->capabilities) ? cl->tech->capabilities : -1,
301 (cl->tech->send_digit_begin) ? "yes" : "no",
302 (cl->tech->send_digit_end) ? "yes" : "no",
303 (cl->tech->send_html) ? "yes" : "no",
304 (cl->tech->send_image) ? "yes" : "no",
305 (cl->tech->send_text) ? "yes" : "no"
309 AST_LIST_UNLOCK(&channels);
310 return RESULT_SUCCESS;
313 static char *complete_channeltypes_deprecated(const char *line, const char *word, int pos, int state)
315 struct chanlist *cl;
316 int which = 0;
317 int wordlen;
318 char *ret = NULL;
320 if (pos != 2)
321 return NULL;
323 wordlen = strlen(word);
325 AST_LIST_TRAVERSE(&backends, cl, list) {
326 if (!strncasecmp(word, cl->tech->type, wordlen) && ++which > state) {
327 ret = strdup(cl->tech->type);
328 break;
332 return ret;
335 static char *complete_channeltypes(const char *line, const char *word, int pos, int state)
337 struct chanlist *cl;
338 int which = 0;
339 int wordlen;
340 char *ret = NULL;
342 if (pos != 3)
343 return NULL;
345 wordlen = strlen(word);
347 AST_LIST_TRAVERSE(&backends, cl, list) {
348 if (!strncasecmp(word, cl->tech->type, wordlen) && ++which > state) {
349 ret = strdup(cl->tech->type);
350 break;
354 return ret;
357 static char show_channeltypes_usage[] =
358 "Usage: core show channeltypes\n"
359 " Lists available channel types registered in your Asterisk server.\n";
361 static char show_channeltype_usage[] =
362 "Usage: core show channeltype <name>\n"
363 " Show details about the specified channel type, <name>.\n";
365 static struct ast_cli_entry cli_show_channeltypes_deprecated = {
366 { "show", "channeltypes", NULL },
367 show_channeltypes, NULL,
368 NULL };
370 static struct ast_cli_entry cli_show_channeltype_deprecated = {
371 { "show", "channeltype", NULL },
372 show_channeltype_deprecated, NULL,
373 NULL, complete_channeltypes_deprecated };
375 static struct ast_cli_entry cli_channel[] = {
376 { { "core", "show", "channeltypes", NULL },
377 show_channeltypes, "List available channel types",
378 show_channeltypes_usage, NULL, &cli_show_channeltypes_deprecated },
380 { { "core", "show", "channeltype", NULL },
381 show_channeltype, "Give more details on that channel type",
382 show_channeltype_usage, complete_channeltypes, &cli_show_channeltype_deprecated },
385 /*! \brief Checks to see if a channel is needing hang up */
386 int ast_check_hangup(struct ast_channel *chan)
388 if (chan->_softhangup) /* yes if soft hangup flag set */
389 return 1;
390 if (!chan->tech_pvt) /* yes if no technology private data */
391 return 1;
392 if (!chan->whentohangup) /* no if no hangup scheduled */
393 return 0;
394 if (chan->whentohangup > time(NULL)) /* no if hangup time has not come yet. */
395 return 0;
396 chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT; /* record event */
397 return 1;
400 static int ast_check_hangup_locked(struct ast_channel *chan)
402 int res;
403 ast_channel_lock(chan);
404 res = ast_check_hangup(chan);
405 ast_channel_unlock(chan);
406 return res;
409 /*! \brief printf the string into a correctly sized mallocd buffer, and return the buffer */
410 char *ast_safe_string_alloc(const char *fmt, ...)
412 char *b2, buf[1];
413 int len;
414 va_list args;
416 va_start(args, fmt);
417 len = vsnprintf(buf, 1, fmt, args);
418 va_end(args);
420 if (!(b2 = ast_malloc(len + 1)))
421 return NULL;
423 va_start(args, fmt);
424 vsnprintf(b2, len + 1, fmt, args);
425 va_end(args);
427 return b2;
430 /*! \brief Initiate system shutdown */
431 void ast_begin_shutdown(int hangup)
433 struct ast_channel *c;
434 shutting_down = 1;
435 if (hangup) {
436 AST_LIST_LOCK(&channels);
437 AST_LIST_TRAVERSE(&channels, c, chan_list)
438 ast_softhangup(c, AST_SOFTHANGUP_SHUTDOWN);
439 AST_LIST_UNLOCK(&channels);
443 /*! \brief returns number of active/allocated channels */
444 int ast_active_channels(void)
446 struct ast_channel *c;
447 int cnt = 0;
448 AST_LIST_LOCK(&channels);
449 AST_LIST_TRAVERSE(&channels, c, chan_list)
450 cnt++;
451 AST_LIST_UNLOCK(&channels);
452 return cnt;
455 /*! \brief Cancel a shutdown in progress */
456 void ast_cancel_shutdown(void)
458 shutting_down = 0;
461 /*! \brief Returns non-zero if Asterisk is being shut down */
462 int ast_shutting_down(void)
464 return shutting_down;
467 /*! \brief Set when to hangup channel */
468 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset)
470 chan->whentohangup = offset ? time(NULL) + offset : 0;
471 ast_queue_frame(chan, &ast_null_frame);
472 return;
475 /*! \brief Compare a offset with when to hangup channel */
476 int ast_channel_cmpwhentohangup(struct ast_channel *chan, time_t offset)
478 time_t whentohangup;
480 if (chan->whentohangup == 0) {
481 return (offset == 0) ? 0 : -1;
482 } else {
483 if (offset == 0) /* XXX why is this special ? */
484 return (1);
485 else {
486 whentohangup = offset + time (NULL);
487 if (chan->whentohangup < whentohangup)
488 return (1);
489 else if (chan->whentohangup == whentohangup)
490 return (0);
491 else
492 return (-1);
497 /*! \brief Register a new telephony channel in Asterisk */
498 int ast_channel_register(const struct ast_channel_tech *tech)
500 struct chanlist *chan;
502 AST_LIST_LOCK(&channels);
504 AST_LIST_TRAVERSE(&backends, chan, list) {
505 if (!strcasecmp(tech->type, chan->tech->type)) {
506 ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
507 AST_LIST_UNLOCK(&channels);
508 return -1;
512 if (!(chan = ast_calloc(1, sizeof(*chan)))) {
513 AST_LIST_UNLOCK(&channels);
514 return -1;
516 chan->tech = tech;
517 AST_LIST_INSERT_HEAD(&backends, chan, list);
519 if (option_debug)
520 ast_log(LOG_DEBUG, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);
522 if (option_verbose > 1)
523 ast_verbose(VERBOSE_PREFIX_2 "Registered channel type '%s' (%s)\n", chan->tech->type,
524 chan->tech->description);
526 AST_LIST_UNLOCK(&channels);
527 return 0;
530 void ast_channel_unregister(const struct ast_channel_tech *tech)
532 struct chanlist *chan;
534 if (option_debug)
535 ast_log(LOG_DEBUG, "Unregistering channel type '%s'\n", tech->type);
537 AST_LIST_LOCK(&channels);
539 AST_LIST_TRAVERSE_SAFE_BEGIN(&backends, chan, list) {
540 if (chan->tech == tech) {
541 AST_LIST_REMOVE_CURRENT(&backends, list);
542 free(chan);
543 if (option_verbose > 1)
544 ast_verbose(VERBOSE_PREFIX_2 "Unregistered channel type '%s'\n", tech->type);
545 break;
548 AST_LIST_TRAVERSE_SAFE_END
550 AST_LIST_UNLOCK(&channels);
553 const struct ast_channel_tech *ast_get_channel_tech(const char *name)
555 struct chanlist *chanls;
556 const struct ast_channel_tech *ret = NULL;
558 if (AST_LIST_LOCK(&channels)) {
559 ast_log(LOG_WARNING, "Unable to lock channel tech list\n");
560 return NULL;
563 AST_LIST_TRAVERSE(&backends, chanls, list) {
564 if (!strcasecmp(name, chanls->tech->type)) {
565 ret = chanls->tech;
566 break;
570 AST_LIST_UNLOCK(&channels);
572 return ret;
575 /*! \brief Gives the string form of a given hangup cause */
576 const char *ast_cause2str(int cause)
578 int x;
580 for (x=0; x < sizeof(causes) / sizeof(causes[0]); x++) {
581 if (causes[x].cause == cause)
582 return causes[x].desc;
585 return "Unknown";
588 /*! \brief Convert a symbolic hangup cause to number */
589 int ast_str2cause(const char *name)
591 int x;
593 for (x = 0; x < sizeof(causes) / sizeof(causes[0]); x++)
594 if (strncasecmp(causes[x].name, name, strlen(causes[x].name)) == 0)
595 return causes[x].cause;
597 return -1;
600 /*! \brief Gives the string form of a given channel state */
601 char *ast_state2str(enum ast_channel_state state)
603 char *buf;
605 switch(state) {
606 case AST_STATE_DOWN:
607 return "Down";
608 case AST_STATE_RESERVED:
609 return "Rsrvd";
610 case AST_STATE_OFFHOOK:
611 return "OffHook";
612 case AST_STATE_DIALING:
613 return "Dialing";
614 case AST_STATE_RING:
615 return "Ring";
616 case AST_STATE_RINGING:
617 return "Ringing";
618 case AST_STATE_UP:
619 return "Up";
620 case AST_STATE_BUSY:
621 return "Busy";
622 case AST_STATE_DIALING_OFFHOOK:
623 return "Dialing Offhook";
624 case AST_STATE_PRERING:
625 return "Pre-ring";
626 default:
627 if (!(buf = ast_threadstorage_get(&state2str_threadbuf, STATE2STR_BUFSIZE)))
628 return "Unknown";
629 snprintf(buf, STATE2STR_BUFSIZE, "Unknown (%d)", state);
630 return buf;
634 /*! \brief Gives the string form of a given transfer capability */
635 char *ast_transfercapability2str(int transfercapability)
637 switch(transfercapability) {
638 case AST_TRANS_CAP_SPEECH:
639 return "SPEECH";
640 case AST_TRANS_CAP_DIGITAL:
641 return "DIGITAL";
642 case AST_TRANS_CAP_RESTRICTED_DIGITAL:
643 return "RESTRICTED_DIGITAL";
644 case AST_TRANS_CAP_3_1K_AUDIO:
645 return "3K1AUDIO";
646 case AST_TRANS_CAP_DIGITAL_W_TONES:
647 return "DIGITAL_W_TONES";
648 case AST_TRANS_CAP_VIDEO:
649 return "VIDEO";
650 default:
651 return "UNKNOWN";
655 /*! \brief Pick the best audio codec */
656 int ast_best_codec(int fmts)
658 /* This just our opinion, expressed in code. We are asked to choose
659 the best codec to use, given no information */
660 int x;
661 static int prefs[] =
663 /*! Okay, ulaw is used by all telephony equipment, so start with it */
664 AST_FORMAT_ULAW,
665 /*! Unless of course, you're a silly European, so then prefer ALAW */
666 AST_FORMAT_ALAW,
667 /*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */
668 AST_FORMAT_G722,
669 /*! Okay, well, signed linear is easy to translate into other stuff */
670 AST_FORMAT_SLINEAR,
671 /*! G.726 is standard ADPCM, in RFC3551 packing order */
672 AST_FORMAT_G726,
673 /*! G.726 is standard ADPCM, in AAL2 packing order */
674 AST_FORMAT_G726_AAL2,
675 /*! ADPCM has great sound quality and is still pretty easy to translate */
676 AST_FORMAT_ADPCM,
677 /*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
678 translate and sounds pretty good */
679 AST_FORMAT_GSM,
680 /*! iLBC is not too bad */
681 AST_FORMAT_ILBC,
682 /*! Speex is free, but computationally more expensive than GSM */
683 AST_FORMAT_SPEEX,
684 /*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
685 to use it */
686 AST_FORMAT_LPC10,
687 /*! G.729a is faster than 723 and slightly less expensive */
688 AST_FORMAT_G729A,
689 /*! Down to G.723.1 which is proprietary but at least designed for voice */
690 AST_FORMAT_G723_1,
693 /* Strip out video */
694 fmts &= AST_FORMAT_AUDIO_MASK;
696 /* Find the first preferred codec in the format given */
697 for (x=0; x < (sizeof(prefs) / sizeof(prefs[0]) ); x++)
698 if (fmts & prefs[x])
699 return prefs[x];
700 ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts);
701 return 0;
704 static const struct ast_channel_tech null_tech = {
705 .type = "NULL",
706 .description = "Null channel (should not see this)",
709 /*! \brief Create a new channel structure */
710 struct ast_channel *ast_channel_alloc(int needqueue, int state, const char *cid_num, const char *cid_name, const char *acctcode, const char *exten, const char *context, const int amaflag, const char *name_fmt, ...)
712 struct ast_channel *tmp;
713 int x;
714 int flags;
715 struct varshead *headp;
716 va_list ap1, ap2;
718 /* If shutting down, don't allocate any new channels */
719 if (shutting_down) {
720 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
721 return NULL;
724 if (!(tmp = ast_calloc(1, sizeof(*tmp))))
725 return NULL;
727 if (!(tmp->sched = sched_context_create())) {
728 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
729 free(tmp);
730 return NULL;
733 if ((ast_string_field_init(tmp, 128))) {
734 sched_context_destroy(tmp->sched);
735 free(tmp);
736 return NULL;
739 /* Don't bother initializing the last two FD here, because they
740 will *always* be set just a few lines down (AST_TIMING_FD,
741 AST_ALERT_FD). */
742 for (x = 0; x < AST_MAX_FDS - 2; x++)
743 tmp->fds[x] = -1;
745 #ifdef HAVE_ZAPTEL
746 tmp->timingfd = open("/dev/zap/timer", O_RDWR);
747 if (tmp->timingfd > -1) {
748 /* Check if timing interface supports new
749 ping/pong scheme */
750 flags = 1;
751 if (!ioctl(tmp->timingfd, ZT_TIMERPONG, &flags))
752 needqueue = 0;
754 #else
755 tmp->timingfd = -1;
756 #endif
758 if (needqueue) {
759 if (pipe(tmp->alertpipe)) {
760 ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
761 #ifdef HAVE_ZAPTEL
762 if (tmp->timingfd > -1)
763 close(tmp->timingfd);
764 #endif
765 sched_context_destroy(tmp->sched);
766 ast_string_field_free_memory(tmp);
767 free(tmp);
768 return NULL;
769 } else {
770 flags = fcntl(tmp->alertpipe[0], F_GETFL);
771 fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK);
772 flags = fcntl(tmp->alertpipe[1], F_GETFL);
773 fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK);
775 } else /* Make sure we've got it done right if they don't */
776 tmp->alertpipe[0] = tmp->alertpipe[1] = -1;
778 /* Always watch the alertpipe */
779 tmp->fds[AST_ALERT_FD] = tmp->alertpipe[0];
780 /* And timing pipe */
781 tmp->fds[AST_TIMING_FD] = tmp->timingfd;
782 ast_string_field_set(tmp, name, "**Unknown**");
784 /* Initial state */
785 tmp->_state = state;
787 tmp->streamid = -1;
789 tmp->fin = global_fin;
790 tmp->fout = global_fout;
792 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
793 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL),
794 ast_atomic_fetchadd_int(&uniqueint, 1));
795 } else {
796 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME,
797 (long) time(NULL), ast_atomic_fetchadd_int(&uniqueint, 1));
800 tmp->cid.cid_name = ast_strdup(cid_name);
801 tmp->cid.cid_num = ast_strdup(cid_num);
803 if (!ast_strlen_zero(name_fmt)) {
804 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
805 * And they all use slightly different formats for their name string.
806 * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
807 * This means, that the stringfields must have a routine that takes the va_lists directly, and
808 * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
809 * This new function was written so this can be accomplished.
811 va_start(ap1, name_fmt);
812 va_start(ap2, name_fmt);
813 ast_string_field_build_va(tmp, name, name_fmt, ap1, ap2);
814 va_end(ap1);
815 va_end(ap2);
818 /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */
820 /* These 4 variables need to be set up for the cdr_init() to work right */
821 if (amaflag)
822 tmp->amaflags = amaflag;
823 else
824 tmp->amaflags = ast_default_amaflags;
826 if (!ast_strlen_zero(acctcode))
827 ast_string_field_set(tmp, accountcode, acctcode);
828 else
829 ast_string_field_set(tmp, accountcode, ast_default_accountcode);
831 if (!ast_strlen_zero(context))
832 ast_copy_string(tmp->context, context, sizeof(tmp->context));
833 else
834 strcpy(tmp->context, "default");
836 if (!ast_strlen_zero(exten))
837 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten));
838 else
839 strcpy(tmp->exten, "s");
841 tmp->priority = 1;
843 tmp->cdr = ast_cdr_alloc();
844 ast_cdr_init(tmp->cdr, tmp);
845 ast_cdr_start(tmp->cdr);
847 headp = &tmp->varshead;
848 AST_LIST_HEAD_INIT_NOLOCK(headp);
850 ast_mutex_init(&tmp->lock);
852 AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores);
854 ast_string_field_set(tmp, language, defaultlanguage);
856 tmp->tech = &null_tech;
858 AST_LIST_LOCK(&channels);
859 AST_LIST_INSERT_HEAD(&channels, tmp, chan_list);
860 AST_LIST_UNLOCK(&channels);
862 /*\!note
863 * and now, since the channel structure is built, and has its name, let's
864 * call the manager event generator with this Newchannel event. This is the
865 * proper and correct place to make this call, but you sure do have to pass
866 * a lot of data into this func to do it here!
868 if (!ast_strlen_zero(name_fmt)) {
869 manager_event(EVENT_FLAG_CALL, "Newchannel",
870 "Channel: %s\r\n"
871 "State: %s\r\n"
872 "CallerIDNum: %s\r\n"
873 "CallerIDName: %s\r\n"
874 "Uniqueid: %s\r\n",
875 tmp->name, ast_state2str(state),
876 S_OR(cid_num, "<unknown>"),
877 S_OR(cid_name, "<unknown>"),
878 tmp->uniqueid);
881 return tmp;
884 /*! \brief Queue an outgoing media frame */
885 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
887 struct ast_frame *f;
888 struct ast_frame *cur;
889 int blah = 1;
890 int qlen = 0;
892 /* Build us a copy and free the original one */
893 if (!(f = ast_frdup(fin))) {
894 ast_log(LOG_WARNING, "Unable to duplicate frame\n");
895 return -1;
897 ast_channel_lock(chan);
899 /* See if the last frame on the queue is a hangup, if so don't queue anything */
900 if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
901 ast_frfree(f);
902 ast_channel_unlock(chan);
903 return 0;
906 /* Count how many frames exist on the queue */
907 AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
908 qlen++;
911 /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
912 if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen > 128)) {
913 if (fin->frametype != AST_FRAME_VOICE) {
914 ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name);
915 CRASH;
916 } else {
917 if (option_debug)
918 ast_log(LOG_DEBUG, "Dropping voice to exceptionally long queue on %s\n", chan->name);
919 ast_frfree(f);
920 ast_channel_unlock(chan);
921 return 0;
924 AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
925 if (chan->alertpipe[1] > -1) {
926 if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
927 ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
928 chan->name, f->frametype, f->subclass, qlen, strerror(errno));
929 #ifdef HAVE_ZAPTEL
930 } else if (chan->timingfd > -1) {
931 ioctl(chan->timingfd, ZT_TIMERPING, &blah);
932 #endif
933 } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
934 pthread_kill(chan->blocker, SIGURG);
936 ast_channel_unlock(chan);
937 return 0;
940 /*! \brief Queue a hangup frame for channel */
941 int ast_queue_hangup(struct ast_channel *chan)
943 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
944 /* Yeah, let's not change a lock-critical value without locking */
945 if (!ast_channel_trylock(chan)) {
946 chan->_softhangup |= AST_SOFTHANGUP_DEV;
947 ast_channel_unlock(chan);
949 return ast_queue_frame(chan, &f);
952 /*! \brief Queue a control frame */
953 int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
955 struct ast_frame f = { AST_FRAME_CONTROL, };
957 f.subclass = control;
959 return ast_queue_frame(chan, &f);
962 /*! \brief Queue a control frame with payload */
963 int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control,
964 const void *data, size_t datalen)
966 struct ast_frame f = { AST_FRAME_CONTROL, };
968 f.subclass = control;
969 f.data = (void *) data;
970 f.datalen = datalen;
972 return ast_queue_frame(chan, &f);
975 /*! \brief Set defer DTMF flag on channel */
976 int ast_channel_defer_dtmf(struct ast_channel *chan)
978 int pre = 0;
980 if (chan) {
981 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
982 ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
984 return pre;
987 /*! \brief Unset defer DTMF flag on channel */
988 void ast_channel_undefer_dtmf(struct ast_channel *chan)
990 if (chan)
991 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
995 * \brief Helper function to find channels.
997 * It supports these modes:
999 * prev != NULL : get channel next in list after prev
1000 * name != NULL : get channel with matching name
1001 * name != NULL && namelen != 0 : get channel whose name starts with prefix
1002 * exten != NULL : get channel whose exten or macroexten matches
1003 * context != NULL && exten != NULL : get channel whose context or macrocontext
1005 * It returns with the channel's lock held. If getting the individual lock fails,
1006 * unlock and retry quickly up to 10 times, then give up.
1008 * \note XXX Note that this code has cost O(N) because of the need to verify
1009 * that the object is still on the global list.
1011 * \note XXX also note that accessing fields (e.g. c->name in ast_log())
1012 * can only be done with the lock held or someone could delete the
1013 * object while we work on it. This causes some ugliness in the code.
1014 * Note that removing the first ast_log() may be harmful, as it would
1015 * shorten the retry period and possibly cause failures.
1016 * We should definitely go for a better scheme that is deadlock-free.
1018 static struct ast_channel *channel_find_locked(const struct ast_channel *prev,
1019 const char *name, const int namelen,
1020 const char *context, const char *exten)
1022 const char *msg = prev ? "deadlock" : "initial deadlock";
1023 int retries;
1024 struct ast_channel *c;
1025 const struct ast_channel *_prev = prev;
1027 for (retries = 0; retries < 10; retries++) {
1028 int done;
1029 AST_LIST_LOCK(&channels);
1030 AST_LIST_TRAVERSE(&channels, c, chan_list) {
1031 prev = _prev;
1032 if (prev) { /* look for next item */
1033 if (c != prev) /* not this one */
1034 continue;
1035 /* found, prepare to return c->next */
1036 if ((c = AST_LIST_NEXT(c, chan_list)) == NULL) break;
1037 /* If prev was the last item on the channel list, then we just
1038 * want to return NULL, instead of trying to deref NULL in the
1039 * next section.
1041 prev = NULL;
1042 /* We want prev to be NULL in case we end up doing more searching through
1043 * the channel list to find the channel (ie: name searching). If we didn't
1044 * set this to NULL the logic would just blow up
1045 * XXX Need a better explanation for this ...
1048 if (name) { /* want match by name */
1049 if ((!namelen && strcasecmp(c->name, name)) ||
1050 (namelen && strncasecmp(c->name, name, namelen)))
1051 continue; /* name match failed */
1052 } else if (exten) {
1053 if (context && strcasecmp(c->context, context) &&
1054 strcasecmp(c->macrocontext, context))
1055 continue; /* context match failed */
1056 if (strcasecmp(c->exten, exten) &&
1057 strcasecmp(c->macroexten, exten))
1058 continue; /* exten match failed */
1060 /* if we get here, c points to the desired record */
1061 break;
1063 /* exit if chan not found or mutex acquired successfully */
1064 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
1065 done = c == NULL || ast_channel_trylock(c) == 0;
1066 if (!done) {
1067 if (option_debug)
1068 ast_log(LOG_DEBUG, "Avoiding %s for channel '%p'\n", msg, c);
1069 if (retries == 9) {
1070 /* We are about to fail due to a deadlock, so report this
1071 * while we still have the list lock.
1073 if (option_debug)
1074 ast_log(LOG_DEBUG, "Failure, could not lock '%p' after %d retries!\n", c, retries);
1075 /* As we have deadlocked, we will skip this channel and
1076 * see if there is another match.
1077 * NOTE: No point doing this for a full-name match,
1078 * as there can be no more matches.
1080 if (!(name && !namelen)) {
1081 prev = c;
1082 retries = -1;
1086 AST_LIST_UNLOCK(&channels);
1087 if (done)
1088 return c;
1089 /* If we reach this point we basically tried to lock a channel and failed. Instead of
1090 * starting from the beginning of the list we can restore our saved pointer to the previous
1091 * channel and start from there.
1093 prev = _prev;
1094 usleep(1); /* give other threads a chance before retrying */
1097 return NULL;
1100 /*! \brief Browse channels in use */
1101 struct ast_channel *ast_channel_walk_locked(const struct ast_channel *prev)
1103 return channel_find_locked(prev, NULL, 0, NULL, NULL);
1106 /*! \brief Get channel by name and lock it */
1107 struct ast_channel *ast_get_channel_by_name_locked(const char *name)
1109 return channel_find_locked(NULL, name, 0, NULL, NULL);
1112 /*! \brief Get channel by name prefix and lock it */
1113 struct ast_channel *ast_get_channel_by_name_prefix_locked(const char *name, const int namelen)
1115 return channel_find_locked(NULL, name, namelen, NULL, NULL);
1118 /*! \brief Get next channel by name prefix and lock it */
1119 struct ast_channel *ast_walk_channel_by_name_prefix_locked(const struct ast_channel *chan, const char *name,
1120 const int namelen)
1122 return channel_find_locked(chan, name, namelen, NULL, NULL);
1125 /*! \brief Get channel by exten (and optionally context) and lock it */
1126 struct ast_channel *ast_get_channel_by_exten_locked(const char *exten, const char *context)
1128 return channel_find_locked(NULL, NULL, 0, context, exten);
1131 /*! \brief Get next channel by exten (and optionally context) and lock it */
1132 struct ast_channel *ast_walk_channel_by_exten_locked(const struct ast_channel *chan, const char *exten,
1133 const char *context)
1135 return channel_find_locked(chan, NULL, 0, context, exten);
1138 /*! \brief Wait, look for hangups and condition arg */
1139 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data)
1141 struct ast_frame *f;
1143 while (ms > 0) {
1144 if (cond && ((*cond)(data) == 0))
1145 return 0;
1146 ms = ast_waitfor(chan, ms);
1147 if (ms < 0)
1148 return -1;
1149 if (ms > 0) {
1150 f = ast_read(chan);
1151 if (!f)
1152 return -1;
1153 ast_frfree(f);
1156 return 0;
1159 /*! \brief Wait, look for hangups */
1160 int ast_safe_sleep(struct ast_channel *chan, int ms)
1162 return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
1165 static void free_cid(struct ast_callerid *cid)
1167 if (cid->cid_dnid)
1168 free(cid->cid_dnid);
1169 if (cid->cid_num)
1170 free(cid->cid_num);
1171 if (cid->cid_name)
1172 free(cid->cid_name);
1173 if (cid->cid_ani)
1174 free(cid->cid_ani);
1175 if (cid->cid_rdnis)
1176 free(cid->cid_rdnis);
1179 /*! \brief Free a channel structure */
1180 void ast_channel_free(struct ast_channel *chan)
1182 int fd;
1183 struct ast_var_t *vardata;
1184 struct ast_frame *f;
1185 struct varshead *headp;
1186 struct ast_datastore *datastore = NULL;
1187 char name[AST_CHANNEL_NAME];
1189 headp=&chan->varshead;
1191 AST_LIST_LOCK(&channels);
1192 if (!AST_LIST_REMOVE(&channels, chan, chan_list)) {
1193 AST_LIST_UNLOCK(&channels);
1194 ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
1196 /* Lock and unlock the channel just to be sure nobody
1197 has it locked still */
1198 ast_channel_lock(chan);
1199 ast_channel_unlock(chan);
1200 if (chan->tech_pvt) {
1201 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
1202 free(chan->tech_pvt);
1205 if (chan->sched)
1206 sched_context_destroy(chan->sched);
1208 ast_copy_string(name, chan->name, sizeof(name));
1210 /* Stop monitoring */
1211 if (chan->monitor)
1212 chan->monitor->stop( chan, 0 );
1214 /* If there is native format music-on-hold state, free it */
1215 if (chan->music_state)
1216 ast_moh_cleanup(chan);
1218 /* Free translators */
1219 if (chan->readtrans)
1220 ast_translator_free_path(chan->readtrans);
1221 if (chan->writetrans)
1222 ast_translator_free_path(chan->writetrans);
1223 if (chan->pbx)
1224 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
1225 free_cid(&chan->cid);
1226 ast_mutex_destroy(&chan->lock);
1227 /* Close pipes if appropriate */
1228 if ((fd = chan->alertpipe[0]) > -1)
1229 close(fd);
1230 if ((fd = chan->alertpipe[1]) > -1)
1231 close(fd);
1232 if ((fd = chan->timingfd) > -1)
1233 close(fd);
1234 while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
1235 ast_frfree(f);
1237 /* Get rid of each of the data stores on the channel */
1238 while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
1239 /* Free the data store */
1240 ast_channel_datastore_free(datastore);
1241 AST_LIST_HEAD_INIT_NOLOCK(&chan->datastores);
1243 /* loop over the variables list, freeing all data and deleting list items */
1244 /* no need to lock the list, as the channel is already locked */
1246 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
1247 ast_var_delete(vardata);
1249 ast_app_group_discard(chan);
1251 /* Destroy the jitterbuffer */
1252 ast_jb_destroy(chan);
1254 ast_string_field_free_memory(chan);
1255 free(chan);
1256 AST_LIST_UNLOCK(&channels);
1258 ast_device_state_changed_literal(name);
1261 struct ast_datastore *ast_channel_datastore_alloc(const struct ast_datastore_info *info, char *uid)
1263 struct ast_datastore *datastore = NULL;
1265 /* Make sure we at least have type so we can identify this */
1266 if (info == NULL) {
1267 return NULL;
1270 /* Allocate memory for datastore and clear it */
1271 datastore = ast_calloc(1, sizeof(*datastore));
1272 if (datastore == NULL) {
1273 return NULL;
1276 datastore->info = info;
1278 datastore->uid = ast_strdup(uid);
1280 return datastore;
1283 int ast_channel_datastore_free(struct ast_datastore *datastore)
1285 int res = 0;
1287 /* Using the destroy function (if present) destroy the data */
1288 if (datastore->info->destroy != NULL && datastore->data != NULL) {
1289 datastore->info->destroy(datastore->data);
1290 datastore->data = NULL;
1293 /* Free allocated UID memory */
1294 if (datastore->uid != NULL) {
1295 free(datastore->uid);
1296 datastore->uid = NULL;
1299 /* Finally free memory used by ourselves */
1300 free(datastore);
1302 return res;
1305 int ast_channel_datastore_inherit(struct ast_channel *from, struct ast_channel *to)
1307 struct ast_datastore *datastore = NULL, *datastore2;
1309 AST_LIST_TRAVERSE(&from->datastores, datastore, entry) {
1310 if (datastore->inheritance > 0) {
1311 datastore2 = ast_channel_datastore_alloc(datastore->info, datastore->uid);
1312 if (datastore2) {
1313 datastore2->data = datastore->info->duplicate(datastore->data);
1314 datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
1315 AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry);
1319 return 0;
1322 int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
1324 int res = 0;
1326 AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
1328 return res;
1331 int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
1333 struct ast_datastore *datastore2 = NULL;
1334 int res = -1;
1336 /* Find our position and remove ourselves */
1337 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore2, entry) {
1338 if (datastore2 == datastore) {
1339 AST_LIST_REMOVE_CURRENT(&chan->datastores, entry);
1340 res = 0;
1341 break;
1344 AST_LIST_TRAVERSE_SAFE_END
1346 return res;
1349 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, char *uid)
1351 struct ast_datastore *datastore = NULL;
1353 if (info == NULL)
1354 return NULL;
1356 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
1357 if (datastore->info == info) {
1358 if (uid != NULL && datastore->uid != NULL) {
1359 if (!strcasecmp(uid, datastore->uid)) {
1360 /* Matched by type AND uid */
1361 break;
1363 } else {
1364 /* Matched by type at least */
1365 break;
1369 AST_LIST_TRAVERSE_SAFE_END
1371 return datastore;
1374 /*! \brief Softly hangup a channel, don't lock */
1375 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
1377 if (option_debug)
1378 ast_log(LOG_DEBUG, "Soft-Hanging up channel '%s'\n", chan->name);
1379 /* Inform channel driver that we need to be hung up, if it cares */
1380 chan->_softhangup |= cause;
1381 ast_queue_frame(chan, &ast_null_frame);
1382 /* Interrupt any poll call or such */
1383 if (ast_test_flag(chan, AST_FLAG_BLOCKING))
1384 pthread_kill(chan->blocker, SIGURG);
1385 return 0;
1388 /*! \brief Softly hangup a channel, lock */
1389 int ast_softhangup(struct ast_channel *chan, int cause)
1391 int res;
1392 ast_channel_lock(chan);
1393 res = ast_softhangup_nolock(chan, cause);
1394 ast_channel_unlock(chan);
1395 return res;
1398 static void free_translation(struct ast_channel *clone)
1400 if (clone->writetrans)
1401 ast_translator_free_path(clone->writetrans);
1402 if (clone->readtrans)
1403 ast_translator_free_path(clone->readtrans);
1404 clone->writetrans = NULL;
1405 clone->readtrans = NULL;
1406 clone->rawwriteformat = clone->nativeformats;
1407 clone->rawreadformat = clone->nativeformats;
1410 /*! \brief Hangup a channel */
1411 int ast_hangup(struct ast_channel *chan)
1413 int res = 0;
1414 struct ast_cdr *cdr = NULL;
1416 /* Don't actually hang up a channel that will masquerade as someone else, or
1417 if someone is going to masquerade as us */
1418 ast_channel_lock(chan);
1420 if (chan->audiohooks) {
1421 ast_audiohook_detach_list(chan->audiohooks);
1422 chan->audiohooks = NULL;
1425 ast_autoservice_stop(chan);
1427 if (chan->masq) {
1428 if (ast_do_masquerade(chan))
1429 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1432 if (chan->masq) {
1433 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
1434 ast_channel_unlock(chan);
1435 return 0;
1437 /* If this channel is one which will be masqueraded into something,
1438 mark it as a zombie already, so we know to free it later */
1439 if (chan->masqr) {
1440 ast_set_flag(chan, AST_FLAG_ZOMBIE);
1441 ast_channel_unlock(chan);
1442 return 0;
1444 free_translation(chan);
1445 /* Close audio stream */
1446 if (chan->stream) {
1447 ast_closestream(chan->stream);
1448 chan->stream = NULL;
1450 /* Close video stream */
1451 if (chan->vstream) {
1452 ast_closestream(chan->vstream);
1453 chan->vstream = NULL;
1455 if (chan->sched) {
1456 sched_context_destroy(chan->sched);
1457 chan->sched = NULL;
1460 if (chan->generatordata) /* Clear any tone stuff remaining */
1461 chan->generator->release(chan, chan->generatordata);
1462 chan->generatordata = NULL;
1463 chan->generator = NULL;
1464 if (chan->cdr) { /* End the CDR if it hasn't already */
1465 ast_cdr_end(chan->cdr);
1466 cdr = chan->cdr;
1467 chan->cdr = NULL;
1469 if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1470 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
1471 "is blocked by thread %ld in procedure %s! Expect a failure\n",
1472 (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
1473 CRASH;
1475 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
1476 if (option_debug)
1477 ast_log(LOG_DEBUG, "Hanging up channel '%s'\n", chan->name);
1478 if (chan->tech->hangup)
1479 res = chan->tech->hangup(chan);
1480 } else {
1481 if (option_debug)
1482 ast_log(LOG_DEBUG, "Hanging up zombie '%s'\n", chan->name);
1485 ast_channel_unlock(chan);
1486 manager_event(EVENT_FLAG_CALL, "Hangup",
1487 "Channel: %s\r\n"
1488 "Uniqueid: %s\r\n"
1489 "Cause: %d\r\n"
1490 "Cause-txt: %s\r\n",
1491 chan->name,
1492 chan->uniqueid,
1493 chan->hangupcause,
1494 ast_cause2str(chan->hangupcause)
1496 ast_channel_free(chan);
1498 if (cdr)
1499 ast_cdr_detach(cdr);
1501 return res;
1504 int ast_answer(struct ast_channel *chan)
1506 int res = 0;
1507 ast_channel_lock(chan);
1508 /* You can't answer an outbound call */
1509 if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
1510 ast_channel_unlock(chan);
1511 return 0;
1513 /* Stop if we're a zombie or need a soft hangup */
1514 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1515 ast_channel_unlock(chan);
1516 return -1;
1518 switch(chan->_state) {
1519 case AST_STATE_RINGING:
1520 case AST_STATE_RING:
1521 if (chan->tech->answer)
1522 res = chan->tech->answer(chan);
1523 ast_setstate(chan, AST_STATE_UP);
1524 ast_cdr_answer(chan->cdr);
1525 break;
1526 case AST_STATE_UP:
1527 ast_cdr_answer(chan->cdr);
1528 break;
1529 default:
1530 break;
1532 chan->visible_indication = 0;
1533 ast_channel_unlock(chan);
1534 return res;
1537 void ast_deactivate_generator(struct ast_channel *chan)
1539 ast_channel_lock(chan);
1540 if (chan->generatordata) {
1541 if (chan->generator && chan->generator->release)
1542 chan->generator->release(chan, chan->generatordata);
1543 chan->generatordata = NULL;
1544 chan->generator = NULL;
1545 chan->fds[AST_GENERATOR_FD] = -1;
1546 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1547 ast_settimeout(chan, 0, NULL, NULL);
1549 ast_channel_unlock(chan);
1552 static int generator_force(const void *data)
1554 /* Called if generator doesn't have data */
1555 void *tmp;
1556 int res;
1557 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL;
1558 struct ast_channel *chan = (struct ast_channel *)data;
1560 ast_channel_lock(chan);
1561 tmp = chan->generatordata;
1562 chan->generatordata = NULL;
1563 if (chan->generator)
1564 generate = chan->generator->generate;
1565 ast_channel_unlock(chan);
1567 if (!tmp || !generate)
1568 return 0;
1570 res = generate(chan, tmp, 0, 160);
1572 chan->generatordata = tmp;
1574 if (res) {
1575 if (option_debug)
1576 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
1577 ast_deactivate_generator(chan);
1580 return 0;
1583 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1585 int res = 0;
1587 ast_channel_lock(chan);
1589 if (chan->generatordata) {
1590 if (chan->generator && chan->generator->release)
1591 chan->generator->release(chan, chan->generatordata);
1592 chan->generatordata = NULL;
1595 ast_prod(chan);
1596 if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1597 res = -1;
1600 if (!res) {
1601 ast_settimeout(chan, 160, generator_force, chan);
1602 chan->generator = gen;
1605 ast_channel_unlock(chan);
1607 return res;
1610 /*! \brief Wait for x amount of time on a file descriptor to have input. */
1611 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1613 int winner = -1;
1614 ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1615 return winner;
1618 /*! \brief Wait for x amount of time on a file descriptor to have input. */
1619 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1620 int *exception, int *outfd, int *ms)
1622 struct timeval start = { 0 , 0 };
1623 struct pollfd *pfds = NULL;
1624 int res;
1625 long rms;
1626 int x, y, max;
1627 int sz;
1628 time_t now = 0;
1629 long whentohangup = 0, diff;
1630 struct ast_channel *winner = NULL;
1631 struct fdmap {
1632 int chan;
1633 int fdno;
1634 } *fdmap = NULL;
1636 if ((sz = n * AST_MAX_FDS + nfds)) {
1637 pfds = alloca(sizeof(*pfds) * sz);
1638 fdmap = alloca(sizeof(*fdmap) * sz);
1641 if (outfd)
1642 *outfd = -99999;
1643 if (exception)
1644 *exception = 0;
1646 /* Perform any pending masquerades */
1647 for (x=0; x < n; x++) {
1648 ast_channel_lock(c[x]);
1649 if (c[x]->masq) {
1650 if (ast_do_masquerade(c[x])) {
1651 ast_log(LOG_WARNING, "Masquerade failed\n");
1652 *ms = -1;
1653 ast_channel_unlock(c[x]);
1654 return NULL;
1657 if (c[x]->whentohangup) {
1658 if (!whentohangup)
1659 time(&now);
1660 diff = c[x]->whentohangup - now;
1661 if (diff < 1) {
1662 /* Should already be hungup */
1663 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1664 ast_channel_unlock(c[x]);
1665 return c[x];
1667 if (!whentohangup || (diff < whentohangup))
1668 whentohangup = diff;
1670 ast_channel_unlock(c[x]);
1672 /* Wait full interval */
1673 rms = *ms;
1674 if (whentohangup) {
1675 rms = whentohangup * 1000; /* timeout in milliseconds */
1676 if (*ms >= 0 && *ms < rms) /* original *ms still smaller */
1677 rms = *ms;
1680 * Build the pollfd array, putting the channels' fds first,
1681 * followed by individual fds. Order is important because
1682 * individual fd's must have priority over channel fds.
1684 max = 0;
1685 for (x=0; x<n; x++) {
1686 for (y=0; y<AST_MAX_FDS; y++) {
1687 fdmap[max].fdno = y; /* fd y is linked to this pfds */
1688 fdmap[max].chan = x; /* channel x is linked to this pfds */
1689 max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1691 CHECK_BLOCKING(c[x]);
1693 /* Add the individual fds */
1694 for (x=0; x<nfds; x++) {
1695 fdmap[max].chan = -1;
1696 max += ast_add_fd(&pfds[max], fds[x]);
1699 if (*ms > 0)
1700 start = ast_tvnow();
1702 if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1703 do {
1704 int kbrms = rms;
1705 if (kbrms > 600000)
1706 kbrms = 600000;
1707 res = poll(pfds, max, kbrms);
1708 if (!res)
1709 rms -= kbrms;
1710 } while (!res && (rms > 0));
1711 } else {
1712 res = poll(pfds, max, rms);
1714 for (x=0; x<n; x++)
1715 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1716 if (res < 0) { /* Simulate a timeout if we were interrupted */
1717 if (errno != EINTR)
1718 *ms = -1;
1719 return NULL;
1721 if (whentohangup) { /* if we have a timeout, check who expired */
1722 time(&now);
1723 for (x=0; x<n; x++) {
1724 if (c[x]->whentohangup && now >= c[x]->whentohangup) {
1725 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1726 if (winner == NULL)
1727 winner = c[x];
1731 if (res == 0) { /* no fd ready, reset timeout and done */
1732 *ms = 0; /* XXX use 0 since we may not have an exact timeout. */
1733 return winner;
1736 * Then check if any channel or fd has a pending event.
1737 * Remember to check channels first and fds last, as they
1738 * must have priority on setting 'winner'
1740 for (x = 0; x < max; x++) {
1741 res = pfds[x].revents;
1742 if (res == 0)
1743 continue;
1744 if (fdmap[x].chan >= 0) { /* this is a channel */
1745 winner = c[fdmap[x].chan]; /* override previous winners */
1746 if (res & POLLPRI)
1747 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1748 else
1749 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1750 winner->fdno = fdmap[x].fdno;
1751 } else { /* this is an fd */
1752 if (outfd)
1753 *outfd = pfds[x].fd;
1754 if (exception)
1755 *exception = (res & POLLPRI) ? -1 : 0;
1756 winner = NULL;
1759 if (*ms > 0) {
1760 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1761 if (*ms < 0)
1762 *ms = 0;
1764 return winner;
1767 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
1769 return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
1772 int ast_waitfor(struct ast_channel *c, int ms)
1774 int oldms = ms; /* -1 if no timeout */
1776 ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
1777 if ((ms < 0) && (oldms < 0))
1778 ms = 0;
1779 return ms;
1782 /* XXX never to be called with ms = -1 */
1783 int ast_waitfordigit(struct ast_channel *c, int ms)
1785 return ast_waitfordigit_full(c, ms, -1, -1);
1788 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(const void *data), void *data)
1790 int res = -1;
1791 #ifdef HAVE_ZAPTEL
1792 if (c->timingfd > -1) {
1793 if (!func) {
1794 samples = 0;
1795 data = 0;
1797 if (option_debug)
1798 ast_log(LOG_DEBUG, "Scheduling timer at %d sample intervals\n", samples);
1799 res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
1800 c->timingfunc = func;
1801 c->timingdata = data;
1803 #endif
1804 return res;
1807 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
1809 /* Stop if we're a zombie or need a soft hangup */
1810 if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
1811 return -1;
1813 /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
1814 ast_set_flag(c, AST_FLAG_END_DTMF_ONLY);
1816 /* Wait for a digit, no more than ms milliseconds total. */
1817 while (ms) {
1818 struct ast_channel *rchan;
1819 int outfd;
1821 errno = 0;
1822 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
1823 if (!rchan && outfd < 0 && ms) {
1824 if (errno == 0 || errno == EINTR)
1825 continue;
1826 ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
1827 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
1828 return -1;
1829 } else if (outfd > -1) {
1830 /* The FD we were watching has something waiting */
1831 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
1832 return 1;
1833 } else if (rchan) {
1834 int res;
1835 struct ast_frame *f = ast_read(c);
1836 if (!f)
1837 return -1;
1839 switch(f->frametype) {
1840 case AST_FRAME_DTMF_BEGIN:
1841 break;
1842 case AST_FRAME_DTMF_END:
1843 res = f->subclass;
1844 ast_frfree(f);
1845 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
1846 return res;
1847 case AST_FRAME_CONTROL:
1848 switch(f->subclass) {
1849 case AST_CONTROL_HANGUP:
1850 ast_frfree(f);
1851 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
1852 return -1;
1853 case AST_CONTROL_RINGING:
1854 case AST_CONTROL_ANSWER:
1855 case AST_CONTROL_SRCUPDATE:
1856 /* Unimportant */
1857 break;
1858 default:
1859 ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
1860 break;
1862 break;
1863 case AST_FRAME_VOICE:
1864 /* Write audio if appropriate */
1865 if (audiofd > -1)
1866 write(audiofd, f->data, f->datalen);
1867 default:
1868 /* Ignore */
1869 break;
1871 ast_frfree(f);
1875 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
1877 return 0; /* Time is up */
1880 static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
1882 if (chan->generatordata && !ast_internal_timing_enabled(chan)) {
1883 void *tmp = chan->generatordata;
1884 int res;
1886 if (chan->timingfunc) {
1887 if (option_debug > 1)
1888 ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n");
1889 ast_settimeout(chan, 0, NULL, NULL);
1892 chan->generatordata = NULL; /* reset, to let writes go through */
1893 res = chan->generator->generate(chan, tmp, f->datalen, f->samples);
1894 chan->generatordata = tmp;
1895 if (res) {
1896 if (option_debug > 1)
1897 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
1898 ast_deactivate_generator(chan);
1901 } else if (f->frametype == AST_FRAME_CNG) {
1902 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
1903 if (option_debug > 1)
1904 ast_log(LOG_DEBUG, "Generator got CNG, switching to timed mode\n");
1905 ast_settimeout(chan, 160, generator_force, chan);
1910 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
1912 struct ast_frame *f = NULL; /* the return value */
1913 int blah;
1914 int prestate;
1915 int count = 0;
1917 /* this function is very long so make sure there is only one return
1918 * point at the end (there are only two exceptions to this).
1920 while(ast_channel_trylock(chan)) {
1921 if(count++ > 10)
1922 /*cannot goto done since the channel is not locked*/
1923 return &ast_null_frame;
1924 usleep(1);
1927 if (chan->masq) {
1928 if (ast_do_masquerade(chan))
1929 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1930 else
1931 f = &ast_null_frame;
1932 goto done;
1935 /* Stop if we're a zombie or need a soft hangup */
1936 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1937 if (chan->generator)
1938 ast_deactivate_generator(chan);
1939 goto done;
1941 prestate = chan->_state;
1943 if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) &&
1944 !ast_strlen_zero(chan->dtmfq) &&
1945 (ast_tvzero(chan->dtmf_tv) || ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) > AST_MIN_DTMF_GAP) ) {
1946 /* We have DTMF that has been deferred. Return it now */
1947 chan->dtmff.subclass = chan->dtmfq[0];
1948 /* Drop first digit from the buffer */
1949 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
1950 f = &chan->dtmff;
1951 if (ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) {
1952 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
1953 chan->dtmff.frametype = AST_FRAME_DTMF_END;
1954 } else {
1955 ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %d queued on %s\n", f->subclass, AST_DEFAULT_EMULATE_DTMF_DURATION, chan->name);
1956 chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
1957 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
1958 chan->emulate_dtmf_digit = f->subclass;
1959 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
1961 chan->dtmf_tv = ast_tvnow();
1962 goto done;
1965 /* Read and ignore anything on the alertpipe, but read only
1966 one sizeof(blah) per frame that we send from it */
1967 if (chan->alertpipe[0] > -1)
1968 read(chan->alertpipe[0], &blah, sizeof(blah));
1970 #ifdef HAVE_ZAPTEL
1971 if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
1972 int res;
1974 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
1975 blah = -1;
1976 /* IF we can't get event, assume it's an expired as-per the old interface */
1977 res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
1978 if (res)
1979 blah = ZT_EVENT_TIMER_EXPIRED;
1981 if (blah == ZT_EVENT_TIMER_PING) {
1982 if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
1983 /* Acknowledge PONG unless we need it again */
1984 if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
1985 ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
1988 } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
1989 ioctl(chan->timingfd, ZT_TIMERACK, &blah);
1990 if (chan->timingfunc) {
1991 /* save a copy of func/data before unlocking the channel */
1992 int (*func)(const void *) = chan->timingfunc;
1993 void *data = chan->timingdata;
1994 ast_channel_unlock(chan);
1995 func(data);
1996 } else {
1997 blah = 0;
1998 ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
1999 chan->timingdata = NULL;
2000 ast_channel_unlock(chan);
2002 /* cannot 'goto done' because the channel is already unlocked */
2003 return &ast_null_frame;
2004 } else
2005 ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
2006 } else
2007 #endif
2008 if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
2009 /* if the AST_GENERATOR_FD is set, call the generator with args
2010 * set to -1 so it can do whatever it needs to.
2012 void *tmp = chan->generatordata;
2013 chan->generatordata = NULL; /* reset to let ast_write get through */
2014 chan->generator->generate(chan, tmp, -1, -1);
2015 chan->generatordata = tmp;
2016 f = &ast_null_frame;
2017 goto done;
2020 /* Check for pending read queue */
2021 if (!AST_LIST_EMPTY(&chan->readq)) {
2022 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
2023 /* Interpret hangup and return NULL */
2024 /* XXX why not the same for frames from the channel ? */
2025 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
2026 ast_frfree(f);
2027 f = NULL;
2029 } else {
2030 chan->blocker = pthread_self();
2031 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2032 if (chan->tech->exception)
2033 f = chan->tech->exception(chan);
2034 else {
2035 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
2036 f = &ast_null_frame;
2038 /* Clear the exception flag */
2039 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2040 } else if (chan->tech->read)
2041 f = chan->tech->read(chan);
2042 else
2043 ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
2046 if (f) {
2047 /* if the channel driver returned more than one frame, stuff the excess
2048 into the readq for the next ast_read call (note that we can safely assume
2049 that the readq is empty, because otherwise we would not have called into
2050 the channel driver and f would be only a single frame)
2052 if (AST_LIST_NEXT(f, frame_list)) {
2053 AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
2054 AST_LIST_NEXT(f, frame_list) = NULL;
2057 switch (f->frametype) {
2058 case AST_FRAME_CONTROL:
2059 if (f->subclass == AST_CONTROL_ANSWER) {
2060 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
2061 if (option_debug)
2062 ast_log(LOG_DEBUG, "Ignoring answer on an inbound call!\n");
2063 ast_frfree(f);
2064 f = &ast_null_frame;
2065 } else if (prestate == AST_STATE_UP) {
2066 if (option_debug)
2067 ast_log(LOG_DEBUG, "Dropping duplicate answer!\n");
2068 ast_frfree(f);
2069 f = &ast_null_frame;
2070 } else {
2071 /* Answer the CDR */
2072 ast_setstate(chan, AST_STATE_UP);
2073 if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
2074 to keep from throwing off the basic order of the universe,
2075 we will try to keep this cdr from getting posted. */
2076 chan->cdr = ast_cdr_alloc();
2077 ast_cdr_init(chan->cdr, chan);
2078 ast_cdr_start(chan->cdr);
2081 ast_cdr_answer(chan->cdr);
2084 break;
2085 case AST_FRAME_DTMF_END:
2086 ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass, chan->name, f->len);
2087 /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2088 * However, only let emulation be forced if the other end cares about BEGIN frames */
2089 if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF) ||
2090 (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) ) {
2091 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2092 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2093 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2094 } else
2095 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2096 ast_frfree(f);
2097 f = &ast_null_frame;
2098 } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) {
2099 if (!ast_tvzero(chan->dtmf_tv) &&
2100 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) {
2101 /* If it hasn't been long enough, defer this digit */
2102 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) {
2103 ast_log(LOG_DTMF, "DTMF end '%c' put into dtmf queue on %s\n", f->subclass, chan->name);
2104 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2105 } else
2106 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2107 ast_frfree(f);
2108 f = &ast_null_frame;
2109 } else {
2110 /* There was no begin, turn this into a begin and send the end later */
2111 f->frametype = AST_FRAME_DTMF_BEGIN;
2112 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2113 chan->emulate_dtmf_digit = f->subclass;
2114 chan->dtmf_tv = ast_tvnow();
2115 if (f->len) {
2116 if (f->len > AST_MIN_DTMF_DURATION)
2117 chan->emulate_dtmf_duration = f->len;
2118 else
2119 chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION;
2120 } else
2121 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2122 ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass, chan->emulate_dtmf_duration, chan->name);
2124 if (chan->audiohooks) {
2125 struct ast_frame *old_frame = f;
2126 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2127 if (old_frame != f)
2128 ast_frfree(old_frame);
2130 } else {
2131 struct timeval now = ast_tvnow();
2132 if (ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2133 ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass, chan->name);
2134 ast_clear_flag(chan, AST_FLAG_IN_DTMF);
2135 if (!f->len)
2136 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2137 } else if (!f->len) {
2138 ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass, chan->name);
2139 f->len = AST_MIN_DTMF_DURATION;
2141 if (f->len < AST_MIN_DTMF_DURATION) {
2142 ast_log(LOG_DTMF, "DTMF end '%c' has duration %ld but want minimum %d, emulating on %s\n", f->subclass, f->len, AST_MIN_DTMF_DURATION, chan->name);
2143 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2144 chan->emulate_dtmf_digit = f->subclass;
2145 chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len;
2146 ast_frfree(f);
2147 f = &ast_null_frame;
2148 } else {
2149 ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass, chan->name);
2150 chan->dtmf_tv = now;
2152 if (chan->audiohooks) {
2153 struct ast_frame *old_frame = f;
2154 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2155 if (old_frame != f)
2156 ast_frfree(old_frame);
2159 break;
2160 case AST_FRAME_DTMF_BEGIN:
2161 ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2162 if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY | AST_FLAG_EMULATE_DTMF) ||
2163 (!ast_tvzero(chan->dtmf_tv) &&
2164 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) {
2165 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass, chan->name);
2166 ast_frfree(f);
2167 f = &ast_null_frame;
2168 } else {
2169 ast_set_flag(chan, AST_FLAG_IN_DTMF);
2170 chan->dtmf_tv = ast_tvnow();
2171 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass, chan->name);
2173 break;
2174 case AST_FRAME_NULL:
2175 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2176 * is reached , because we want to make sure we pass at least one
2177 * voice frame through before starting the next digit, to ensure a gap
2178 * between DTMF digits. */
2179 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2180 struct timeval now = ast_tvnow();
2181 if (!chan->emulate_dtmf_duration) {
2182 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2183 chan->emulate_dtmf_digit = 0;
2184 } else if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2185 chan->emulate_dtmf_duration = 0;
2186 ast_frfree(f);
2187 f = &chan->dtmff;
2188 f->frametype = AST_FRAME_DTMF_END;
2189 f->subclass = chan->emulate_dtmf_digit;
2190 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2191 chan->dtmf_tv = now;
2192 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2193 chan->emulate_dtmf_digit = 0;
2194 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2197 break;
2198 case AST_FRAME_VOICE:
2199 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2200 * is reached , because we want to make sure we pass at least one
2201 * voice frame through before starting the next digit, to ensure a gap
2202 * between DTMF digits. */
2203 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) {
2204 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2205 chan->emulate_dtmf_digit = 0;
2208 if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2209 if (dropaudio)
2210 ast_read_generator_actions(chan, f);
2211 ast_frfree(f);
2212 f = &ast_null_frame;
2215 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2216 struct timeval now = ast_tvnow();
2217 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2218 chan->emulate_dtmf_duration = 0;
2219 ast_frfree(f);
2220 f = &chan->dtmff;
2221 f->frametype = AST_FRAME_DTMF_END;
2222 f->subclass = chan->emulate_dtmf_digit;
2223 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2224 chan->dtmf_tv = now;
2225 if (chan->audiohooks) {
2226 struct ast_frame *old_frame = f;
2227 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2228 if (old_frame != f)
2229 ast_frfree(old_frame);
2231 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass, chan->name);
2232 } else {
2233 /* Drop voice frames while we're still in the middle of the digit */
2234 ast_frfree(f);
2235 f = &ast_null_frame;
2237 } else if ((f->frametype == AST_FRAME_VOICE) && !(f->subclass & chan->nativeformats)) {
2238 /* This frame can't be from the current native formats -- drop it on the
2239 floor */
2240 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2241 chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
2242 ast_frfree(f);
2243 f = &ast_null_frame;
2244 } else if ((f->frametype == AST_FRAME_VOICE)) {
2245 if (chan->audiohooks) {
2246 struct ast_frame *old_frame = f;
2247 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f);
2248 if (old_frame != f)
2249 ast_frfree(old_frame);
2251 if (chan->monitor && chan->monitor->read_stream ) {
2252 /* XXX what does this do ? */
2253 #ifndef MONITOR_CONSTANT_DELAY
2254 int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2255 if (jump >= 0) {
2256 jump = chan->outsmpl - chan->insmpl;
2257 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1)
2258 ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2259 chan->insmpl += jump + f->samples;
2260 } else
2261 chan->insmpl+= f->samples;
2262 #else
2263 int jump = chan->outsmpl - chan->insmpl;
2264 if (jump - MONITOR_DELAY >= 0) {
2265 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2266 ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2267 chan->insmpl += jump;
2268 } else
2269 chan->insmpl += f->samples;
2270 #endif
2271 if (chan->monitor->state == AST_MONITOR_RUNNING) {
2272 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2273 ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2277 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
2278 f = &ast_null_frame;
2280 /* Run generator sitting on the line if timing device not available
2281 * and synchronous generation of outgoing frames is necessary */
2282 ast_read_generator_actions(chan, f);
2284 default:
2285 /* Just pass it on! */
2286 break;
2288 } else {
2289 /* Make sure we always return NULL in the future */
2290 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2291 if (chan->generator)
2292 ast_deactivate_generator(chan);
2293 /* End the CDR if appropriate */
2294 if (chan->cdr)
2295 ast_cdr_end(chan->cdr);
2298 /* High bit prints debugging */
2299 if (chan->fin & DEBUGCHAN_FLAG)
2300 ast_frame_dump(chan->name, f, "<<");
2301 chan->fin = FRAMECOUNT_INC(chan->fin);
2303 done:
2304 ast_channel_unlock(chan);
2305 return f;
2308 int ast_internal_timing_enabled(struct ast_channel *chan)
2310 int ret = ast_opt_internal_timing && chan->timingfd > -1;
2311 if (option_debug > 4)
2312 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);
2313 return ret;
2316 struct ast_frame *ast_read(struct ast_channel *chan)
2318 return __ast_read(chan, 0);
2321 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2323 return __ast_read(chan, 1);
2326 int ast_indicate(struct ast_channel *chan, int condition)
2328 return ast_indicate_data(chan, condition, NULL, 0);
2331 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
2333 int res = -1;
2335 ast_channel_lock(chan);
2336 /* Stop if we're a zombie or need a soft hangup */
2337 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2338 ast_channel_unlock(chan);
2339 return -1;
2341 if (chan->tech->indicate)
2342 res = chan->tech->indicate(chan, condition, data, datalen);
2343 ast_channel_unlock(chan);
2344 if (!chan->tech->indicate || res) {
2346 * Device does not support (that) indication, lets fake
2347 * it by doing our own tone generation. (PM2002)
2349 if (condition < 0)
2350 ast_playtones_stop(chan);
2351 else {
2352 const struct tone_zone_sound *ts = NULL;
2353 switch (condition) {
2354 case AST_CONTROL_RINGING:
2355 ts = ast_get_indication_tone(chan->zone, "ring");
2356 break;
2357 case AST_CONTROL_BUSY:
2358 ts = ast_get_indication_tone(chan->zone, "busy");
2359 break;
2360 case AST_CONTROL_CONGESTION:
2361 ts = ast_get_indication_tone(chan->zone, "congestion");
2362 break;
2364 if (ts && ts->data[0]) {
2365 if (option_debug)
2366 ast_log(LOG_DEBUG, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2367 ast_playtones_start(chan,0,ts->data, 1);
2368 res = 0;
2369 chan->visible_indication = condition;
2370 } else if (condition == AST_CONTROL_PROGRESS) {
2371 /* ast_playtones_stop(chan); */
2372 } else if (condition == AST_CONTROL_PROCEEDING) {
2373 /* Do nothing, really */
2374 } else if (condition == AST_CONTROL_HOLD) {
2375 /* Do nothing.... */
2376 } else if (condition == AST_CONTROL_UNHOLD) {
2377 /* Do nothing.... */
2378 } else if (condition == AST_CONTROL_VIDUPDATE) {
2379 /* Do nothing.... */
2380 } else if (condition == AST_CONTROL_SRCUPDATE) {
2381 /* Do nothing... */
2382 } else {
2383 /* not handled */
2384 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2385 res = -1;
2388 } else
2389 chan->visible_indication = condition;
2391 return res;
2394 int ast_recvchar(struct ast_channel *chan, int timeout)
2396 int c;
2397 char *buf = ast_recvtext(chan, timeout);
2398 if (buf == NULL)
2399 return -1; /* error or timeout */
2400 c = *(unsigned char *)buf;
2401 free(buf);
2402 return c;
2405 char *ast_recvtext(struct ast_channel *chan, int timeout)
2407 int res, done = 0;
2408 char *buf = NULL;
2410 while (!done) {
2411 struct ast_frame *f;
2412 if (ast_check_hangup(chan))
2413 break;
2414 res = ast_waitfor(chan, timeout);
2415 if (res <= 0) /* timeout or error */
2416 break;
2417 timeout = res; /* update timeout */
2418 f = ast_read(chan);
2419 if (f == NULL)
2420 break; /* no frame */
2421 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2422 done = 1; /* force a break */
2423 else if (f->frametype == AST_FRAME_TEXT) { /* what we want */
2424 buf = ast_strndup((char *) f->data, f->datalen); /* dup and break */
2425 done = 1;
2427 ast_frfree(f);
2429 return buf;
2432 int ast_sendtext(struct ast_channel *chan, const char *text)
2434 int res = 0;
2435 /* Stop if we're a zombie or need a soft hangup */
2436 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2437 return -1;
2438 CHECK_BLOCKING(chan);
2439 if (chan->tech->send_text)
2440 res = chan->tech->send_text(chan, text);
2441 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2442 return res;
2445 int ast_senddigit_begin(struct ast_channel *chan, char digit)
2447 /* Device does not support DTMF tones, lets fake
2448 * it by doing our own generation. */
2449 static const char* dtmf_tones[] = {
2450 "941+1336", /* 0 */
2451 "697+1209", /* 1 */
2452 "697+1336", /* 2 */
2453 "697+1477", /* 3 */
2454 "770+1209", /* 4 */
2455 "770+1336", /* 5 */
2456 "770+1477", /* 6 */
2457 "852+1209", /* 7 */
2458 "852+1336", /* 8 */
2459 "852+1477", /* 9 */
2460 "697+1633", /* A */
2461 "770+1633", /* B */
2462 "852+1633", /* C */
2463 "941+1633", /* D */
2464 "941+1209", /* * */
2465 "941+1477" /* # */
2468 if (!chan->tech->send_digit_begin)
2469 return 0;
2471 if (!chan->tech->send_digit_begin(chan, digit))
2472 return 0;
2474 if (digit >= '0' && digit <='9')
2475 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2476 else if (digit >= 'A' && digit <= 'D')
2477 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2478 else if (digit == '*')
2479 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2480 else if (digit == '#')
2481 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2482 else {
2483 /* not handled */
2484 if (option_debug)
2485 ast_log(LOG_DEBUG, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2488 return 0;
2491 int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
2493 int res = -1;
2495 if (chan->tech->send_digit_end)
2496 res = chan->tech->send_digit_end(chan, digit, duration);
2498 if (res && chan->generator)
2499 ast_playtones_stop(chan);
2501 return 0;
2504 int ast_senddigit(struct ast_channel *chan, char digit)
2506 if (chan->tech->send_digit_begin) {
2507 ast_senddigit_begin(chan, digit);
2508 ast_safe_sleep(chan, AST_DEFAULT_EMULATE_DTMF_DURATION);
2511 return ast_senddigit_end(chan, digit, AST_DEFAULT_EMULATE_DTMF_DURATION);
2514 int ast_prod(struct ast_channel *chan)
2516 struct ast_frame a = { AST_FRAME_VOICE };
2517 char nothing[128];
2519 /* Send an empty audio frame to get things moving */
2520 if (chan->_state != AST_STATE_UP) {
2521 if (option_debug)
2522 ast_log(LOG_DEBUG, "Prodding channel '%s'\n", chan->name);
2523 a.subclass = chan->rawwriteformat;
2524 a.data = nothing + AST_FRIENDLY_OFFSET;
2525 a.src = "ast_prod";
2526 if (ast_write(chan, &a))
2527 ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2529 return 0;
2532 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2534 int res;
2535 if (!chan->tech->write_video)
2536 return 0;
2537 res = ast_write(chan, fr);
2538 if (!res)
2539 res = 1;
2540 return res;
2543 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2545 int res = -1;
2546 int count = 0;
2547 struct ast_frame *f = NULL, *f2 = NULL;
2549 /*Deadlock avoidance*/
2550 while(ast_channel_trylock(chan)) {
2551 /*cannot goto done since the channel is not locked*/
2552 if(count++ > 10) {
2553 if(option_debug)
2554 ast_log(LOG_DEBUG, "Deadlock avoided for write to channel '%s'\n", chan->name);
2555 return 0;
2557 usleep(1);
2559 /* Stop if we're a zombie or need a soft hangup */
2560 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2561 goto done;
2563 /* Handle any pending masquerades */
2564 if (chan->masq && ast_do_masquerade(chan)) {
2565 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2566 goto done;
2568 if (chan->masqr) {
2569 res = 0; /* XXX explain, why 0 ? */
2570 goto done;
2572 if (chan->generatordata) {
2573 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
2574 ast_deactivate_generator(chan);
2575 else {
2576 if (fr->frametype == AST_FRAME_DTMF_END) {
2577 /* There is a generator running while we're in the middle of a digit.
2578 * It's probably inband DTMF, so go ahead and pass it so it can
2579 * stop the generator */
2580 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2581 ast_channel_unlock(chan);
2582 res = ast_senddigit_end(chan, fr->subclass, fr->len);
2583 ast_channel_lock(chan);
2584 CHECK_BLOCKING(chan);
2585 } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
2586 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
2587 res = (chan->tech->indicate == NULL) ? 0 :
2588 chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2590 res = 0; /* XXX explain, why 0 ? */
2591 goto done;
2594 /* High bit prints debugging */
2595 if (chan->fout & DEBUGCHAN_FLAG)
2596 ast_frame_dump(chan->name, fr, ">>");
2597 CHECK_BLOCKING(chan);
2598 switch(fr->frametype) {
2599 case AST_FRAME_CONTROL:
2600 res = (chan->tech->indicate == NULL) ? 0 :
2601 chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2602 break;
2603 case AST_FRAME_DTMF_BEGIN:
2604 if (chan->audiohooks) {
2605 struct ast_frame *old_frame = fr;
2606 fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2607 if (old_frame != fr)
2608 f = fr;
2610 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2611 ast_channel_unlock(chan);
2612 res = ast_senddigit_begin(chan, fr->subclass);
2613 ast_channel_lock(chan);
2614 CHECK_BLOCKING(chan);
2615 break;
2616 case AST_FRAME_DTMF_END:
2617 if (chan->audiohooks) {
2618 struct ast_frame *old_frame = fr;
2619 fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2620 if (old_frame != fr)
2621 f = fr;
2623 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2624 ast_channel_unlock(chan);
2625 res = ast_senddigit_end(chan, fr->subclass, fr->len);
2626 ast_channel_lock(chan);
2627 CHECK_BLOCKING(chan);
2628 break;
2629 case AST_FRAME_TEXT:
2630 res = (chan->tech->send_text == NULL) ? 0 :
2631 chan->tech->send_text(chan, (char *) fr->data);
2632 break;
2633 case AST_FRAME_HTML:
2634 res = (chan->tech->send_html == NULL) ? 0 :
2635 chan->tech->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen);
2636 break;
2637 case AST_FRAME_VIDEO:
2638 /* XXX Handle translation of video codecs one day XXX */
2639 res = (chan->tech->write_video == NULL) ? 0 :
2640 chan->tech->write_video(chan, fr);
2641 break;
2642 case AST_FRAME_MODEM:
2643 res = (chan->tech->write == NULL) ? 0 :
2644 chan->tech->write(chan, fr);
2645 break;
2646 case AST_FRAME_VOICE:
2647 if (chan->tech->write == NULL)
2648 break; /*! \todo XXX should return 0 maybe ? */
2650 if (chan->audiohooks) {
2651 struct ast_frame *old_frame = fr;
2652 fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
2653 if (old_frame != fr)
2654 f2 = fr;
2657 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
2658 if (fr->subclass == chan->rawwriteformat)
2659 f = fr;
2660 else
2661 f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
2663 /* If we have no frame of audio, then we have to bail out */
2664 if (!f) {
2665 res = 0;
2666 break;
2669 /* If Monitor is running on this channel, then we have to write frames out there too */
2670 if (chan->monitor && chan->monitor->write_stream) {
2671 /* XXX must explain this code */
2672 #ifndef MONITOR_CONSTANT_DELAY
2673 int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
2674 if (jump >= 0) {
2675 jump = chan->insmpl - chan->outsmpl;
2676 if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
2677 ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2678 chan->outsmpl += jump + f->samples;
2679 } else
2680 chan->outsmpl += f->samples;
2681 #else
2682 int jump = chan->insmpl - chan->outsmpl;
2683 if (jump - MONITOR_DELAY >= 0) {
2684 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2685 ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2686 chan->outsmpl += jump;
2687 } else
2688 chan->outsmpl += f->samples;
2689 #endif
2690 if (chan->monitor->state == AST_MONITOR_RUNNING) {
2691 if (ast_writestream(chan->monitor->write_stream, f) < 0)
2692 ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
2696 if (f)
2697 res = chan->tech->write(chan,f);
2698 else
2699 res = 0;
2700 break;
2701 case AST_FRAME_NULL:
2702 case AST_FRAME_IAX:
2703 /* Ignore these */
2704 res = 0;
2705 break;
2706 default:
2707 /* At this point, fr is the incoming frame and f is NULL. Channels do
2708 * not expect to get NULL as a frame pointer and will segfault. Hence,
2709 * we output the original frame passed in. */
2710 res = chan->tech->write(chan, fr);
2711 break;
2714 if (f && f != fr)
2715 ast_frfree(f);
2716 if (f2)
2717 ast_frfree(f2);
2718 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2719 /* Consider a write failure to force a soft hangup */
2720 if (res < 0)
2721 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2722 else {
2723 chan->fout = FRAMECOUNT_INC(chan->fout);
2725 done:
2726 ast_channel_unlock(chan);
2727 return res;
2730 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
2731 struct ast_trans_pvt **trans, const int direction)
2733 int native;
2734 int res;
2736 /* Make sure we only consider audio */
2737 fmt &= AST_FORMAT_AUDIO_MASK;
2739 native = chan->nativeformats;
2740 /* Find a translation path from the native format to one of the desired formats */
2741 if (!direction)
2742 /* reading */
2743 res = ast_translator_best_choice(&fmt, &native);
2744 else
2745 /* writing */
2746 res = ast_translator_best_choice(&native, &fmt);
2748 if (res < 0) {
2749 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
2750 ast_getformatname(native), ast_getformatname(fmt));
2751 return -1;
2754 /* Now we have a good choice for both. */
2755 ast_channel_lock(chan);
2757 if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
2758 /* the channel is already in these formats, so nothing to do */
2759 ast_channel_unlock(chan);
2760 return 0;
2763 *rawformat = native;
2764 /* User perspective is fmt */
2765 *format = fmt;
2766 /* Free any read translation we have right now */
2767 if (*trans)
2768 ast_translator_free_path(*trans);
2769 /* Build a translation path from the raw format to the desired format */
2770 if (!direction)
2771 /* reading */
2772 *trans = ast_translator_build_path(*format, *rawformat);
2773 else
2774 /* writing */
2775 *trans = ast_translator_build_path(*rawformat, *format);
2776 ast_channel_unlock(chan);
2777 if (option_debug)
2778 ast_log(LOG_DEBUG, "Set channel %s to %s format %s\n", chan->name,
2779 direction ? "write" : "read", ast_getformatname(fmt));
2780 return 0;
2783 int ast_set_read_format(struct ast_channel *chan, int fmt)
2785 return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
2786 &chan->readtrans, 0);
2789 int ast_set_write_format(struct ast_channel *chan, int fmt)
2791 return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
2792 &chan->writetrans, 1);
2795 char *ast_channel_reason2str(int reason)
2797 switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */
2799 case 0:
2800 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
2801 case AST_CONTROL_HANGUP:
2802 return "Hangup";
2803 case AST_CONTROL_RING:
2804 return "Local Ring";
2805 case AST_CONTROL_RINGING:
2806 return "Remote end Ringing";
2807 case AST_CONTROL_ANSWER:
2808 return "Remote end has Answered";
2809 case AST_CONTROL_BUSY:
2810 return "Remote end is Busy";
2811 case AST_CONTROL_CONGESTION:
2812 return "Congestion (circuits busy)";
2813 default:
2814 return "Unknown Reason!!";
2818 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)
2820 int dummy_outstate;
2821 int cause = 0;
2822 struct ast_channel *chan;
2823 int res = 0;
2824 int last_subclass = 0;
2826 if (outstate)
2827 *outstate = 0;
2828 else
2829 outstate = &dummy_outstate; /* make outstate always a valid pointer */
2831 chan = ast_request(type, format, data, &cause);
2832 if (!chan) {
2833 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
2834 /* compute error and return */
2835 if (cause == AST_CAUSE_BUSY)
2836 *outstate = AST_CONTROL_BUSY;
2837 else if (cause == AST_CAUSE_CONGESTION)
2838 *outstate = AST_CONTROL_CONGESTION;
2839 return NULL;
2842 if (oh) {
2843 if (oh->vars)
2844 ast_set_variables(chan, oh->vars);
2845 /* XXX why is this necessary, for the parent_channel perhaps ? */
2846 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
2847 ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
2848 if (oh->parent_channel)
2849 ast_channel_inherit_variables(oh->parent_channel, chan);
2850 if (oh->account)
2851 ast_cdr_setaccount(chan, oh->account);
2853 ast_set_callerid(chan, cid_num, cid_name, cid_num);
2857 if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
2858 to keep from throwing off the basic order of the universe,
2859 we will try to keep this cdr from getting posted. */
2860 chan->cdr = ast_cdr_alloc();
2861 ast_cdr_init(chan->cdr, chan);
2862 ast_cdr_start(chan->cdr);
2864 if (ast_call(chan, data, 0)) { /* ast_call failed... */
2865 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
2866 } else {
2867 res = 1; /* mark success in case chan->_state is already AST_STATE_UP */
2868 while (timeout && chan->_state != AST_STATE_UP) {
2869 struct ast_frame *f;
2870 res = ast_waitfor(chan, timeout);
2871 if (res <= 0) /* error, timeout, or done */
2872 break;
2873 if (timeout > -1)
2874 timeout = res;
2875 f = ast_read(chan);
2876 if (!f) {
2877 *outstate = AST_CONTROL_HANGUP;
2878 res = 0;
2879 break;
2881 if (f->frametype == AST_FRAME_CONTROL) {
2882 switch (f->subclass) {
2883 case AST_CONTROL_RINGING: /* record but keep going */
2884 *outstate = f->subclass;
2885 break;
2887 case AST_CONTROL_BUSY:
2888 case AST_CONTROL_CONGESTION:
2889 case AST_CONTROL_ANSWER:
2890 *outstate = f->subclass;
2891 timeout = 0; /* trick to force exit from the while() */
2892 break;
2894 /* Ignore these */
2895 case AST_CONTROL_PROGRESS:
2896 case AST_CONTROL_PROCEEDING:
2897 case AST_CONTROL_HOLD:
2898 case AST_CONTROL_UNHOLD:
2899 case AST_CONTROL_VIDUPDATE:
2900 case AST_CONTROL_SRCUPDATE:
2901 case -1: /* Ignore -- just stopping indications */
2902 break;
2904 default:
2905 ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
2907 last_subclass = f->subclass;
2909 ast_frfree(f);
2913 /* Final fixups */
2914 if (oh) {
2915 if (!ast_strlen_zero(oh->context))
2916 ast_copy_string(chan->context, oh->context, sizeof(chan->context));
2917 if (!ast_strlen_zero(oh->exten))
2918 ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
2919 if (oh->priority)
2920 chan->priority = oh->priority;
2922 if (chan->_state == AST_STATE_UP)
2923 *outstate = AST_CONTROL_ANSWER;
2925 if (res <= 0) {
2926 if ( AST_CONTROL_RINGING == last_subclass )
2927 chan->hangupcause = AST_CAUSE_NO_ANSWER;
2928 if (!chan->cdr && (chan->cdr = ast_cdr_alloc()))
2929 ast_cdr_init(chan->cdr, chan);
2930 if (chan->cdr) {
2931 char tmp[256];
2932 snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data);
2933 ast_cdr_setapp(chan->cdr,"Dial",tmp);
2934 ast_cdr_update(chan);
2935 ast_cdr_start(chan->cdr);
2936 ast_cdr_end(chan->cdr);
2937 /* If the cause wasn't handled properly */
2938 if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
2939 ast_cdr_failed(chan->cdr);
2941 ast_hangup(chan);
2942 chan = NULL;
2944 return chan;
2947 struct ast_channel *ast_request_and_dial(const char *type, int format, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname)
2949 return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
2952 struct ast_channel *ast_request(const char *type, int format, void *data, int *cause)
2954 struct chanlist *chan;
2955 struct ast_channel *c;
2956 int capabilities;
2957 int fmt;
2958 int res;
2959 int foo;
2960 int videoformat = format & AST_FORMAT_VIDEO_MASK;
2962 if (!cause)
2963 cause = &foo;
2964 *cause = AST_CAUSE_NOTDEFINED;
2966 if (AST_LIST_LOCK(&channels)) {
2967 ast_log(LOG_WARNING, "Unable to lock channel list\n");
2968 return NULL;
2971 AST_LIST_TRAVERSE(&backends, chan, list) {
2972 if (strcasecmp(type, chan->tech->type))
2973 continue;
2975 capabilities = chan->tech->capabilities;
2976 fmt = format & AST_FORMAT_AUDIO_MASK;
2977 res = ast_translator_best_choice(&fmt, &capabilities);
2978 if (res < 0) {
2979 ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %d) to %d\n", type, chan->tech->capabilities, format);
2980 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
2981 AST_LIST_UNLOCK(&channels);
2982 return NULL;
2984 AST_LIST_UNLOCK(&channels);
2985 if (!chan->tech->requester)
2986 return NULL;
2988 if (!(c = chan->tech->requester(type, capabilities | videoformat, data, cause)))
2989 return NULL;
2991 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
2992 return c;
2995 ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
2996 *cause = AST_CAUSE_NOSUCHDRIVER;
2997 AST_LIST_UNLOCK(&channels);
2999 return NULL;
3002 int ast_call(struct ast_channel *chan, char *addr, int timeout)
3004 /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
3005 If the remote end does not answer within the timeout, then do NOT hang up, but
3006 return anyway. */
3007 int res = -1;
3008 /* Stop if we're a zombie or need a soft hangup */
3009 ast_channel_lock(chan);
3010 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
3011 if (chan->tech->call)
3012 res = chan->tech->call(chan, addr, timeout);
3013 ast_set_flag(chan, AST_FLAG_OUTGOING);
3015 ast_channel_unlock(chan);
3016 return res;
3020 \brief Transfer a call to dest, if the channel supports transfer
3022 Called by:
3023 \arg app_transfer
3024 \arg the manager interface
3026 int ast_transfer(struct ast_channel *chan, char *dest)
3028 int res = -1;
3030 /* Stop if we're a zombie or need a soft hangup */
3031 ast_channel_lock(chan);
3032 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
3033 if (chan->tech->transfer) {
3034 res = chan->tech->transfer(chan, dest);
3035 if (!res)
3036 res = 1;
3037 } else
3038 res = 0;
3040 ast_channel_unlock(chan);
3041 return res;
3044 int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
3046 return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
3049 int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
3051 int pos = 0; /* index in the buffer where we accumulate digits */
3052 int to = ftimeout;
3054 /* Stop if we're a zombie or need a soft hangup */
3055 if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
3056 return -1;
3057 if (!len)
3058 return -1;
3059 for (;;) {
3060 int d;
3061 if (c->stream) {
3062 d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
3063 ast_stopstream(c);
3064 usleep(1000);
3065 if (!d)
3066 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
3067 } else {
3068 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
3070 if (d < 0)
3071 return -1;
3072 if (d == 0) {
3073 s[pos]='\0';
3074 return 1;
3076 if (d == 1) {
3077 s[pos]='\0';
3078 return 2;
3080 if (!strchr(enders, d))
3081 s[pos++] = d;
3082 if (strchr(enders, d) || (pos >= len)) {
3083 s[pos]='\0';
3084 return 0;
3086 to = timeout;
3088 /* Never reached */
3089 return 0;
3092 int ast_channel_supports_html(struct ast_channel *chan)
3094 return (chan->tech->send_html) ? 1 : 0;
3097 int ast_channel_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen)
3099 if (chan->tech->send_html)
3100 return chan->tech->send_html(chan, subclass, data, datalen);
3101 return -1;
3104 int ast_channel_sendurl(struct ast_channel *chan, const char *url)
3106 return ast_channel_sendhtml(chan, AST_HTML_URL, url, strlen(url) + 1);
3109 int ast_channel_make_compatible(struct ast_channel *chan, struct ast_channel *peer)
3111 int src;
3112 int dst;
3114 if (chan->readformat == peer->writeformat && chan->writeformat == peer->readformat) {
3115 /* Already compatible! Moving on ... */
3116 return 0;
3119 /* Set up translation from the chan to the peer */
3120 src = chan->nativeformats;
3121 dst = peer->nativeformats;
3122 if (ast_translator_best_choice(&dst, &src) < 0) {
3123 ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", chan->name, src, peer->name, dst);
3124 return -1;
3127 /* if the best path is not 'pass through', then
3128 transcoding is needed; if desired, force transcode path
3129 to use SLINEAR between channels, but only if there is
3130 no direct conversion available */
3131 if ((src != dst) && ast_opt_transcode_via_slin &&
3132 (ast_translate_path_steps(dst, src) != 1))
3133 dst = AST_FORMAT_SLINEAR;
3134 if (ast_set_read_format(chan, dst) < 0) {
3135 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", chan->name, dst);
3136 return -1;
3138 if (ast_set_write_format(peer, dst) < 0) {
3139 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", peer->name, dst);
3140 return -1;
3143 /* Set up translation from the peer to the chan */
3144 src = peer->nativeformats;
3145 dst = chan->nativeformats;
3146 if (ast_translator_best_choice(&dst, &src) < 0) {
3147 ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", peer->name, src, chan->name, dst);
3148 return -1;
3151 /* if the best path is not 'pass through', then
3152 transcoding is needed; if desired, force transcode path
3153 to use SLINEAR between channels, but only if there is
3154 no direct conversion available */
3155 if ((src != dst) && ast_opt_transcode_via_slin &&
3156 (ast_translate_path_steps(dst, src) != 1))
3157 dst = AST_FORMAT_SLINEAR;
3158 if (ast_set_read_format(peer, dst) < 0) {
3159 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", peer->name, dst);
3160 return -1;
3162 if (ast_set_write_format(chan, dst) < 0) {
3163 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", chan->name, dst);
3164 return -1;
3166 return 0;
3169 int ast_channel_masquerade(struct ast_channel *original, struct ast_channel *clone)
3171 int res = -1;
3172 struct ast_channel *final_orig, *final_clone, *base;
3174 retrymasq:
3175 final_orig = original;
3176 final_clone = clone;
3178 ast_channel_lock(original);
3179 while (ast_channel_trylock(clone)) {
3180 ast_channel_unlock(original);
3181 usleep(1);
3182 ast_channel_lock(original);
3185 /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent)
3186 and if so, we don't really want to masquerade it, but its proxy */
3187 if (original->_bridge && (original->_bridge != ast_bridged_channel(original)) && (original->_bridge->_bridge != original))
3188 final_orig = original->_bridge;
3190 if (clone->_bridge && (clone->_bridge != ast_bridged_channel(clone)) && (clone->_bridge->_bridge != clone))
3191 final_clone = clone->_bridge;
3193 if (final_clone->tech->get_base_channel && (base = final_clone->tech->get_base_channel(final_clone))) {
3194 final_clone = base;
3197 if ((final_orig != original) || (final_clone != clone)) {
3198 /* Lots and lots of deadlock avoidance. The main one we're competing with
3199 * is ast_write(), which locks channels recursively, when working with a
3200 * proxy channel. */
3201 if (ast_channel_trylock(final_orig)) {
3202 ast_channel_unlock(clone);
3203 ast_channel_unlock(original);
3204 goto retrymasq;
3206 if (ast_channel_trylock(final_clone)) {
3207 ast_channel_unlock(final_orig);
3208 ast_channel_unlock(clone);
3209 ast_channel_unlock(original);
3210 goto retrymasq;
3212 ast_channel_unlock(clone);
3213 ast_channel_unlock(original);
3214 original = final_orig;
3215 clone = final_clone;
3218 if (original == clone) {
3219 ast_log(LOG_WARNING, "Can't masquerade channel '%s' into itself!\n", original->name);
3220 ast_channel_unlock(clone);
3221 ast_channel_unlock(original);
3222 return -1;
3225 if (option_debug)
3226 ast_log(LOG_DEBUG, "Planning to masquerade channel %s into the structure of %s\n",
3227 clone->name, original->name);
3228 if (original->masq) {
3229 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
3230 original->masq->name, original->name);
3231 } else if (clone->masqr) {
3232 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
3233 clone->name, clone->masqr->name);
3234 } else {
3235 original->masq = clone;
3236 clone->masqr = original;
3237 ast_queue_frame(original, &ast_null_frame);
3238 ast_queue_frame(clone, &ast_null_frame);
3239 if (option_debug)
3240 ast_log(LOG_DEBUG, "Done planning to masquerade channel %s into the structure of %s\n", clone->name, original->name);
3241 res = 0;
3244 ast_channel_unlock(clone);
3245 ast_channel_unlock(original);
3247 return res;
3250 void ast_change_name(struct ast_channel *chan, char *newname)
3252 manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan->name, newname, chan->uniqueid);
3253 ast_string_field_set(chan, name, newname);
3256 void ast_channel_inherit_variables(const struct ast_channel *parent, struct ast_channel *child)
3258 struct ast_var_t *current, *newvar;
3259 const char *varname;
3261 AST_LIST_TRAVERSE(&parent->varshead, current, entries) {
3262 int vartype = 0;
3264 varname = ast_var_full_name(current);
3265 if (!varname)
3266 continue;
3268 if (varname[0] == '_') {
3269 vartype = 1;
3270 if (varname[1] == '_')
3271 vartype = 2;
3274 switch (vartype) {
3275 case 1:
3276 newvar = ast_var_assign(&varname[1], ast_var_value(current));
3277 if (newvar) {
3278 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
3279 if (option_debug)
3280 ast_log(LOG_DEBUG, "Copying soft-transferable variable %s.\n", ast_var_name(newvar));
3282 break;
3283 case 2:
3284 newvar = ast_var_assign(ast_var_full_name(current), ast_var_value(current));
3285 if (newvar) {
3286 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
3287 if (option_debug)
3288 ast_log(LOG_DEBUG, "Copying hard-transferable variable %s.\n", ast_var_name(newvar));
3290 break;
3291 default:
3292 if (option_debug)
3293 ast_log(LOG_DEBUG, "Not copying variable %s.\n", ast_var_name(current));
3294 break;
3300 \brief Clone channel variables from 'clone' channel into 'original' channel
3302 All variables except those related to app_groupcount are cloned.
3303 Variables are actually _removed_ from 'clone' channel, presumably
3304 because it will subsequently be destroyed.
3306 \note Assumes locks will be in place on both channels when called.
3308 static void clone_variables(struct ast_channel *original, struct ast_channel *clone)
3310 struct ast_var_t *current, *newvar;
3311 /* Append variables from clone channel into original channel */
3312 /* XXX Is this always correct? We have to in order to keep MACROS working XXX */
3313 if (AST_LIST_FIRST(&clone->varshead))
3314 AST_LIST_APPEND_LIST(&original->varshead, &clone->varshead, entries);
3316 /* then, dup the varshead list into the clone */
3318 AST_LIST_TRAVERSE(&original->varshead, current, entries) {
3319 newvar = ast_var_assign(current->name, current->value);
3320 if (newvar)
3321 AST_LIST_INSERT_TAIL(&clone->varshead, newvar, entries);
3326 \brief Masquerade a channel
3328 \note Assumes channel will be locked when called
3330 int ast_do_masquerade(struct ast_channel *original)
3332 int x,i;
3333 int res=0;
3334 int origstate;
3335 struct ast_frame *cur;
3336 const struct ast_channel_tech *t;
3337 void *t_pvt;
3338 struct ast_callerid tmpcid;
3339 struct ast_channel *clone = original->masq;
3340 struct ast_cdr *cdr;
3341 int rformat = original->readformat;
3342 int wformat = original->writeformat;
3343 char newn[100];
3344 char orig[100];
3345 char masqn[100];
3346 char zombn[100];
3348 if (option_debug > 3)
3349 ast_log(LOG_DEBUG, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
3350 clone->name, clone->_state, original->name, original->_state);
3352 /* XXX This is a seriously wacked out operation. We're essentially putting the guts of
3353 the clone channel into the original channel. Start by killing off the original
3354 channel's backend. I'm not sure we're going to keep this function, because
3355 while the features are nice, the cost is very high in terms of pure nastiness. XXX */
3357 /* We need the clone's lock, too */
3358 ast_channel_lock(clone);
3360 if (option_debug > 1)
3361 ast_log(LOG_DEBUG, "Got clone lock for masquerade on '%s' at %p\n", clone->name, &clone->lock);
3363 /* Having remembered the original read/write formats, we turn off any translation on either
3364 one */
3365 free_translation(clone);
3366 free_translation(original);
3369 /* Unlink the masquerade */
3370 original->masq = NULL;
3371 clone->masqr = NULL;
3373 /* Save the original name */
3374 ast_copy_string(orig, original->name, sizeof(orig));
3375 /* Save the new name */
3376 ast_copy_string(newn, clone->name, sizeof(newn));
3377 /* Create the masq name */
3378 snprintf(masqn, sizeof(masqn), "%s<MASQ>", newn);
3380 /* Copy the name from the clone channel */
3381 ast_string_field_set(original, name, newn);
3383 /* Mangle the name of the clone channel */
3384 ast_string_field_set(clone, name, masqn);
3386 /* Notify any managers of the change, first the masq then the other */
3387 manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", newn, masqn, clone->uniqueid);
3388 manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", orig, newn, original->uniqueid);
3390 /* Swap the technologies */
3391 t = original->tech;
3392 original->tech = clone->tech;
3393 clone->tech = t;
3395 /* Swap the cdrs */
3396 cdr = original->cdr;
3397 original->cdr = clone->cdr;
3398 clone->cdr = cdr;
3400 t_pvt = original->tech_pvt;
3401 original->tech_pvt = clone->tech_pvt;
3402 clone->tech_pvt = t_pvt;
3404 /* Swap the alertpipes */
3405 for (i = 0; i < 2; i++) {
3406 x = original->alertpipe[i];
3407 original->alertpipe[i] = clone->alertpipe[i];
3408 clone->alertpipe[i] = x;
3412 * Swap the readq's. The end result should be this:
3414 * 1) All frames should be on the new (original) channel.
3415 * 2) Any frames that were already on the new channel before this
3416 * masquerade need to be at the end of the readq, after all of the
3417 * frames on the old (clone) channel.
3418 * 3) The alertpipe needs to get poked for every frame that was already
3419 * on the new channel, since we are now using the alert pipe from the
3420 * old (clone) channel.
3423 AST_LIST_HEAD_NOLOCK(, ast_frame) tmp_readq;
3424 AST_LIST_HEAD_SET_NOLOCK(&tmp_readq, NULL);
3426 AST_LIST_APPEND_LIST(&tmp_readq, &original->readq, frame_list);
3427 AST_LIST_APPEND_LIST(&original->readq, &clone->readq, frame_list);
3429 while ((cur = AST_LIST_REMOVE_HEAD(&tmp_readq, frame_list))) {
3430 AST_LIST_INSERT_TAIL(&original->readq, cur, frame_list);
3431 if (original->alertpipe[1] > -1) {
3432 int poke = 0;
3433 write(original->alertpipe[1], &poke, sizeof(poke));
3438 /* Swap the raw formats */
3439 x = original->rawreadformat;
3440 original->rawreadformat = clone->rawreadformat;
3441 clone->rawreadformat = x;
3442 x = original->rawwriteformat;
3443 original->rawwriteformat = clone->rawwriteformat;
3444 clone->rawwriteformat = x;
3446 clone->_softhangup = AST_SOFTHANGUP_DEV;
3448 /* And of course, so does our current state. Note we need not
3449 call ast_setstate since the event manager doesn't really consider
3450 these separate. We do this early so that the clone has the proper
3451 state of the original channel. */
3452 origstate = original->_state;
3453 original->_state = clone->_state;
3454 clone->_state = origstate;
3456 if (clone->tech->fixup){
3457 res = clone->tech->fixup(original, clone);
3458 if (res)
3459 ast_log(LOG_WARNING, "Fixup failed on channel %s, strange things may happen.\n", clone->name);
3462 /* Start by disconnecting the original's physical side */
3463 if (clone->tech->hangup)
3464 res = clone->tech->hangup(clone);
3465 if (res) {
3466 ast_log(LOG_WARNING, "Hangup failed! Strange things may happen!\n");
3467 ast_channel_unlock(clone);
3468 return -1;
3471 snprintf(zombn, sizeof(zombn), "%s<ZOMBIE>", orig);
3472 /* Mangle the name of the clone channel */
3473 ast_string_field_set(clone, name, zombn);
3474 manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", masqn, zombn, clone->uniqueid);
3476 /* Update the type. */
3477 t_pvt = original->monitor;
3478 original->monitor = clone->monitor;
3479 clone->monitor = t_pvt;
3481 /* Keep the same language. */
3482 ast_string_field_set(original, language, clone->language);
3483 /* Copy the FD's other than the generator fd */
3484 for (x = 0; x < AST_MAX_FDS; x++) {
3485 if (x != AST_GENERATOR_FD)
3486 original->fds[x] = clone->fds[x];
3489 ast_app_group_update(clone, original);
3490 /* Move data stores over */
3491 if (AST_LIST_FIRST(&clone->datastores))
3492 AST_LIST_APPEND_LIST(&original->datastores, &clone->datastores, entry);
3494 clone_variables(original, clone);
3495 /* Presense of ADSI capable CPE follows clone */
3496 original->adsicpe = clone->adsicpe;
3497 /* Bridge remains the same */
3498 /* CDR fields remain the same */
3499 /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */
3500 /* Application and data remain the same */
3501 /* Clone exception becomes real one, as with fdno */
3502 ast_copy_flags(original, clone, AST_FLAG_EXCEPTION);
3503 original->fdno = clone->fdno;
3504 /* Schedule context remains the same */
3505 /* Stream stuff stays the same */
3506 /* Keep the original state. The fixup code will need to work with it most likely */
3508 /* Just swap the whole structures, nevermind the allocations, they'll work themselves
3509 out. */
3510 tmpcid = original->cid;
3511 original->cid = clone->cid;
3512 clone->cid = tmpcid;
3514 /* Restore original timing file descriptor */
3515 original->fds[AST_TIMING_FD] = original->timingfd;
3517 /* Our native formats are different now */
3518 original->nativeformats = clone->nativeformats;
3520 /* Context, extension, priority, app data, jump table, remain the same */
3521 /* pvt switches. pbx stays the same, as does next */
3523 /* Set the write format */
3524 ast_set_write_format(original, wformat);
3526 /* Set the read format */
3527 ast_set_read_format(original, rformat);
3529 /* Copy the music class */
3530 ast_string_field_set(original, musicclass, clone->musicclass);
3532 if (option_debug)
3533 ast_log(LOG_DEBUG, "Putting channel %s in %d/%d formats\n", original->name, wformat, rformat);
3535 /* Okay. Last thing is to let the channel driver know about all this mess, so he
3536 can fix up everything as best as possible */
3537 if (original->tech->fixup) {
3538 res = original->tech->fixup(clone, original);
3539 if (res) {
3540 ast_log(LOG_WARNING, "Channel for type '%s' could not fixup channel %s\n",
3541 original->tech->type, original->name);
3542 ast_channel_unlock(clone);
3543 return -1;
3545 } else
3546 ast_log(LOG_WARNING, "Channel type '%s' does not have a fixup routine (for %s)! Bad things may happen.\n",
3547 original->tech->type, original->name);
3549 /* If an indication is currently playing maintain it on the channel that is taking the place of original */
3550 if (original->visible_indication)
3551 ast_indicate(original, original->visible_indication);
3553 /* Now, at this point, the "clone" channel is totally F'd up. We mark it as
3554 a zombie so nothing tries to touch it. If it's already been marked as a
3555 zombie, then free it now (since it already is considered invalid). */
3556 if (ast_test_flag(clone, AST_FLAG_ZOMBIE)) {
3557 if (option_debug)
3558 ast_log(LOG_DEBUG, "Destroying channel clone '%s'\n", clone->name);
3559 ast_channel_unlock(clone);
3560 manager_event(EVENT_FLAG_CALL, "Hangup",
3561 "Channel: %s\r\n"
3562 "Uniqueid: %s\r\n"
3563 "Cause: %d\r\n"
3564 "Cause-txt: %s\r\n",
3565 clone->name,
3566 clone->uniqueid,
3567 clone->hangupcause,
3568 ast_cause2str(clone->hangupcause)
3570 ast_channel_free(clone);
3571 } else {
3572 if (option_debug)
3573 ast_log(LOG_DEBUG, "Released clone lock on '%s'\n", clone->name);
3574 ast_set_flag(clone, AST_FLAG_ZOMBIE);
3575 ast_queue_frame(clone, &ast_null_frame);
3576 ast_channel_unlock(clone);
3579 /* Signal any blocker */
3580 if (ast_test_flag(original, AST_FLAG_BLOCKING))
3581 pthread_kill(original->blocker, SIGURG);
3582 if (option_debug)
3583 ast_log(LOG_DEBUG, "Done Masquerading %s (%d)\n", original->name, original->_state);
3584 return 0;
3587 void ast_set_callerid(struct ast_channel *chan, const char *callerid, const char *calleridname, const char *ani)
3589 ast_channel_lock(chan);
3591 if (callerid) {
3592 if (chan->cid.cid_num)
3593 free(chan->cid.cid_num);
3594 chan->cid.cid_num = ast_strdup(callerid);
3596 if (calleridname) {
3597 if (chan->cid.cid_name)
3598 free(chan->cid.cid_name);
3599 chan->cid.cid_name = ast_strdup(calleridname);
3601 if (ani) {
3602 if (chan->cid.cid_ani)
3603 free(chan->cid.cid_ani);
3604 chan->cid.cid_ani = ast_strdup(ani);
3606 if (chan->cdr)
3607 ast_cdr_setcid(chan->cdr, chan);
3608 manager_event(EVENT_FLAG_CALL, "Newcallerid",
3609 "Channel: %s\r\n"
3610 "CallerID: %s\r\n"
3611 "CallerIDName: %s\r\n"
3612 "Uniqueid: %s\r\n"
3613 "CID-CallingPres: %d (%s)\r\n",
3614 chan->name,
3615 S_OR(chan->cid.cid_num, "<Unknown>"),
3616 S_OR(chan->cid.cid_name, "<Unknown>"),
3617 chan->uniqueid,
3618 chan->cid.cid_pres,
3619 ast_describe_caller_presentation(chan->cid.cid_pres)
3622 ast_channel_unlock(chan);
3625 int ast_setstate(struct ast_channel *chan, enum ast_channel_state state)
3627 int oldstate = chan->_state;
3629 if (oldstate == state)
3630 return 0;
3632 chan->_state = state;
3633 ast_device_state_changed_literal(chan->name);
3634 /* setstate used to conditionally report Newchannel; this is no more */
3635 manager_event(EVENT_FLAG_CALL,
3636 "Newstate",
3637 "Channel: %s\r\n"
3638 "State: %s\r\n"
3639 "CallerID: %s\r\n"
3640 "CallerIDName: %s\r\n"
3641 "Uniqueid: %s\r\n",
3642 chan->name, ast_state2str(chan->_state),
3643 S_OR(chan->cid.cid_num, "<unknown>"),
3644 S_OR(chan->cid.cid_name, "<unknown>"),
3645 chan->uniqueid);
3647 return 0;
3650 /*! \brief Find bridged channel */
3651 struct ast_channel *ast_bridged_channel(struct ast_channel *chan)
3653 struct ast_channel *bridged;
3654 bridged = chan->_bridge;
3655 if (bridged && bridged->tech->bridged_channel)
3656 bridged = bridged->tech->bridged_channel(chan, bridged);
3657 return bridged;
3660 static void bridge_playfile(struct ast_channel *chan, struct ast_channel *peer, const char *sound, int remain)
3662 int min = 0, sec = 0, check;
3664 check = ast_autoservice_start(peer);
3665 if (check)
3666 return;
3668 if (remain > 0) {
3669 if (remain / 60 > 1) {
3670 min = remain / 60;
3671 sec = remain % 60;
3672 } else {
3673 sec = remain;
3677 if (!strcmp(sound,"timeleft")) { /* Queue support */
3678 ast_stream_and_wait(chan, "vm-youhave", chan->language, "");
3679 if (min) {
3680 ast_say_number(chan, min, AST_DIGIT_ANY, chan->language, NULL);
3681 ast_stream_and_wait(chan, "queue-minutes", chan->language, "");
3683 if (sec) {
3684 ast_say_number(chan, sec, AST_DIGIT_ANY, chan->language, NULL);
3685 ast_stream_and_wait(chan, "queue-seconds", chan->language, "");
3687 } else {
3688 ast_stream_and_wait(chan, sound, chan->language, "");
3691 ast_autoservice_stop(peer);
3694 static enum ast_bridge_result ast_generic_bridge(struct ast_channel *c0, struct ast_channel *c1,
3695 struct ast_bridge_config *config, struct ast_frame **fo,
3696 struct ast_channel **rc, struct timeval bridge_end)
3698 /* Copy voice back and forth between the two channels. */
3699 struct ast_channel *cs[3];
3700 struct ast_frame *f;
3701 enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
3702 int o0nativeformats;
3703 int o1nativeformats;
3704 int watch_c0_dtmf;
3705 int watch_c1_dtmf;
3706 void *pvt0, *pvt1;
3707 /* Indicates whether a frame was queued into a jitterbuffer */
3708 int frame_put_in_jb = 0;
3709 int jb_in_use;
3710 int to;
3712 cs[0] = c0;
3713 cs[1] = c1;
3714 pvt0 = c0->tech_pvt;
3715 pvt1 = c1->tech_pvt;
3716 o0nativeformats = c0->nativeformats;
3717 o1nativeformats = c1->nativeformats;
3718 watch_c0_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_0;
3719 watch_c1_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_1;
3721 /* Check the need of a jitterbuffer for each channel */
3722 jb_in_use = ast_jb_do_usecheck(c0, c1);
3724 for (;;) {
3725 struct ast_channel *who, *other;
3727 if ((c0->tech_pvt != pvt0) || (c1->tech_pvt != pvt1) ||
3728 (o0nativeformats != c0->nativeformats) ||
3729 (o1nativeformats != c1->nativeformats)) {
3730 /* Check for Masquerade, codec changes, etc */
3731 res = AST_BRIDGE_RETRY;
3732 break;
3734 if (bridge_end.tv_sec) {
3735 to = ast_tvdiff_ms(bridge_end, ast_tvnow());
3736 if (to <= 0) {
3737 if (config->timelimit)
3738 res = AST_BRIDGE_RETRY;
3739 else
3740 res = AST_BRIDGE_COMPLETE;
3741 break;
3743 } else
3744 to = -1;
3745 /* Calculate the appropriate max sleep interval - in general, this is the time,
3746 left to the closest jb delivery moment */
3747 if (jb_in_use)
3748 to = ast_jb_get_when_to_wakeup(c0, c1, to);
3749 who = ast_waitfor_n(cs, 2, &to);
3750 if (!who) {
3751 /* No frame received within the specified timeout - check if we have to deliver now */
3752 if (jb_in_use)
3753 ast_jb_get_and_deliver(c0, c1);
3754 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
3755 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
3756 c0->_softhangup = 0;
3757 if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
3758 c1->_softhangup = 0;
3759 c0->_bridge = c1;
3760 c1->_bridge = c0;
3762 continue;
3764 f = ast_read(who);
3765 if (!f) {
3766 *fo = NULL;
3767 *rc = who;
3768 if (option_debug)
3769 ast_log(LOG_DEBUG, "Didn't get a frame from channel: %s\n",who->name);
3770 break;
3773 other = (who == c0) ? c1 : c0; /* the 'other' channel */
3774 /* Try add the frame info the who's bridged channel jitterbuff */
3775 if (jb_in_use)
3776 frame_put_in_jb = !ast_jb_put(other, f);
3778 if ((f->frametype == AST_FRAME_CONTROL) && !(config->flags & AST_BRIDGE_IGNORE_SIGS)) {
3779 int bridge_exit = 0;
3781 switch (f->subclass) {
3782 case AST_CONTROL_HOLD:
3783 case AST_CONTROL_UNHOLD:
3784 case AST_CONTROL_VIDUPDATE:
3785 case AST_CONTROL_SRCUPDATE:
3786 ast_indicate_data(other, f->subclass, f->data, f->datalen);
3787 break;
3788 default:
3789 *fo = f;
3790 *rc = who;
3791 bridge_exit = 1;
3792 if (option_debug)
3793 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
3794 break;
3796 if (bridge_exit)
3797 break;
3799 if ((f->frametype == AST_FRAME_VOICE) ||
3800 (f->frametype == AST_FRAME_DTMF_BEGIN) ||
3801 (f->frametype == AST_FRAME_DTMF) ||
3802 (f->frametype == AST_FRAME_VIDEO) ||
3803 (f->frametype == AST_FRAME_IMAGE) ||
3804 (f->frametype == AST_FRAME_HTML) ||
3805 (f->frametype == AST_FRAME_MODEM) ||
3806 (f->frametype == AST_FRAME_TEXT)) {
3807 /* monitored dtmf causes exit from bridge */
3808 int monitored_source = (who == c0) ? watch_c0_dtmf : watch_c1_dtmf;
3810 if (monitored_source &&
3811 (f->frametype == AST_FRAME_DTMF_END ||
3812 f->frametype == AST_FRAME_DTMF_BEGIN)) {
3813 *fo = f;
3814 *rc = who;
3815 if (option_debug)
3816 ast_log(LOG_DEBUG, "Got DTMF %s on channel (%s)\n",
3817 f->frametype == AST_FRAME_DTMF_END ? "end" : "begin",
3818 who->name);
3819 break;
3821 /* Write immediately frames, not passed through jb */
3822 if (!frame_put_in_jb)
3823 ast_write(other, f);
3825 /* Check if we have to deliver now */
3826 if (jb_in_use)
3827 ast_jb_get_and_deliver(c0, c1);
3829 /* XXX do we want to pass on also frames not matched above ? */
3830 ast_frfree(f);
3832 /* Swap who gets priority */
3833 cs[2] = cs[0];
3834 cs[0] = cs[1];
3835 cs[1] = cs[2];
3837 return res;
3840 /*! \brief Bridge two channels together */
3841 enum ast_bridge_result ast_channel_bridge(struct ast_channel *c0, struct ast_channel *c1,
3842 struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc)
3844 struct ast_channel *who = NULL;
3845 enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
3846 int nativefailed=0;
3847 int firstpass;
3848 int o0nativeformats;
3849 int o1nativeformats;
3850 long time_left_ms=0;
3851 struct timeval nexteventts = { 0, };
3852 char caller_warning = 0;
3853 char callee_warning = 0;
3855 if (c0->_bridge) {
3856 ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
3857 c0->name, c0->_bridge->name);
3858 return -1;
3860 if (c1->_bridge) {
3861 ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
3862 c1->name, c1->_bridge->name);
3863 return -1;
3866 /* Stop if we're a zombie or need a soft hangup */
3867 if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
3868 ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1))
3869 return -1;
3871 *fo = NULL;
3872 firstpass = config->firstpass;
3873 config->firstpass = 0;
3875 if (ast_tvzero(config->start_time))
3876 config->start_time = ast_tvnow();
3877 time_left_ms = config->timelimit;
3879 caller_warning = ast_test_flag(&config->features_caller, AST_FEATURE_PLAY_WARNING);
3880 callee_warning = ast_test_flag(&config->features_callee, AST_FEATURE_PLAY_WARNING);
3882 if (config->start_sound && firstpass) {
3883 if (caller_warning)
3884 bridge_playfile(c0, c1, config->start_sound, time_left_ms / 1000);
3885 if (callee_warning)
3886 bridge_playfile(c1, c0, config->start_sound, time_left_ms / 1000);
3889 /* Keep track of bridge */
3890 c0->_bridge = c1;
3891 c1->_bridge = c0;
3893 /* \todo XXX here should check that cid_num is not NULL */
3894 manager_event(EVENT_FLAG_CALL, "Link",
3895 "Channel1: %s\r\n"
3896 "Channel2: %s\r\n"
3897 "Uniqueid1: %s\r\n"
3898 "Uniqueid2: %s\r\n"
3899 "CallerID1: %s\r\n"
3900 "CallerID2: %s\r\n",
3901 c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
3903 o0nativeformats = c0->nativeformats;
3904 o1nativeformats = c1->nativeformats;
3906 if (config->feature_timer) {
3907 nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->feature_timer, 1000));
3908 } else if (config->timelimit) {
3909 nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
3910 if (caller_warning || callee_warning)
3911 nexteventts = ast_tvsub(nexteventts, ast_samp2tv(config->play_warning, 1000));
3914 if (!c0->tech->send_digit_begin)
3915 ast_set_flag(c1, AST_FLAG_END_DTMF_ONLY);
3916 if (!c1->tech->send_digit_begin)
3917 ast_set_flag(c0, AST_FLAG_END_DTMF_ONLY);
3919 /* Before we enter in and bridge these two together tell them both the source of audio has changed */
3920 ast_indicate(c0, AST_CONTROL_SRCUPDATE);
3921 ast_indicate(c1, AST_CONTROL_SRCUPDATE);
3923 for (/* ever */;;) {
3924 struct timeval now = { 0, };
3925 int to;
3927 to = -1;
3929 if (!ast_tvzero(nexteventts)) {
3930 now = ast_tvnow();
3931 to = ast_tvdiff_ms(nexteventts, now);
3932 if (to <= 0) {
3933 if (!config->timelimit) {
3934 res = AST_BRIDGE_COMPLETE;
3935 break;
3937 to = 0;
3941 if (config->timelimit) {
3942 time_left_ms = config->timelimit - ast_tvdiff_ms(now, config->start_time);
3943 if (time_left_ms < to)
3944 to = time_left_ms;
3946 if (time_left_ms <= 0) {
3947 if (caller_warning && config->end_sound)
3948 bridge_playfile(c0, c1, config->end_sound, 0);
3949 if (callee_warning && config->end_sound)
3950 bridge_playfile(c1, c0, config->end_sound, 0);
3951 *fo = NULL;
3952 if (who)
3953 *rc = who;
3954 res = 0;
3955 break;
3958 if (!to) {
3959 if (time_left_ms >= 5000 && config->warning_sound && config->play_warning) {
3960 int t = (time_left_ms + 500) / 1000; /* round to nearest second */
3961 if (caller_warning)
3962 bridge_playfile(c0, c1, config->warning_sound, t);
3963 if (callee_warning)
3964 bridge_playfile(c1, c0, config->warning_sound, t);
3966 if (config->warning_freq && (time_left_ms > (config->warning_freq + 5000)))
3967 nexteventts = ast_tvadd(nexteventts, ast_samp2tv(config->warning_freq, 1000));
3968 else
3969 nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
3973 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
3974 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
3975 c0->_softhangup = 0;
3976 if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
3977 c1->_softhangup = 0;
3978 c0->_bridge = c1;
3979 c1->_bridge = c0;
3980 if (option_debug)
3981 ast_log(LOG_DEBUG, "Unbridge signal received. Ending native bridge.\n");
3982 continue;
3985 /* Stop if we're a zombie or need a soft hangup */
3986 if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
3987 ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1)) {
3988 *fo = NULL;
3989 if (who)
3990 *rc = who;
3991 res = 0;
3992 if (option_debug)
3993 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",
3994 c0->name, c1->name,
3995 ast_test_flag(c0, AST_FLAG_ZOMBIE) ? "Yes" : "No",
3996 ast_check_hangup(c0) ? "Yes" : "No",
3997 ast_test_flag(c1, AST_FLAG_ZOMBIE) ? "Yes" : "No",
3998 ast_check_hangup(c1) ? "Yes" : "No");
3999 break;
4002 /* See if the BRIDGEPEER variable needs to be updated */
4003 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c0, "BRIDGEPEER")))
4004 pbx_builtin_setvar_helper(c0, "BRIDGEPEER", c1->name);
4005 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c1, "BRIDGEPEER")))
4006 pbx_builtin_setvar_helper(c1, "BRIDGEPEER", c0->name);
4008 if (c0->tech->bridge &&
4009 (config->timelimit == 0) &&
4010 (c0->tech->bridge == c1->tech->bridge) &&
4011 !nativefailed && !c0->monitor && !c1->monitor &&
4012 !c0->audiohooks && !c1->audiohooks && !ast_test_flag(&(config->features_callee),AST_FEATURE_REDIRECT) &&
4013 !ast_test_flag(&(config->features_caller),AST_FEATURE_REDIRECT) &&
4014 !c0->masq && !c0->masqr && !c1->masq && !c1->masqr) {
4015 /* Looks like they share a bridge method and nothing else is in the way */
4016 ast_set_flag(c0, AST_FLAG_NBRIDGE);
4017 ast_set_flag(c1, AST_FLAG_NBRIDGE);
4018 if ((res = c0->tech->bridge(c0, c1, config->flags, fo, rc, to)) == AST_BRIDGE_COMPLETE) {
4019 /* \todo XXX here should check that cid_num is not NULL */
4020 manager_event(EVENT_FLAG_CALL, "Unlink",
4021 "Channel1: %s\r\n"
4022 "Channel2: %s\r\n"
4023 "Uniqueid1: %s\r\n"
4024 "Uniqueid2: %s\r\n"
4025 "CallerID1: %s\r\n"
4026 "CallerID2: %s\r\n",
4027 c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
4028 if (option_debug)
4029 ast_log(LOG_DEBUG, "Returning from native bridge, channels: %s, %s\n", c0->name, c1->name);
4031 ast_clear_flag(c0, AST_FLAG_NBRIDGE);
4032 ast_clear_flag(c1, AST_FLAG_NBRIDGE);
4034 if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
4035 continue;
4037 c0->_bridge = NULL;
4038 c1->_bridge = NULL;
4040 return res;
4041 } else {
4042 ast_clear_flag(c0, AST_FLAG_NBRIDGE);
4043 ast_clear_flag(c1, AST_FLAG_NBRIDGE);
4045 switch (res) {
4046 case AST_BRIDGE_RETRY:
4047 continue;
4048 default:
4049 if (option_verbose > 2)
4050 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s ended\n",
4051 c0->name, c1->name);
4052 /* fallthrough */
4053 case AST_BRIDGE_FAILED_NOWARN:
4054 nativefailed++;
4055 break;
4059 if (((c0->writeformat != c1->readformat) || (c0->readformat != c1->writeformat) ||
4060 (c0->nativeformats != o0nativeformats) || (c1->nativeformats != o1nativeformats)) &&
4061 !(c0->generator || c1->generator)) {
4062 if (ast_channel_make_compatible(c0, c1)) {
4063 ast_log(LOG_WARNING, "Can't make %s and %s compatible\n", c0->name, c1->name);
4064 /* \todo XXX here should check that cid_num is not NULL */
4065 manager_event(EVENT_FLAG_CALL, "Unlink",
4066 "Channel1: %s\r\n"
4067 "Channel2: %s\r\n"
4068 "Uniqueid1: %s\r\n"
4069 "Uniqueid2: %s\r\n"
4070 "CallerID1: %s\r\n"
4071 "CallerID2: %s\r\n",
4072 c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
4073 return AST_BRIDGE_FAILED;
4075 o0nativeformats = c0->nativeformats;
4076 o1nativeformats = c1->nativeformats;
4078 res = ast_generic_bridge(c0, c1, config, fo, rc, nexteventts);
4079 if (res != AST_BRIDGE_RETRY)
4080 break;
4083 ast_clear_flag(c0, AST_FLAG_END_DTMF_ONLY);
4084 ast_clear_flag(c1, AST_FLAG_END_DTMF_ONLY);
4086 /* Now that we have broken the bridge the source will change yet again */
4087 ast_indicate(c0, AST_CONTROL_SRCUPDATE);
4088 ast_indicate(c1, AST_CONTROL_SRCUPDATE);
4090 c0->_bridge = NULL;
4091 c1->_bridge = NULL;
4093 /* \todo XXX here should check that cid_num is not NULL */
4094 manager_event(EVENT_FLAG_CALL, "Unlink",
4095 "Channel1: %s\r\n"
4096 "Channel2: %s\r\n"
4097 "Uniqueid1: %s\r\n"
4098 "Uniqueid2: %s\r\n"
4099 "CallerID1: %s\r\n"
4100 "CallerID2: %s\r\n",
4101 c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
4102 if (option_debug)
4103 ast_log(LOG_DEBUG, "Bridge stops bridging channels %s and %s\n", c0->name, c1->name);
4105 return res;
4108 /*! \brief Sets an option on a channel */
4109 int ast_channel_setoption(struct ast_channel *chan, int option, void *data, int datalen, int block)
4111 int res;
4113 if (chan->tech->setoption) {
4114 res = chan->tech->setoption(chan, option, data, datalen);
4115 if (res < 0)
4116 return res;
4117 } else {
4118 errno = ENOSYS;
4119 return -1;
4121 if (block) {
4122 /* XXX Implement blocking -- just wait for our option frame reply, discarding
4123 intermediate packets. XXX */
4124 ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
4125 return -1;
4127 return 0;
4130 struct tonepair_def {
4131 int freq1;
4132 int freq2;
4133 int duration;
4134 int vol;
4137 struct tonepair_state {
4138 int fac1;
4139 int fac2;
4140 int v1_1;
4141 int v2_1;
4142 int v3_1;
4143 int v1_2;
4144 int v2_2;
4145 int v3_2;
4146 int origwfmt;
4147 int pos;
4148 int duration;
4149 int modulate;
4150 struct ast_frame f;
4151 unsigned char offset[AST_FRIENDLY_OFFSET];
4152 short data[4000];
4155 static void tonepair_release(struct ast_channel *chan, void *params)
4157 struct tonepair_state *ts = params;
4159 if (chan)
4160 ast_set_write_format(chan, ts->origwfmt);
4161 free(ts);
4164 static void *tonepair_alloc(struct ast_channel *chan, void *params)
4166 struct tonepair_state *ts;
4167 struct tonepair_def *td = params;
4169 if (!(ts = ast_calloc(1, sizeof(*ts))))
4170 return NULL;
4171 ts->origwfmt = chan->writeformat;
4172 if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) {
4173 ast_log(LOG_WARNING, "Unable to set '%s' to signed linear format (write)\n", chan->name);
4174 tonepair_release(NULL, ts);
4175 ts = NULL;
4176 } else {
4177 ts->fac1 = 2.0 * cos(2.0 * M_PI * (td->freq1 / 8000.0)) * 32768.0;
4178 ts->v1_1 = 0;
4179 ts->v2_1 = sin(-4.0 * M_PI * (td->freq1 / 8000.0)) * td->vol;
4180 ts->v3_1 = sin(-2.0 * M_PI * (td->freq1 / 8000.0)) * td->vol;
4181 ts->v2_1 = 0;
4182 ts->fac2 = 2.0 * cos(2.0 * M_PI * (td->freq2 / 8000.0)) * 32768.0;
4183 ts->v2_2 = sin(-4.0 * M_PI * (td->freq2 / 8000.0)) * td->vol;
4184 ts->v3_2 = sin(-2.0 * M_PI * (td->freq2 / 8000.0)) * td->vol;
4185 ts->duration = td->duration;
4186 ts->modulate = 0;
4188 /* Let interrupts interrupt :) */
4189 ast_set_flag(chan, AST_FLAG_WRITE_INT);
4190 return ts;
4193 static int tonepair_generator(struct ast_channel *chan, void *data, int len, int samples)
4195 struct tonepair_state *ts = data;
4196 int x;
4198 /* we need to prepare a frame with 16 * timelen samples as we're
4199 * generating SLIN audio
4201 len = samples * 2;
4203 if (len > sizeof(ts->data) / 2 - 1) {
4204 ast_log(LOG_WARNING, "Can't generate that much data!\n");
4205 return -1;
4207 memset(&ts->f, 0, sizeof(ts->f));
4208 for (x=0;x<len/2;x++) {
4209 ts->v1_1 = ts->v2_1;
4210 ts->v2_1 = ts->v3_1;
4211 ts->v3_1 = (ts->fac1 * ts->v2_1 >> 15) - ts->v1_1;
4213 ts->v1_2 = ts->v2_2;
4214 ts->v2_2 = ts->v3_2;
4215 ts->v3_2 = (ts->fac2 * ts->v2_2 >> 15) - ts->v1_2;
4216 if (ts->modulate) {
4217 int p;
4218 p = ts->v3_2 - 32768;
4219 if (p < 0) p = -p;
4220 p = ((p * 9) / 10) + 1;
4221 ts->data[x] = (ts->v3_1 * p) >> 15;
4222 } else
4223 ts->data[x] = ts->v3_1 + ts->v3_2;
4225 ts->f.frametype = AST_FRAME_VOICE;
4226 ts->f.subclass = AST_FORMAT_SLINEAR;
4227 ts->f.datalen = len;
4228 ts->f.samples = samples;
4229 ts->f.offset = AST_FRIENDLY_OFFSET;
4230 ts->f.data = ts->data;
4231 ast_write(chan, &ts->f);
4232 ts->pos += x;
4233 if (ts->duration > 0) {
4234 if (ts->pos >= ts->duration * 8)
4235 return -1;
4237 return 0;
4240 static struct ast_generator tonepair = {
4241 alloc: tonepair_alloc,
4242 release: tonepair_release,
4243 generate: tonepair_generator,
4246 int ast_tonepair_start(struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
4248 struct tonepair_def d = { 0, };
4250 d.freq1 = freq1;
4251 d.freq2 = freq2;
4252 d.duration = duration;
4253 d.vol = (vol < 1) ? 8192 : vol; /* force invalid to 8192 */
4254 if (ast_activate_generator(chan, &tonepair, &d))
4255 return -1;
4256 return 0;
4259 void ast_tonepair_stop(struct ast_channel *chan)
4261 ast_deactivate_generator(chan);
4264 int ast_tonepair(struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
4266 int res;
4268 if ((res = ast_tonepair_start(chan, freq1, freq2, duration, vol)))
4269 return res;
4271 /* Give us some wiggle room */
4272 while (chan->generatordata && ast_waitfor(chan, 100) >= 0) {
4273 struct ast_frame *f = ast_read(chan);
4274 if (f)
4275 ast_frfree(f);
4276 else
4277 return -1;
4279 return 0;
4282 ast_group_t ast_get_group(const char *s)
4284 char *piece;
4285 char *c;
4286 int start=0, finish=0, x;
4287 ast_group_t group = 0;
4289 if (ast_strlen_zero(s))
4290 return 0;
4292 c = ast_strdupa(s);
4294 while ((piece = strsep(&c, ","))) {
4295 if (sscanf(piece, "%d-%d", &start, &finish) == 2) {
4296 /* Range */
4297 } else if (sscanf(piece, "%d", &start)) {
4298 /* Just one */
4299 finish = start;
4300 } else {
4301 ast_log(LOG_ERROR, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s, piece);
4302 continue;
4304 for (x = start; x <= finish; x++) {
4305 if ((x > 63) || (x < 0)) {
4306 ast_log(LOG_WARNING, "Ignoring invalid group %d (maximum group is 63)\n", x);
4307 } else
4308 group |= ((ast_group_t) 1 << x);
4311 return group;
4314 static int (*ast_moh_start_ptr)(struct ast_channel *, const char *, const char *) = NULL;
4315 static void (*ast_moh_stop_ptr)(struct ast_channel *) = NULL;
4316 static void (*ast_moh_cleanup_ptr)(struct ast_channel *) = NULL;
4318 void ast_install_music_functions(int (*start_ptr)(struct ast_channel *, const char *, const char *),
4319 void (*stop_ptr)(struct ast_channel *),
4320 void (*cleanup_ptr)(struct ast_channel *))
4322 ast_moh_start_ptr = start_ptr;
4323 ast_moh_stop_ptr = stop_ptr;
4324 ast_moh_cleanup_ptr = cleanup_ptr;
4327 void ast_uninstall_music_functions(void)
4329 ast_moh_start_ptr = NULL;
4330 ast_moh_stop_ptr = NULL;
4331 ast_moh_cleanup_ptr = NULL;
4334 /*! \brief Turn on music on hold on a given channel */
4335 int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
4337 if (ast_moh_start_ptr)
4338 return ast_moh_start_ptr(chan, mclass, interpclass);
4340 if (option_verbose > 2) {
4341 ast_verbose(VERBOSE_PREFIX_3 "Music class %s requested but no musiconhold loaded.\n",
4342 mclass ? mclass : (interpclass ? interpclass : "default"));
4345 return 0;
4348 /*! \brief Turn off music on hold on a given channel */
4349 void ast_moh_stop(struct ast_channel *chan)
4351 if (ast_moh_stop_ptr)
4352 ast_moh_stop_ptr(chan);
4355 void ast_moh_cleanup(struct ast_channel *chan)
4357 if (ast_moh_cleanup_ptr)
4358 ast_moh_cleanup_ptr(chan);
4361 void ast_channels_init(void)
4363 ast_cli_register_multiple(cli_channel, sizeof(cli_channel) / sizeof(struct ast_cli_entry));
4366 /*! \brief Print call group and pickup group ---*/
4367 char *ast_print_group(char *buf, int buflen, ast_group_t group)
4369 unsigned int i;
4370 int first=1;
4371 char num[3];
4373 buf[0] = '\0';
4375 if (!group) /* Return empty string if no group */
4376 return buf;
4378 for (i = 0; i <= 63; i++) { /* Max group is 63 */
4379 if (group & ((ast_group_t) 1 << i)) {
4380 if (!first) {
4381 strncat(buf, ", ", buflen - strlen(buf) - 1);
4382 } else {
4383 first=0;
4385 snprintf(num, sizeof(num), "%u", i);
4386 strncat(buf, num, buflen - strlen(buf) - 1);
4389 return buf;
4392 void ast_set_variables(struct ast_channel *chan, struct ast_variable *vars)
4394 struct ast_variable *cur;
4396 for (cur = vars; cur; cur = cur->next)
4397 pbx_builtin_setvar_helper(chan, cur->name, cur->value);
4400 static void *silence_generator_alloc(struct ast_channel *chan, void *data)
4402 /* just store the data pointer in the channel structure */
4403 return data;
4406 static void silence_generator_release(struct ast_channel *chan, void *data)
4408 /* nothing to do */
4411 static int silence_generator_generate(struct ast_channel *chan, void *data, int len, int samples)
4413 short buf[samples];
4414 struct ast_frame frame = {
4415 .frametype = AST_FRAME_VOICE,
4416 .subclass = AST_FORMAT_SLINEAR,
4417 .data = buf,
4418 .samples = samples,
4419 .datalen = sizeof(buf),
4421 memset(buf, 0, sizeof(buf));
4422 if (ast_write(chan, &frame))
4423 return -1;
4424 return 0;
4427 static struct ast_generator silence_generator = {
4428 .alloc = silence_generator_alloc,
4429 .release = silence_generator_release,
4430 .generate = silence_generator_generate,
4433 struct ast_silence_generator {
4434 int old_write_format;
4437 struct ast_silence_generator *ast_channel_start_silence_generator(struct ast_channel *chan)
4439 struct ast_silence_generator *state;
4441 if (!(state = ast_calloc(1, sizeof(*state)))) {
4442 return NULL;
4445 state->old_write_format = chan->writeformat;
4447 if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) {
4448 ast_log(LOG_ERROR, "Could not set write format to SLINEAR\n");
4449 free(state);
4450 return NULL;
4453 ast_activate_generator(chan, &silence_generator, state);
4455 if (option_debug)
4456 ast_log(LOG_DEBUG, "Started silence generator on '%s'\n", chan->name);
4458 return state;
4461 void ast_channel_stop_silence_generator(struct ast_channel *chan, struct ast_silence_generator *state)
4463 if (!state)
4464 return;
4466 ast_deactivate_generator(chan);
4468 if (option_debug)
4469 ast_log(LOG_DEBUG, "Stopped silence generator on '%s'\n", chan->name);
4471 if (ast_set_write_format(chan, state->old_write_format) < 0)
4472 ast_log(LOG_ERROR, "Could not return write format to its original state\n");
4474 free(state);
4478 /*! \ brief Convert channel reloadreason (ENUM) to text string for manager event */
4479 const char *channelreloadreason2txt(enum channelreloadreason reason)
4481 switch (reason) {
4482 case CHANNEL_MODULE_LOAD:
4483 return "LOAD (Channel module load)";
4485 case CHANNEL_MODULE_RELOAD:
4486 return "RELOAD (Channel module reload)";
4488 case CHANNEL_CLI_RELOAD:
4489 return "CLIRELOAD (Channel module reload by CLI command)";
4491 default:
4492 return "MANAGERRELOAD (Channel module reload by manager)";
4496 #ifdef DEBUG_CHANNEL_LOCKS
4498 /*! \brief Unlock AST channel (and print debugging output)
4499 \note You need to enable DEBUG_CHANNEL_LOCKS for this function
4501 int ast_channel_unlock(struct ast_channel *chan)
4503 int res = 0;
4504 if (option_debug > 2)
4505 ast_log(LOG_DEBUG, "::::==== Unlocking AST channel %s\n", chan->name);
4507 if (!chan) {
4508 if (option_debug)
4509 ast_log(LOG_DEBUG, "::::==== Unlocking non-existing channel \n");
4510 return 0;
4513 res = ast_mutex_unlock(&chan->lock);
4515 if (option_debug > 2) {
4516 #ifdef DEBUG_THREADS
4517 int count = 0;
4518 if ((count = chan->lock.reentrancy))
4519 ast_log(LOG_DEBUG, ":::=== Still have %d locks (recursive)\n", count);
4520 #endif
4521 if (!res)
4522 if (option_debug)
4523 ast_log(LOG_DEBUG, "::::==== Channel %s was unlocked\n", chan->name);
4524 if (res == EINVAL) {
4525 if (option_debug)
4526 ast_log(LOG_DEBUG, "::::==== Channel %s had no lock by this thread. Failed unlocking\n", chan->name);
4529 if (res == EPERM) {
4530 /* We had no lock, so okay any way*/
4531 if (option_debug > 3)
4532 ast_log(LOG_DEBUG, "::::==== Channel %s was not locked at all \n", chan->name);
4533 res = 0;
4535 return res;
4538 /*! \brief Lock AST channel (and print debugging output)
4539 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
4540 int ast_channel_lock(struct ast_channel *chan)
4542 int res;
4544 if (option_debug > 3)
4545 ast_log(LOG_DEBUG, "====:::: Locking AST channel %s\n", chan->name);
4547 res = ast_mutex_lock(&chan->lock);
4549 if (option_debug > 3) {
4550 #ifdef DEBUG_THREADS
4551 int count = 0;
4552 if ((count = chan->lock.reentrancy))
4553 ast_log(LOG_DEBUG, ":::=== Now have %d locks (recursive)\n", count);
4554 #endif
4555 if (!res)
4556 ast_log(LOG_DEBUG, "::::==== Channel %s was locked\n", chan->name);
4557 if (res == EDEADLK) {
4558 /* We had no lock, so okey any way */
4559 if (option_debug > 3)
4560 ast_log(LOG_DEBUG, "::::==== Channel %s was not locked by us. Lock would cause deadlock.\n", chan->name);
4562 if (res == EINVAL) {
4563 if (option_debug > 3)
4564 ast_log(LOG_DEBUG, "::::==== Channel %s lock failed. No mutex.\n", chan->name);
4567 return res;
4570 /*! \brief Lock AST channel (and print debugging output)
4571 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
4572 int ast_channel_trylock(struct ast_channel *chan)
4574 int res;
4576 if (option_debug > 2)
4577 ast_log(LOG_DEBUG, "====:::: Trying to lock AST channel %s\n", chan->name);
4579 res = ast_mutex_trylock(&chan->lock);
4581 if (option_debug > 2) {
4582 #ifdef DEBUG_THREADS
4583 int count = 0;
4584 if ((count = chan->lock.reentrancy))
4585 ast_log(LOG_DEBUG, ":::=== Now have %d locks (recursive)\n", count);
4586 #endif
4587 if (!res)
4588 ast_log(LOG_DEBUG, "::::==== Channel %s was locked\n", chan->name);
4589 if (res == EBUSY) {
4590 /* We failed to lock */
4591 if (option_debug > 2)
4592 ast_log(LOG_DEBUG, "::::==== Channel %s failed to lock. Not waiting around...\n", chan->name);
4594 if (res == EDEADLK) {
4595 /* We had no lock, so okey any way*/
4596 if (option_debug > 2)
4597 ast_log(LOG_DEBUG, "::::==== Channel %s was not locked. Lock would cause deadlock.\n", chan->name);
4599 if (res == EINVAL && option_debug > 2)
4600 ast_log(LOG_DEBUG, "::::==== Channel %s lock failed. No mutex.\n", chan->name);
4602 return res;
4605 #endif
4608 * Wrappers for various ast_say_*() functions that call the full version
4609 * of the same functions.
4610 * The proper place would be say.c, but that file is optional and one
4611 * must be able to build asterisk even without it (using a loadable 'say'
4612 * implementation that only supplies the 'full' version of the functions.
4615 int ast_say_number(struct ast_channel *chan, int num,
4616 const char *ints, const char *language, const char *options)
4618 return ast_say_number_full(chan, num, ints, language, options, -1, -1);
4621 int ast_say_enumeration(struct ast_channel *chan, int num,
4622 const char *ints, const char *language, const char *options)
4624 return ast_say_enumeration_full(chan, num, ints, language, options, -1, -1);
4627 int ast_say_digits(struct ast_channel *chan, int num,
4628 const char *ints, const char *lang)
4630 return ast_say_digits_full(chan, num, ints, lang, -1, -1);
4633 int ast_say_digit_str(struct ast_channel *chan, const char *str,
4634 const char *ints, const char *lang)
4636 return ast_say_digit_str_full(chan, str, ints, lang, -1, -1);
4639 int ast_say_character_str(struct ast_channel *chan, const char *str,
4640 const char *ints, const char *lang)
4642 return ast_say_character_str_full(chan, str, ints, lang, -1, -1);
4645 int ast_say_phonetic_str(struct ast_channel *chan, const char *str,
4646 const char *ints, const char *lang)
4648 return ast_say_phonetic_str_full(chan, str, ints, lang, -1, -1);
4651 int ast_say_digits_full(struct ast_channel *chan, int num,
4652 const char *ints, const char *lang, int audiofd, int ctrlfd)
4654 char buf[256];
4656 snprintf(buf, sizeof(buf), "%d", num);
4657 return ast_say_digit_str_full(chan, buf, ints, lang, audiofd, ctrlfd);