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.
21 * \brief Channel Management
23 * \author Mark Spencer <markster@digium.com>
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
40 #include "asterisk/zapata.h"
42 #include "asterisk/pbx.h"
43 #include "asterisk/frame.h"
44 #include "asterisk/sched.h"
45 #include "asterisk/options.h"
46 #include "asterisk/channel.h"
47 #include "asterisk/chanspy.h"
48 #include "asterisk/musiconhold.h"
49 #include "asterisk/logger.h"
50 #include "asterisk/say.h"
51 #include "asterisk/file.h"
52 #include "asterisk/cli.h"
53 #include "asterisk/translate.h"
54 #include "asterisk/manager.h"
55 #include "asterisk/chanvars.h"
56 #include "asterisk/linkedlists.h"
57 #include "asterisk/indications.h"
58 #include "asterisk/monitor.h"
59 #include "asterisk/causes.h"
60 #include "asterisk/callerid.h"
61 #include "asterisk/utils.h"
62 #include "asterisk/lock.h"
63 #include "asterisk/app.h"
64 #include "asterisk/transcap.h"
65 #include "asterisk/devicestate.h"
66 #include "asterisk/sha1.h"
67 #include "asterisk/threadstorage.h"
68 #include "asterisk/slinfactory.h"
70 struct channel_spy_trans {
72 struct ast_trans_pvt *path;
75 /*! \brief List of SPY structures
77 struct ast_channel_spy_list {
78 struct channel_spy_trans read_translator;
79 struct channel_spy_trans write_translator;
80 AST_LIST_HEAD_NOLOCK(, ast_channel_spy) list;
83 /*! \brief Definition of the Whisper buffer */
84 struct ast_channel_whisper_buffer {
86 struct ast_slinfactory sf;
87 unsigned int original_format;
88 struct ast_trans_pvt *path;
91 /* uncomment if you have problems with 'monitoring' synchronized files */
93 #define MONITOR_CONSTANT_DELAY
94 #define MONITOR_DELAY 150 * 8 /*!< 150 ms of MONITORING DELAY */
97 /*! \brief Prevent new channel allocation if shutting down. */
98 static int shutting_down;
100 static int uniqueint;
102 unsigned long global_fin, global_fout;
104 AST_THREADSTORAGE(state2str_threadbuf);
105 #define STATE2STR_BUFSIZE 32
107 /*! Default amount of time to use when emulating a digit as a begin and end
109 #define AST_DEFAULT_EMULATE_DTMF_DURATION 100
111 /*! Minimum allowed digit length - 80ms */
112 #define AST_MIN_DTMF_DURATION 80
114 /*! Minimum amount of time between the end of the last digit and the beginning
115 * of a new one - 45ms */
116 #define AST_MIN_DTMF_GAP 45
118 /*! \brief List of channel drivers */
120 const struct ast_channel_tech *tech;
121 AST_LIST_ENTRY(chanlist) list;
124 /*! \brief the list of registered channel types */
125 static AST_LIST_HEAD_NOLOCK_STATIC(backends, chanlist);
127 /*! \brief the list of channels we have. Note that the lock for this list is used for
128 both the channels list and the backends list. */
129 static AST_LIST_HEAD_STATIC(channels, ast_channel);
131 /*! \brief map AST_CAUSE's to readable string representations
135 const struct ast_cause {
140 { AST_CAUSE_UNALLOCATED, "UNALLOCATED", "Unallocated (unassigned) number" },
141 { AST_CAUSE_NO_ROUTE_TRANSIT_NET, "NO_ROUTE_TRANSIT_NET", "No route to specified transmit network" },
142 { AST_CAUSE_NO_ROUTE_DESTINATION, "NO_ROUTE_DESTINATION", "No route to destination" },
143 { AST_CAUSE_CHANNEL_UNACCEPTABLE, "CHANNEL_UNACCEPTABLE", "Channel unacceptable" },
144 { AST_CAUSE_CALL_AWARDED_DELIVERED, "CALL_AWARDED_DELIVERED", "Call awarded and being delivered in an established channel" },
145 { AST_CAUSE_NORMAL_CLEARING, "NORMAL_CLEARING", "Normal Clearing" },
146 { AST_CAUSE_USER_BUSY, "USER_BUSY", "User busy" },
147 { AST_CAUSE_NO_USER_RESPONSE, "NO_USER_RESPONSE", "No user responding" },
148 { AST_CAUSE_NO_ANSWER, "NO_ANSWER", "User alerting, no answer" },
149 { AST_CAUSE_CALL_REJECTED, "CALL_REJECTED", "Call Rejected" },
150 { AST_CAUSE_NUMBER_CHANGED, "NUMBER_CHANGED", "Number changed" },
151 { AST_CAUSE_DESTINATION_OUT_OF_ORDER, "DESTINATION_OUT_OF_ORDER", "Destination out of order" },
152 { AST_CAUSE_INVALID_NUMBER_FORMAT, "INVALID_NUMBER_FORMAT", "Invalid number format" },
153 { AST_CAUSE_FACILITY_REJECTED, "FACILITY_REJECTED", "Facility rejected" },
154 { AST_CAUSE_RESPONSE_TO_STATUS_ENQUIRY, "RESPONSE_TO_STATUS_ENQUIRY", "Response to STATus ENQuiry" },
155 { AST_CAUSE_NORMAL_UNSPECIFIED, "NORMAL_UNSPECIFIED", "Normal, unspecified" },
156 { AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, "NORMAL_CIRCUIT_CONGESTION", "Circuit/channel congestion" },
157 { AST_CAUSE_NETWORK_OUT_OF_ORDER, "NETWORK_OUT_OF_ORDER", "Network out of order" },
158 { AST_CAUSE_NORMAL_TEMPORARY_FAILURE, "NORMAL_TEMPORARY_FAILURE", "Temporary failure" },
159 { AST_CAUSE_SWITCH_CONGESTION, "SWITCH_CONGESTION", "Switching equipment congestion" },
160 { AST_CAUSE_ACCESS_INFO_DISCARDED, "ACCESS_INFO_DISCARDED", "Access information discarded" },
161 { AST_CAUSE_REQUESTED_CHAN_UNAVAIL, "REQUESTED_CHAN_UNAVAIL", "Requested channel not available" },
162 { AST_CAUSE_PRE_EMPTED, "PRE_EMPTED", "Pre-empted" },
163 { AST_CAUSE_FACILITY_NOT_SUBSCRIBED, "FACILITY_NOT_SUBSCRIBED", "Facility not subscribed" },
164 { AST_CAUSE_OUTGOING_CALL_BARRED, "OUTGOING_CALL_BARRED", "Outgoing call barred" },
165 { AST_CAUSE_INCOMING_CALL_BARRED, "INCOMING_CALL_BARRED", "Incoming call barred" },
166 { AST_CAUSE_BEARERCAPABILITY_NOTAUTH, "BEARERCAPABILITY_NOTAUTH", "Bearer capability not authorized" },
167 { AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, "BEARERCAPABILITY_NOTAVAIL", "Bearer capability not available" },
168 { AST_CAUSE_BEARERCAPABILITY_NOTIMPL, "BEARERCAPABILITY_NOTIMPL", "Bearer capability not implemented" },
169 { AST_CAUSE_CHAN_NOT_IMPLEMENTED, "CHAN_NOT_IMPLEMENTED", "Channel not implemented" },
170 { AST_CAUSE_FACILITY_NOT_IMPLEMENTED, "FACILITY_NOT_IMPLEMENTED", "Facility not implemented" },
171 { AST_CAUSE_INVALID_CALL_REFERENCE, "INVALID_CALL_REFERENCE", "Invalid call reference value" },
172 { AST_CAUSE_INCOMPATIBLE_DESTINATION, "INCOMPATIBLE_DESTINATION", "Incompatible destination" },
173 { AST_CAUSE_INVALID_MSG_UNSPECIFIED, "INVALID_MSG_UNSPECIFIED", "Invalid message unspecified" },
174 { AST_CAUSE_MANDATORY_IE_MISSING, "MANDATORY_IE_MISSING", "Mandatory information element is missing" },
175 { AST_CAUSE_MESSAGE_TYPE_NONEXIST, "MESSAGE_TYPE_NONEXIST", "Message type nonexist." },
176 { AST_CAUSE_WRONG_MESSAGE, "WRONG_MESSAGE", "Wrong message" },
177 { AST_CAUSE_IE_NONEXIST, "IE_NONEXIST", "Info. element nonexist or not implemented" },
178 { AST_CAUSE_INVALID_IE_CONTENTS, "INVALID_IE_CONTENTS", "Invalid information element contents" },
179 { AST_CAUSE_WRONG_CALL_STATE, "WRONG_CALL_STATE", "Message not compatible with call state" },
180 { AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, "RECOVERY_ON_TIMER_EXPIRE", "Recover on timer expiry" },
181 { AST_CAUSE_MANDATORY_IE_LENGTH_ERROR, "MANDATORY_IE_LENGTH_ERROR", "Mandatory IE length error" },
182 { AST_CAUSE_PROTOCOL_ERROR, "PROTOCOL_ERROR", "Protocol error, unspecified" },
183 { AST_CAUSE_INTERWORKING, "INTERWORKING", "Interworking, unspecified" },
186 struct ast_variable *ast_channeltype_list(void)
189 struct ast_variable *var=NULL, *prev = NULL;
190 AST_LIST_TRAVERSE(&backends, cl, list) {
192 if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description)))
195 var = ast_variable_new(cl->tech->type, cl->tech->description);
202 /*! \brief Show channel types - CLI command */
203 static int show_channeltypes(int fd, int argc, char *argv[])
205 #define FORMAT "%-10.10s %-40.40s %-12.12s %-12.12s %-12.12s\n"
209 ast_cli(fd, FORMAT, "Type", "Description", "Devicestate", "Indications", "Transfer");
210 ast_cli(fd, FORMAT, "----------", "-----------", "-----------", "-----------", "--------");
211 if (AST_LIST_LOCK(&channels)) {
212 ast_log(LOG_WARNING, "Unable to lock channel list\n");
215 AST_LIST_TRAVERSE(&backends, cl, list) {
216 ast_cli(fd, FORMAT, cl->tech->type, cl->tech->description,
217 (cl->tech->devicestate) ? "yes" : "no",
218 (cl->tech->indicate) ? "yes" : "no",
219 (cl->tech->transfer) ? "yes" : "no");
222 AST_LIST_UNLOCK(&channels);
223 ast_cli(fd, "----------\n%d channel drivers registered.\n", count_chan);
224 return RESULT_SUCCESS;
230 /*! \brief Show details about a channel driver - CLI command */
231 static int show_channeltype(int fd, int argc, char *argv[])
233 struct chanlist *cl = NULL;
236 return RESULT_SHOWUSAGE;
238 if (AST_LIST_LOCK(&channels)) {
239 ast_log(LOG_WARNING, "Unable to lock channel list\n");
240 return RESULT_FAILURE;
243 AST_LIST_TRAVERSE(&backends, cl, list) {
244 if (!strncasecmp(cl->tech->type, argv[3], strlen(cl->tech->type))) {
251 ast_cli(fd, "\n%s is not a registered channel driver.\n", argv[3]);
252 AST_LIST_UNLOCK(&channels);
253 return RESULT_FAILURE;
257 "-- Info about channel driver: %s --\n"
258 " Device State: %s\n"
261 " Capabilities: %d\n"
265 " Image Support: %s\n"
266 " Text Support: %s\n",
268 (cl->tech->devicestate) ? "yes" : "no",
269 (cl->tech->indicate) ? "yes" : "no",
270 (cl->tech->transfer) ? "yes" : "no",
271 (cl->tech->capabilities) ? cl->tech->capabilities : -1,
272 (cl->tech->send_digit_begin) ? "yes" : "no",
273 (cl->tech->send_digit_end) ? "yes" : "no",
274 (cl->tech->send_html) ? "yes" : "no",
275 (cl->tech->send_image) ? "yes" : "no",
276 (cl->tech->send_text) ? "yes" : "no"
280 AST_LIST_UNLOCK(&channels);
281 return RESULT_SUCCESS;
284 static char *complete_channeltypes(const char *line, const char *word, int pos, int state)
294 wordlen = strlen(word);
296 AST_LIST_TRAVERSE(&backends, cl, list) {
297 if (!strncasecmp(word, cl->tech->type, wordlen) && ++which > state) {
298 ret = strdup(cl->tech->type);
306 static const char show_channeltypes_usage[] =
307 "Usage: core show channeltypes\n"
308 " Lists available channel types registered in your Asterisk server.\n";
310 static const char show_channeltype_usage[] =
311 "Usage: core show channeltype <name>\n"
312 " Show details about the specified channel type, <name>.\n";
314 static struct ast_cli_entry cli_channel[] = {
315 { { "core", "show", "channeltypes", NULL },
316 show_channeltypes, "List available channel types",
317 show_channeltypes_usage },
319 { { "core", "show", "channeltype", NULL },
320 show_channeltype, "Give more details on that channel type",
321 show_channeltype_usage, complete_channeltypes },
324 /*! \brief Checks to see if a channel is needing hang up */
325 int ast_check_hangup(struct ast_channel *chan)
327 if (chan->_softhangup) /* yes if soft hangup flag set */
329 if (!chan->tech_pvt) /* yes if no technology private data */
331 if (!chan->whentohangup) /* no if no hangup scheduled */
333 if (chan->whentohangup > time(NULL)) /* no if hangup time has not come yet. */
335 chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT; /* record event */
339 static int ast_check_hangup_locked(struct ast_channel *chan)
342 ast_channel_lock(chan);
343 res = ast_check_hangup(chan);
344 ast_channel_unlock(chan);
348 /*! \brief Initiate system shutdown */
349 void ast_begin_shutdown(int hangup)
351 struct ast_channel *c;
354 AST_LIST_LOCK(&channels);
355 AST_LIST_TRAVERSE(&channels, c, chan_list)
356 ast_softhangup(c, AST_SOFTHANGUP_SHUTDOWN);
357 AST_LIST_UNLOCK(&channels);
361 /*! \brief returns number of active/allocated channels */
362 int ast_active_channels(void)
364 struct ast_channel *c;
366 AST_LIST_LOCK(&channels);
367 AST_LIST_TRAVERSE(&channels, c, chan_list)
369 AST_LIST_UNLOCK(&channels);
373 /*! \brief Cancel a shutdown in progress */
374 void ast_cancel_shutdown(void)
379 /*! \brief Returns non-zero if Asterisk is being shut down */
380 int ast_shutting_down(void)
382 return shutting_down;
385 /*! \brief Set when to hangup channel */
386 void ast_channel_setwhentohangup(struct ast_channel *chan, time_t offset)
388 chan->whentohangup = offset ? time(NULL) + offset : 0;
389 ast_queue_frame(chan, &ast_null_frame);
393 /*! \brief Compare a offset with when to hangup channel */
394 int ast_channel_cmpwhentohangup(struct ast_channel *chan, time_t offset)
398 if (chan->whentohangup == 0) {
399 return (offset == 0) ? 0 : -1;
401 if (offset == 0) /* XXX why is this special ? */
404 whentohangup = offset + time (NULL);
405 if (chan->whentohangup < whentohangup)
407 else if (chan->whentohangup == whentohangup)
415 /*! \brief Register a new telephony channel in Asterisk */
416 int ast_channel_register(const struct ast_channel_tech *tech)
418 struct chanlist *chan;
420 AST_LIST_LOCK(&channels);
422 AST_LIST_TRAVERSE(&backends, chan, list) {
423 if (!strcasecmp(tech->type, chan->tech->type)) {
424 ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
425 AST_LIST_UNLOCK(&channels);
430 if (!(chan = ast_calloc(1, sizeof(*chan)))) {
431 AST_LIST_UNLOCK(&channels);
435 AST_LIST_INSERT_HEAD(&backends, chan, list);
438 ast_log(LOG_DEBUG, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);
440 if (option_verbose > 1)
441 ast_verbose(VERBOSE_PREFIX_2 "Registered channel type '%s' (%s)\n", chan->tech->type,
442 chan->tech->description);
444 AST_LIST_UNLOCK(&channels);
448 /*! \brief Unregister channel driver */
449 void ast_channel_unregister(const struct ast_channel_tech *tech)
451 struct chanlist *chan;
454 ast_log(LOG_DEBUG, "Unregistering channel type '%s'\n", tech->type);
456 AST_LIST_LOCK(&channels);
458 AST_LIST_TRAVERSE_SAFE_BEGIN(&backends, chan, list) {
459 if (chan->tech == tech) {
460 AST_LIST_REMOVE_CURRENT(&backends, list);
462 if (option_verbose > 1)
463 ast_verbose(VERBOSE_PREFIX_2 "Unregistered channel type '%s'\n", tech->type);
467 AST_LIST_TRAVERSE_SAFE_END
469 AST_LIST_UNLOCK(&channels);
472 /*! \brief Get handle to channel driver based on name */
473 const struct ast_channel_tech *ast_get_channel_tech(const char *name)
475 struct chanlist *chanls;
476 const struct ast_channel_tech *ret = NULL;
478 if (AST_LIST_LOCK(&channels)) {
479 ast_log(LOG_WARNING, "Unable to lock channel tech list\n");
483 AST_LIST_TRAVERSE(&backends, chanls, list) {
484 if (!strcasecmp(name, chanls->tech->type)) {
490 AST_LIST_UNLOCK(&channels);
495 /*! \brief Gives the string form of a given hangup cause */
496 const char *ast_cause2str(int cause)
500 for (x=0; x < sizeof(causes) / sizeof(causes[0]); x++) {
501 if (causes[x].cause == cause)
502 return causes[x].desc;
508 /*! \brief Convert a symbolic hangup cause to number */
509 int ast_str2cause(const char *name)
513 for (x = 0; x < sizeof(causes) / sizeof(causes[0]); x++)
514 if (strncasecmp(causes[x].name, name, strlen(causes[x].name)) == 0)
515 return causes[x].cause;
520 /*! \brief Gives the string form of a given channel state.
521 \note This function is not reentrant.
523 const char *ast_state2str(enum ast_channel_state state)
530 case AST_STATE_RESERVED:
532 case AST_STATE_OFFHOOK:
534 case AST_STATE_DIALING:
538 case AST_STATE_RINGING:
544 case AST_STATE_DIALING_OFFHOOK:
545 return "Dialing Offhook";
546 case AST_STATE_PRERING:
549 if (!(buf = ast_threadstorage_get(&state2str_threadbuf, STATE2STR_BUFSIZE)))
551 snprintf(buf, STATE2STR_BUFSIZE, "Unknown (%d)", state);
556 /*! \brief Gives the string form of a given transfer capability */
557 char *ast_transfercapability2str(int transfercapability)
559 switch (transfercapability) {
560 case AST_TRANS_CAP_SPEECH:
562 case AST_TRANS_CAP_DIGITAL:
564 case AST_TRANS_CAP_RESTRICTED_DIGITAL:
565 return "RESTRICTED_DIGITAL";
566 case AST_TRANS_CAP_3_1K_AUDIO:
568 case AST_TRANS_CAP_DIGITAL_W_TONES:
569 return "DIGITAL_W_TONES";
570 case AST_TRANS_CAP_VIDEO:
577 /*! \brief Pick the best audio codec */
578 int ast_best_codec(int fmts)
580 /* This just our opinion, expressed in code. We are asked to choose
581 the best codec to use, given no information */
583 static const int prefs[] =
585 /*! Okay, ulaw is used by all telephony equipment, so start with it */
587 /*! Unless of course, you're a silly European, so then prefer ALAW */
589 /*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */
591 /*! Okay, well, signed linear is easy to translate into other stuff */
593 /*! G.726 is standard ADPCM, in RFC3551 packing order */
595 /*! G.726 is standard ADPCM, in AAL2 packing order */
596 AST_FORMAT_G726_AAL2,
597 /*! ADPCM has great sound quality and is still pretty easy to translate */
599 /*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
600 translate and sounds pretty good */
602 /*! iLBC is not too bad */
604 /*! Speex is free, but computationally more expensive than GSM */
606 /*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
609 /*! G.729a is faster than 723 and slightly less expensive */
611 /*! Down to G.723.1 which is proprietary but at least designed for voice */
615 /* Strip out video */
616 fmts &= AST_FORMAT_AUDIO_MASK;
618 /* Find the first preferred codec in the format given */
619 for (x=0; x < (sizeof(prefs) / sizeof(prefs[0]) ); x++)
622 ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts);
626 static const struct ast_channel_tech null_tech = {
628 .description = "Null channel (should not see this)",
631 /*! \brief Create a new channel structure */
632 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, ...)
634 struct ast_channel *tmp;
637 struct varshead *headp;
640 /* If shutting down, don't allocate any new channels */
642 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
646 if (!(tmp = ast_calloc(1, sizeof(*tmp))))
649 if (!(tmp->sched = sched_context_create())) {
650 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
655 if ((ast_string_field_init(tmp, 128))) {
656 sched_context_destroy(tmp->sched);
661 /* Don't bother initializing the last two FD here, because they
662 will *always* be set just a few lines down (AST_TIMING_FD,
664 for (x = 0; x < AST_MAX_FDS - 2; x++)
668 tmp->timingfd = open("/dev/zap/timer", O_RDWR);
669 if (tmp->timingfd > -1) {
670 /* Check if timing interface supports new
673 if (!ioctl(tmp->timingfd, ZT_TIMERPONG, &flags))
681 if (pipe(tmp->alertpipe)) {
682 ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
683 ast_string_field_free_pools(tmp);
687 flags = fcntl(tmp->alertpipe[0], F_GETFL);
688 fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK);
689 flags = fcntl(tmp->alertpipe[1], F_GETFL);
690 fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK);
692 } else /* Make sure we've got it done right if they don't */
693 tmp->alertpipe[0] = tmp->alertpipe[1] = -1;
695 /* Always watch the alertpipe */
696 tmp->fds[AST_ALERT_FD] = tmp->alertpipe[0];
697 /* And timing pipe */
698 tmp->fds[AST_TIMING_FD] = tmp->timingfd;
699 ast_string_field_set(tmp, name, "**Unknown**");
706 tmp->fin = global_fin;
707 tmp->fout = global_fout;
709 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
710 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL),
711 ast_atomic_fetchadd_int(&uniqueint, 1));
713 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME,
714 (long) time(NULL), ast_atomic_fetchadd_int(&uniqueint, 1));
717 tmp->cid.cid_name = ast_strdup(cid_name);
718 tmp->cid.cid_num = ast_strdup(cid_num);
720 if (!ast_strlen_zero(name_fmt)) {
721 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
722 * And they all use slightly different formats for their name string.
723 * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
724 * This means, that the stringfields must have a routine that takes the va_lists directly, and
725 * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
726 * This new function was written so this can be accomplished.
728 va_start(ap1, name_fmt);
729 va_start(ap2, name_fmt);
730 ast_string_field_build_va(tmp, name, name_fmt, ap1, ap2);
734 /* and now, since the channel structure is built, and has its name, let's call the
735 * manager event generator with this Newchannel event. This is the proper and correct
736 * place to make this call, but you sure do have to pass a lot of data into this func
739 manager_event(EVENT_FLAG_CALL, "Newchannel",
742 "CallerIDNum: %s\r\n"
743 "CallerIDName: %s\r\n"
745 tmp->name, ast_state2str(state),
746 S_OR(cid_num, "<unknown>"),
747 S_OR(cid_name, "<unknown>"),
751 /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */
753 /* These 4 variables need to be set up for the cdr_init() to work right */
755 tmp->amaflags = amaflag;
757 tmp->amaflags = ast_default_amaflags;
759 if (!ast_strlen_zero(acctcode))
760 ast_string_field_set(tmp, accountcode, acctcode);
762 ast_string_field_set(tmp, accountcode, ast_default_accountcode);
764 if (!ast_strlen_zero(context))
765 ast_copy_string(tmp->context, context, sizeof(tmp->context));
767 strcpy(tmp->context, "default");
769 if (!ast_strlen_zero(exten))
770 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten));
772 strcpy(tmp->exten, "s");
776 tmp->cdr = ast_cdr_alloc();
777 ast_cdr_init(tmp->cdr, tmp);
778 ast_cdr_start(tmp->cdr);
780 headp = &tmp->varshead;
781 AST_LIST_HEAD_INIT_NOLOCK(headp);
783 ast_mutex_init(&tmp->lock);
785 AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores);
787 ast_string_field_set(tmp, language, defaultlanguage);
789 tmp->tech = &null_tech;
791 AST_LIST_LOCK(&channels);
792 AST_LIST_INSERT_HEAD(&channels, tmp, chan_list);
793 AST_LIST_UNLOCK(&channels);
798 /*! \brief Queue an outgoing media frame */
799 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
802 struct ast_frame *cur;
806 /* Build us a copy and free the original one */
807 if (!(f = ast_frdup(fin))) {
808 ast_log(LOG_WARNING, "Unable to duplicate frame\n");
811 ast_channel_lock(chan);
813 /* See if the last frame on the queue is a hangup, if so don't queue anything */
814 if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
816 ast_channel_unlock(chan);
820 /* Count how many frames exist on the queue */
821 AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
825 /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
826 if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen > 128)) {
827 if (fin->frametype != AST_FRAME_VOICE) {
828 ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name);
832 ast_log(LOG_DEBUG, "Dropping voice to exceptionally long queue on %s\n", chan->name);
834 ast_channel_unlock(chan);
838 AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
839 if (chan->alertpipe[1] > -1) {
840 if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
841 ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
842 chan->name, f->frametype, f->subclass, qlen, strerror(errno));
844 } else if (chan->timingfd > -1) {
845 ioctl(chan->timingfd, ZT_TIMERPING, &blah);
847 } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
848 pthread_kill(chan->blocker, SIGURG);
850 ast_channel_unlock(chan);
854 /*! \brief Queue a hangup frame for channel */
855 int ast_queue_hangup(struct ast_channel *chan)
857 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
858 /* Yeah, let's not change a lock-critical value without locking */
859 if (!ast_channel_trylock(chan)) {
860 chan->_softhangup |= AST_SOFTHANGUP_DEV;
861 ast_channel_unlock(chan);
863 return ast_queue_frame(chan, &f);
866 /*! \brief Queue a control frame */
867 int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
869 struct ast_frame f = { AST_FRAME_CONTROL, };
871 f.subclass = control;
873 return ast_queue_frame(chan, &f);
876 /*! \brief Queue a control frame with payload */
877 int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control,
878 const void *data, size_t datalen)
880 struct ast_frame f = { AST_FRAME_CONTROL, };
882 f.subclass = control;
883 f.data = (void *) data;
886 return ast_queue_frame(chan, &f);
889 /*! \brief Set defer DTMF flag on channel */
890 int ast_channel_defer_dtmf(struct ast_channel *chan)
895 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
896 ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
901 /*! \brief Unset defer DTMF flag on channel */
902 void ast_channel_undefer_dtmf(struct ast_channel *chan)
905 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
909 * \brief Helper function to find channels.
911 * It supports these modes:
913 * prev != NULL : get channel next in list after prev
914 * name != NULL : get channel with matching name
915 * name != NULL && namelen != 0 : get channel whose name starts with prefix
916 * exten != NULL : get channel whose exten or macroexten matches
917 * context != NULL && exten != NULL : get channel whose context or macrocontext
919 * It returns with the channel's lock held. If getting the individual lock fails,
920 * unlock and retry quickly up to 10 times, then give up.
922 * \note XXX Note that this code has cost O(N) because of the need to verify
923 * that the object is still on the global list.
925 * \note XXX also note that accessing fields (e.g. c->name in ast_log())
926 * can only be done with the lock held or someone could delete the
927 * object while we work on it. This causes some ugliness in the code.
928 * Note that removing the first ast_log() may be harmful, as it would
929 * shorten the retry period and possibly cause failures.
930 * We should definitely go for a better scheme that is deadlock-free.
932 static struct ast_channel *channel_find_locked(const struct ast_channel *prev,
933 const char *name, const int namelen,
934 const char *context, const char *exten)
936 const char *msg = prev ? "deadlock" : "initial deadlock";
938 struct ast_channel *c;
940 for (retries = 0; retries < 10; retries++) {
942 AST_LIST_LOCK(&channels);
943 AST_LIST_TRAVERSE(&channels, c, chan_list) {
944 if (prev) { /* look for next item */
945 if (c != prev) /* not this one */
947 /* found, prepare to return c->next */
948 if ((c = AST_LIST_NEXT(c, chan_list)) == NULL) break;
949 /* If prev was the last item on the channel list, then we just
950 * want to return NULL, instead of trying to deref NULL in the
954 /* We want prev to be NULL in case we end up doing more searching through
955 * the channel list to find the channel (ie: name searching). If we didn't
956 * set this to NULL the logic would just blow up
959 if (name) { /* want match by name */
960 if ((!namelen && strcasecmp(c->name, name)) ||
961 (namelen && strncasecmp(c->name, name, namelen)))
962 continue; /* name match failed */
964 if (context && strcasecmp(c->context, context) &&
965 strcasecmp(c->macrocontext, context))
966 continue; /* context match failed */
967 if (strcasecmp(c->exten, exten) &&
968 strcasecmp(c->macroexten, exten))
969 continue; /* exten match failed */
971 /* if we get here, c points to the desired record */
974 /* exit if chan not found or mutex acquired successfully */
975 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
976 done = c == NULL || ast_channel_trylock(c) == 0;
979 ast_log(LOG_DEBUG, "Avoiding %s for channel '%p'\n", msg, c);
981 AST_LIST_UNLOCK(&channels);
984 usleep(1); /* give other threads a chance before retrying */
987 * c is surely not null, but we don't have the lock so cannot
991 ast_log(LOG_DEBUG, "Failure, could not lock '%p' after %d retries!\n",
997 /*! \brief Browse channels in use */
998 struct ast_channel *ast_channel_walk_locked(const struct ast_channel *prev)
1000 return channel_find_locked(prev, NULL, 0, NULL, NULL);
1003 /*! \brief Get channel by name and lock it */
1004 struct ast_channel *ast_get_channel_by_name_locked(const char *name)
1006 return channel_find_locked(NULL, name, 0, NULL, NULL);
1009 /*! \brief Get channel by name prefix and lock it */
1010 struct ast_channel *ast_get_channel_by_name_prefix_locked(const char *name, const int namelen)
1012 return channel_find_locked(NULL, name, namelen, NULL, NULL);
1015 /*! \brief Get next channel by name prefix and lock it */
1016 struct ast_channel *ast_walk_channel_by_name_prefix_locked(const struct ast_channel *chan, const char *name,
1019 return channel_find_locked(chan, name, namelen, NULL, NULL);
1022 /*! \brief Get channel by exten (and optionally context) and lock it */
1023 struct ast_channel *ast_get_channel_by_exten_locked(const char *exten, const char *context)
1025 return channel_find_locked(NULL, NULL, 0, context, exten);
1028 /*! \brief Get next channel by exten (and optionally context) and lock it */
1029 struct ast_channel *ast_walk_channel_by_exten_locked(const struct ast_channel *chan, const char *exten,
1030 const char *context)
1032 return channel_find_locked(chan, NULL, 0, context, exten);
1035 /*! \brief Wait, look for hangups and condition arg */
1036 int ast_safe_sleep_conditional(struct ast_channel *chan, int ms, int (*cond)(void*), void *data)
1038 struct ast_frame *f;
1041 if (cond && ((*cond)(data) == 0))
1043 ms = ast_waitfor(chan, ms);
1056 /*! \brief Wait, look for hangups */
1057 int ast_safe_sleep(struct ast_channel *chan, int ms)
1059 return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
1062 static void free_cid(struct ast_callerid *cid)
1065 ast_free(cid->cid_dnid);
1067 ast_free(cid->cid_num);
1069 ast_free(cid->cid_name);
1071 ast_free(cid->cid_ani);
1073 ast_free(cid->cid_rdnis);
1074 cid->cid_dnid = cid->cid_num = cid->cid_name = cid->cid_ani = cid->cid_rdnis = NULL;
1077 /*! \brief Free a channel structure */
1078 void ast_channel_free(struct ast_channel *chan)
1081 struct ast_var_t *vardata;
1082 struct ast_frame *f;
1083 struct varshead *headp;
1084 struct ast_datastore *datastore = NULL;
1085 char name[AST_CHANNEL_NAME];
1087 headp=&chan->varshead;
1089 AST_LIST_LOCK(&channels);
1090 if (!AST_LIST_REMOVE(&channels, chan, chan_list)) {
1091 AST_LIST_UNLOCK(&channels);
1092 ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
1094 /* Lock and unlock the channel just to be sure nobody
1095 has it locked still */
1096 ast_channel_lock(chan);
1097 ast_channel_unlock(chan);
1098 if (chan->tech_pvt) {
1099 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
1100 ast_free(chan->tech_pvt);
1104 sched_context_destroy(chan->sched);
1106 ast_copy_string(name, chan->name, sizeof(name));
1108 /* Stop monitoring */
1110 chan->monitor->stop( chan, 0 );
1112 /* If there is native format music-on-hold state, free it */
1113 if (chan->music_state)
1114 ast_moh_cleanup(chan);
1116 /* if someone is whispering on the channel, stop them */
1118 ast_channel_whisper_stop(chan);
1120 /* Free translators */
1121 if (chan->readtrans)
1122 ast_translator_free_path(chan->readtrans);
1123 if (chan->writetrans)
1124 ast_translator_free_path(chan->writetrans);
1126 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
1127 free_cid(&chan->cid);
1128 ast_mutex_destroy(&chan->lock);
1129 /* Close pipes if appropriate */
1130 if ((fd = chan->alertpipe[0]) > -1)
1132 if ((fd = chan->alertpipe[1]) > -1)
1134 if ((fd = chan->timingfd) > -1)
1136 while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
1139 /* Get rid of each of the data stores on the channel */
1140 while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
1141 /* Free the data store */
1142 ast_channel_datastore_free(datastore);
1143 AST_LIST_HEAD_INIT_NOLOCK(&chan->datastores);
1145 /* loop over the variables list, freeing all data and deleting list items */
1146 /* no need to lock the list, as the channel is already locked */
1148 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
1149 ast_var_delete(vardata);
1151 ast_app_group_discard(chan);
1153 /* Destroy the jitterbuffer */
1154 ast_jb_destroy(chan);
1156 ast_string_field_free_pools(chan);
1158 AST_LIST_UNLOCK(&channels);
1160 ast_device_state_changed_literal(name);
1163 struct ast_datastore *ast_channel_datastore_alloc(const struct ast_datastore_info *info, char *uid)
1165 struct ast_datastore *datastore = NULL;
1167 /* Make sure we at least have type so we can identify this */
1172 /* Allocate memory for datastore and clear it */
1173 datastore = ast_calloc(1, sizeof(*datastore));
1178 datastore->info = info;
1180 datastore->uid = ast_strdup(uid);
1185 int ast_channel_datastore_free(struct ast_datastore *datastore)
1189 /* Using the destroy function (if present) destroy the data */
1190 if (datastore->info->destroy != NULL && datastore->data != NULL) {
1191 datastore->info->destroy(datastore->data);
1192 datastore->data = NULL;
1195 /* Free allocated UID memory */
1196 if (datastore->uid != NULL) {
1197 ast_free(datastore->uid);
1198 datastore->uid = NULL;
1201 /* Finally free memory used by ourselves */
1202 ast_free(datastore);
1207 int ast_channel_datastore_inherit(struct ast_channel *from, struct ast_channel *to)
1209 struct ast_datastore *datastore = NULL, *datastore2;
1211 AST_LIST_TRAVERSE(&from->datastores, datastore, entry) {
1212 if (datastore->inheritance > 0) {
1213 datastore2 = ast_channel_datastore_alloc(datastore->info, datastore->uid);
1215 datastore2->data = datastore->info->duplicate(datastore->data);
1216 datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
1217 AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry);
1224 int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
1228 AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
1233 int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
1235 struct ast_datastore *datastore2 = NULL;
1238 /* Find our position and remove ourselves */
1239 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore2, entry) {
1240 if (datastore2 == datastore) {
1241 AST_LIST_REMOVE_CURRENT(&chan->datastores, entry);
1246 AST_LIST_TRAVERSE_SAFE_END
1251 struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, char *uid)
1253 struct ast_datastore *datastore = NULL;
1258 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
1259 if (datastore->info == info) {
1260 if (uid != NULL && datastore->uid != NULL) {
1261 if (!strcasecmp(uid, datastore->uid)) {
1262 /* Matched by type AND uid */
1266 /* Matched by type at least */
1271 AST_LIST_TRAVERSE_SAFE_END
1276 int ast_channel_spy_add(struct ast_channel *chan, struct ast_channel_spy *spy)
1278 /* Link the owner channel to the spy */
1281 if (!ast_test_flag(spy, CHANSPY_FORMAT_AUDIO)) {
1282 ast_log(LOG_WARNING, "Could not add channel spy '%s' to channel '%s', only audio format spies are supported.\n",
1283 spy->type, chan->name);
1287 if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST) && (spy->read_queue.format != AST_FORMAT_SLINEAR)) {
1288 ast_log(LOG_WARNING, "Cannot provide volume adjustment on '%s' format spies\n",
1289 ast_getformatname(spy->read_queue.format));
1293 if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST) && (spy->write_queue.format != AST_FORMAT_SLINEAR)) {
1294 ast_log(LOG_WARNING, "Cannot provide volume adjustment on '%s' format spies\n",
1295 ast_getformatname(spy->write_queue.format));
1299 if (ast_test_flag(spy, CHANSPY_MIXAUDIO) &&
1300 ((spy->read_queue.format != AST_FORMAT_SLINEAR) ||
1301 (spy->write_queue.format != AST_FORMAT_SLINEAR))) {
1302 ast_log(LOG_WARNING, "Cannot provide audio mixing on '%s'-'%s' format spies\n",
1303 ast_getformatname(spy->read_queue.format), ast_getformatname(spy->write_queue.format));
1308 if (!(chan->spies = ast_calloc(1, sizeof(*chan->spies)))) {
1312 AST_LIST_HEAD_INIT_NOLOCK(&chan->spies->list);
1313 AST_LIST_INSERT_HEAD(&chan->spies->list, spy, list);
1315 AST_LIST_INSERT_TAIL(&chan->spies->list, spy, list);
1318 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) {
1319 ast_cond_init(&spy->trigger, NULL);
1320 ast_set_flag(spy, CHANSPY_TRIGGER_READ);
1321 ast_clear_flag(spy, CHANSPY_TRIGGER_WRITE);
1325 ast_log(LOG_DEBUG, "Spy %s added to channel %s\n",
1326 spy->type, chan->name);
1331 /* Clean up a channel's spy information */
1332 static void spy_cleanup(struct ast_channel *chan)
1334 if (!AST_LIST_EMPTY(&chan->spies->list))
1336 if (chan->spies->read_translator.path)
1337 ast_translator_free_path(chan->spies->read_translator.path);
1338 if (chan->spies->write_translator.path)
1339 ast_translator_free_path(chan->spies->write_translator.path);
1340 ast_free(chan->spies);
1345 /* Detach a spy from it's channel */
1346 static void spy_detach(struct ast_channel_spy *spy, struct ast_channel *chan)
1348 ast_mutex_lock(&spy->lock);
1350 /* We only need to poke them if they aren't already done */
1351 if (spy->status != CHANSPY_DONE) {
1352 /* Indicate to the spy to stop */
1353 spy->status = CHANSPY_STOP;
1355 /* Poke the spy if needed */
1356 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
1357 ast_cond_signal(&spy->trigger);
1360 /* Print it out while we still have a lock so the structure can't go away (if signalled above) */
1362 ast_log(LOG_DEBUG, "Spy %s removed from channel %s\n", spy->type, chan->name);
1364 ast_mutex_unlock(&spy->lock);
1369 void ast_channel_spy_stop_by_type(struct ast_channel *chan, const char *type)
1371 struct ast_channel_spy *spy = NULL;
1376 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->spies->list, spy, list) {
1377 ast_mutex_lock(&spy->lock);
1378 if ((spy->type == type) && (spy->status == CHANSPY_RUNNING)) {
1379 ast_mutex_unlock(&spy->lock);
1380 AST_LIST_REMOVE_CURRENT(&chan->spies->list, list);
1381 spy_detach(spy, chan);
1383 ast_mutex_unlock(&spy->lock);
1385 AST_LIST_TRAVERSE_SAFE_END
1389 void ast_channel_spy_trigger_wait(struct ast_channel_spy *spy)
1394 tv = ast_tvadd(ast_tvnow(), ast_samp2tv(50000, 1000));
1395 ts.tv_sec = tv.tv_sec;
1396 ts.tv_nsec = tv.tv_usec * 1000;
1398 ast_cond_timedwait(&spy->trigger, &spy->lock, &ts);
1401 void ast_channel_spy_remove(struct ast_channel *chan, struct ast_channel_spy *spy)
1406 AST_LIST_REMOVE(&chan->spies->list, spy, list);
1407 spy_detach(spy, chan);
1411 void ast_channel_spy_free(struct ast_channel_spy *spy)
1413 struct ast_frame *f = NULL;
1415 if (spy->status == CHANSPY_DONE)
1418 /* Switch status to done in case we get called twice */
1419 spy->status = CHANSPY_DONE;
1421 /* Drop any frames in the queue */
1422 while ((f = AST_LIST_REMOVE_HEAD(&spy->write_queue.list, frame_list)))
1424 while ((f = AST_LIST_REMOVE_HEAD(&spy->read_queue.list, frame_list)))
1427 /* Destroy the condition if in use */
1428 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
1429 ast_cond_destroy(&spy->trigger);
1431 /* Destroy our mutex since it is no longer in use */
1432 ast_mutex_destroy(&spy->lock);
1437 static void detach_spies(struct ast_channel *chan)
1439 struct ast_channel_spy *spy = NULL;
1444 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->spies->list, spy, list) {
1445 AST_LIST_REMOVE_CURRENT(&chan->spies->list, list);
1446 spy_detach(spy, chan);
1448 AST_LIST_TRAVERSE_SAFE_END
1453 /*! \brief Softly hangup a channel, don't lock */
1454 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
1457 ast_log(LOG_DEBUG, "Soft-Hanging up channel '%s'\n", chan->name);
1458 /* Inform channel driver that we need to be hung up, if it cares */
1459 chan->_softhangup |= cause;
1460 ast_queue_frame(chan, &ast_null_frame);
1461 /* Interrupt any poll call or such */
1462 if (ast_test_flag(chan, AST_FLAG_BLOCKING))
1463 pthread_kill(chan->blocker, SIGURG);
1467 /*! \brief Softly hangup a channel, lock */
1468 int ast_softhangup(struct ast_channel *chan, int cause)
1471 ast_channel_lock(chan);
1472 res = ast_softhangup_nolock(chan, cause);
1473 ast_channel_unlock(chan);
1477 enum spy_direction {
1482 #define SPY_QUEUE_SAMPLE_LIMIT 4000 /* half of one second */
1484 static void queue_frame_to_spies(struct ast_channel *chan, struct ast_frame *f, enum spy_direction dir)
1486 struct ast_frame *translated_frame = NULL;
1487 struct ast_channel_spy *spy;
1488 struct channel_spy_trans *trans;
1490 trans = (dir == SPY_READ) ? &chan->spies->read_translator : &chan->spies->write_translator;
1492 AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
1493 struct ast_channel_spy_queue *queue;
1494 struct ast_frame *duped_fr;
1496 ast_mutex_lock(&spy->lock);
1498 queue = (dir == SPY_READ) ? &spy->read_queue : &spy->write_queue;
1500 if ((queue->format == AST_FORMAT_SLINEAR) && (f->subclass != AST_FORMAT_SLINEAR)) {
1501 if (!translated_frame) {
1502 if (trans->path && (trans->last_format != f->subclass)) {
1503 ast_translator_free_path(trans->path);
1508 ast_log(LOG_DEBUG, "Building translator from %s to SLINEAR for spies on channel %s\n",
1509 ast_getformatname(f->subclass), chan->name);
1510 if ((trans->path = ast_translator_build_path(AST_FORMAT_SLINEAR, f->subclass)) == NULL) {
1511 ast_log(LOG_WARNING, "Cannot build a path from %s to %s\n",
1512 ast_getformatname(f->subclass), ast_getformatname(AST_FORMAT_SLINEAR));
1513 ast_mutex_unlock(&spy->lock);
1516 trans->last_format = f->subclass;
1519 if (!(translated_frame = ast_translate(trans->path, f, 0))) {
1520 ast_log(LOG_ERROR, "Translation to %s failed, dropping frame for spies\n",
1521 ast_getformatname(AST_FORMAT_SLINEAR));
1522 ast_mutex_unlock(&spy->lock);
1526 duped_fr = ast_frdup(translated_frame);
1527 } else if (f->subclass != queue->format) {
1528 ast_log(LOG_WARNING, "Spy '%s' on channel '%s' wants format '%s', but frame is '%s', dropping\n",
1529 spy->type, chan->name,
1530 ast_getformatname(queue->format), ast_getformatname(f->subclass));
1531 ast_mutex_unlock(&spy->lock);
1534 duped_fr = ast_frdup(f);
1536 AST_LIST_INSERT_TAIL(&queue->list, duped_fr, frame_list);
1538 queue->samples += f->samples;
1540 if (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
1541 if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) {
1542 switch (ast_test_flag(spy, CHANSPY_TRIGGER_MODE)) {
1543 case CHANSPY_TRIGGER_READ:
1544 if (dir == SPY_WRITE) {
1545 ast_set_flag(spy, CHANSPY_TRIGGER_WRITE);
1546 ast_clear_flag(spy, CHANSPY_TRIGGER_READ);
1548 ast_log(LOG_DEBUG, "Switching spy '%s' on '%s' to write-trigger mode\n",
1549 spy->type, chan->name);
1552 case CHANSPY_TRIGGER_WRITE:
1553 if (dir == SPY_READ) {
1554 ast_set_flag(spy, CHANSPY_TRIGGER_READ);
1555 ast_clear_flag(spy, CHANSPY_TRIGGER_WRITE);
1557 ast_log(LOG_DEBUG, "Switching spy '%s' on '%s' to read-trigger mode\n",
1558 spy->type, chan->name);
1563 ast_log(LOG_DEBUG, "Triggering queue flush for spy '%s' on '%s'\n",
1564 spy->type, chan->name);
1565 ast_set_flag(spy, CHANSPY_TRIGGER_FLUSH);
1566 ast_cond_signal(&spy->trigger);
1569 ast_log(LOG_DEBUG, "Spy '%s' on channel '%s' %s queue too long, dropping frames\n",
1570 spy->type, chan->name, (dir == SPY_READ) ? "read" : "write");
1571 while (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
1572 struct ast_frame *drop = AST_LIST_REMOVE_HEAD(&queue->list, frame_list);
1573 queue->samples -= drop->samples;
1578 switch (ast_test_flag(spy, CHANSPY_TRIGGER_MODE)) {
1579 case CHANSPY_TRIGGER_READ:
1580 if (dir == SPY_READ)
1581 ast_cond_signal(&spy->trigger);
1583 case CHANSPY_TRIGGER_WRITE:
1584 if (dir == SPY_WRITE)
1585 ast_cond_signal(&spy->trigger);
1590 ast_mutex_unlock(&spy->lock);
1593 if (translated_frame)
1594 ast_frfree(translated_frame);
1597 static void free_translation(struct ast_channel *clone)
1599 if (clone->writetrans)
1600 ast_translator_free_path(clone->writetrans);
1601 if (clone->readtrans)
1602 ast_translator_free_path(clone->readtrans);
1603 clone->writetrans = NULL;
1604 clone->readtrans = NULL;
1605 clone->rawwriteformat = clone->nativeformats;
1606 clone->rawreadformat = clone->nativeformats;
1609 /*! \brief Hangup a channel */
1610 int ast_hangup(struct ast_channel *chan)
1614 /* Don't actually hang up a channel that will masquerade as someone else, or
1615 if someone is going to masquerade as us */
1616 ast_channel_lock(chan);
1618 detach_spies(chan); /* get rid of spies */
1621 if (ast_do_masquerade(chan))
1622 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
1626 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
1627 ast_channel_unlock(chan);
1630 /* If this channel is one which will be masqueraded into something,
1631 mark it as a zombie already, so we know to free it later */
1633 ast_set_flag(chan, AST_FLAG_ZOMBIE);
1634 ast_channel_unlock(chan);
1637 free_translation(chan);
1638 /* Close audio stream */
1640 ast_closestream(chan->stream);
1641 chan->stream = NULL;
1643 /* Close video stream */
1644 if (chan->vstream) {
1645 ast_closestream(chan->vstream);
1646 chan->vstream = NULL;
1649 sched_context_destroy(chan->sched);
1653 if (chan->generatordata) /* Clear any tone stuff remaining */
1654 if (chan->generator && chan->generator->release)
1655 chan->generator->release(chan, chan->generatordata);
1656 chan->generatordata = NULL;
1657 chan->generator = NULL;
1658 if (chan->cdr) { /* End the CDR if it hasn't already */
1659 ast_cdr_end(chan->cdr);
1660 ast_cdr_detach(chan->cdr); /* Post and Free the CDR */
1663 if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
1664 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
1665 "is blocked by thread %ld in procedure %s! Expect a failure\n",
1666 (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
1669 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
1671 ast_log(LOG_DEBUG, "Hanging up channel '%s'\n", chan->name);
1672 if (chan->tech->hangup)
1673 res = chan->tech->hangup(chan);
1676 ast_log(LOG_DEBUG, "Hanging up zombie '%s'\n", chan->name);
1679 ast_channel_unlock(chan);
1680 manager_event(EVENT_FLAG_CALL, "Hangup",
1684 "Cause-txt: %s\r\n",
1688 ast_cause2str(chan->hangupcause)
1690 ast_channel_free(chan);
1694 int __ast_answer(struct ast_channel *chan, unsigned int delay)
1698 ast_channel_lock(chan);
1700 /* You can't answer an outbound call */
1701 if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
1702 ast_channel_unlock(chan);
1706 /* Stop if we're a zombie or need a soft hangup */
1707 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
1708 ast_channel_unlock(chan);
1712 switch (chan->_state) {
1713 case AST_STATE_RINGING:
1714 case AST_STATE_RING:
1715 if (chan->tech->answer)
1716 res = chan->tech->answer(chan);
1717 ast_setstate(chan, AST_STATE_UP);
1718 ast_cdr_answer(chan->cdr);
1719 ast_channel_unlock(chan);
1721 ast_safe_sleep(chan, delay);
1725 ast_cdr_answer(chan->cdr);
1731 ast_channel_unlock(chan);
1736 int ast_answer(struct ast_channel *chan)
1738 return __ast_answer(chan, 500);
1741 void ast_deactivate_generator(struct ast_channel *chan)
1743 ast_channel_lock(chan);
1744 if (chan->generatordata) {
1745 if (chan->generator && chan->generator->release)
1746 chan->generator->release(chan, chan->generatordata);
1747 chan->generatordata = NULL;
1748 chan->generator = NULL;
1749 chan->fds[AST_GENERATOR_FD] = -1;
1750 ast_clear_flag(chan, AST_FLAG_WRITE_INT);
1751 ast_settimeout(chan, 0, NULL, NULL);
1753 ast_channel_unlock(chan);
1756 static int generator_force(void *data)
1758 /* Called if generator doesn't have data */
1761 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
1762 struct ast_channel *chan = data;
1763 tmp = chan->generatordata;
1764 chan->generatordata = NULL;
1765 generate = chan->generator->generate;
1766 res = generate(chan, tmp, 0, 160);
1767 chan->generatordata = tmp;
1770 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
1771 ast_deactivate_generator(chan);
1776 int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
1780 ast_channel_lock(chan);
1782 if (chan->generatordata) {
1783 if (chan->generator && chan->generator->release)
1784 chan->generator->release(chan, chan->generatordata);
1785 chan->generatordata = NULL;
1789 if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
1794 ast_settimeout(chan, 160, generator_force, chan);
1795 chan->generator = gen;
1798 ast_channel_unlock(chan);
1803 /*! \brief Wait for x amount of time on a file descriptor to have input. */
1804 int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
1807 ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
1811 /*! \brief Wait for x amount of time on a file descriptor to have input. */
1812 struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
1813 int *exception, int *outfd, int *ms)
1815 struct timeval start = { 0 , 0 };
1816 struct pollfd *pfds;
1822 long whentohangup = 0, diff;
1823 struct ast_channel *winner = NULL;
1829 sz = n * AST_MAX_FDS + nfds;
1830 pfds = alloca(sizeof(*pfds) * sz);
1831 fdmap = alloca(sizeof(*fdmap) * sz);
1838 /* Perform any pending masquerades */
1839 for (x=0; x < n; x++) {
1840 ast_channel_lock(c[x]);
1842 if (ast_do_masquerade(c[x])) {
1843 ast_log(LOG_WARNING, "Masquerade failed\n");
1845 ast_channel_unlock(c[x]);
1849 if (c[x]->whentohangup) {
1852 diff = c[x]->whentohangup - now;
1854 /* Should already be hungup */
1855 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1856 ast_channel_unlock(c[x]);
1859 if (!whentohangup || (diff < whentohangup))
1860 whentohangup = diff;
1862 ast_channel_unlock(c[x]);
1864 /* Wait full interval */
1867 rms = whentohangup * 1000; /* timeout in milliseconds */
1868 if (*ms >= 0 && *ms < rms) /* original *ms still smaller */
1872 * Build the pollfd array, putting the channels' fds first,
1873 * followed by individual fds. Order is important because
1874 * individual fd's must have priority over channel fds.
1877 for (x=0; x<n; x++) {
1878 for (y=0; y<AST_MAX_FDS; y++) {
1879 fdmap[max].fdno = y; /* fd y is linked to this pfds */
1880 fdmap[max].chan = x; /* channel x is linked to this pfds */
1881 max += ast_add_fd(&pfds[max], c[x]->fds[y]);
1883 CHECK_BLOCKING(c[x]);
1885 /* Add the individual fds */
1886 for (x=0; x<nfds; x++) {
1887 fdmap[max].chan = -1;
1888 max += ast_add_fd(&pfds[max], fds[x]);
1892 start = ast_tvnow();
1894 if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1899 res = poll(pfds, max, kbrms);
1902 } while (!res && (rms > 0));
1904 res = poll(pfds, max, rms);
1907 ast_clear_flag(c[x], AST_FLAG_BLOCKING);
1908 if (res < 0) { /* Simulate a timeout if we were interrupted */
1913 if (whentohangup) { /* if we have a timeout, check who expired */
1915 for (x=0; x<n; x++) {
1916 if (c[x]->whentohangup && now >= c[x]->whentohangup) {
1917 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
1923 if (res == 0) { /* no fd ready, reset timeout and done */
1924 *ms = 0; /* XXX use 0 since we may not have an exact timeout. */
1928 * Then check if any channel or fd has a pending event.
1929 * Remember to check channels first and fds last, as they
1930 * must have priority on setting 'winner'
1932 for (x = 0; x < max; x++) {
1933 res = pfds[x].revents;
1936 if (fdmap[x].chan >= 0) { /* this is a channel */
1937 winner = c[fdmap[x].chan]; /* override previous winners */
1939 ast_set_flag(winner, AST_FLAG_EXCEPTION);
1941 ast_clear_flag(winner, AST_FLAG_EXCEPTION);
1942 winner->fdno = fdmap[x].fdno;
1943 } else { /* this is an fd */
1945 *outfd = pfds[x].fd;
1947 *exception = (res & POLLPRI) ? -1 : 0;
1952 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
1959 struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
1961 return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
1964 int ast_waitfor(struct ast_channel *c, int ms)
1966 int oldms = ms; /* -1 if no timeout */
1968 ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
1969 if ((ms < 0) && (oldms < 0))
1974 /* XXX never to be called with ms = -1 */
1975 int ast_waitfordigit(struct ast_channel *c, int ms)
1977 return ast_waitfordigit_full(c, ms, -1, -1);
1980 int ast_settimeout(struct ast_channel *c, int samples, int (*func)(void *data), void *data)
1984 if (c->timingfd > -1) {
1990 ast_log(LOG_DEBUG, "Scheduling timer at %d sample intervals\n", samples);
1991 res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
1992 c->timingfunc = func;
1993 c->timingdata = data;
1999 int ast_waitfordigit_full(struct ast_channel *c, int ms, int audiofd, int cmdfd)
2002 /* Stop if we're a zombie or need a soft hangup */
2003 if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
2005 /* Wait for a digit, no more than ms milliseconds total. */
2007 struct ast_channel *rchan;
2011 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
2012 if (!rchan && outfd < 0 && ms) {
2013 if (errno == 0 || errno == EINTR)
2015 ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
2017 } else if (outfd > -1) {
2018 /* The FD we were watching has something waiting */
2022 struct ast_frame *f = ast_read(c);
2026 switch (f->frametype) {
2027 case AST_FRAME_DTMF:
2031 case AST_FRAME_CONTROL:
2032 switch (f->subclass) {
2033 case AST_CONTROL_HANGUP:
2036 case AST_CONTROL_RINGING:
2037 case AST_CONTROL_ANSWER:
2041 ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
2045 case AST_FRAME_VOICE:
2046 /* Write audio if appropriate */
2048 write(audiofd, f->data, f->datalen);
2056 return 0; /* Time is up */
2059 static void send_dtmf_event(const struct ast_channel *chan, const char *direction, const char digit, const char *begin, const char *end)
2061 manager_event(EVENT_FLAG_DTMF,
2069 chan->name, chan->uniqueid, digit, direction, begin, end);
2072 static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio)
2074 struct ast_frame *f = NULL; /* the return value */
2078 /* this function is very long so make sure there is only one return
2079 * point at the end (there is only one exception to this).
2081 ast_channel_lock(chan);
2083 if (ast_do_masquerade(chan))
2084 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2086 f = &ast_null_frame;
2090 /* Stop if we're a zombie or need a soft hangup */
2091 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2092 if (chan->generator)
2093 ast_deactivate_generator(chan);
2096 prestate = chan->_state;
2098 if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF | AST_FLAG_IN_DTMF) &&
2099 !ast_strlen_zero(chan->dtmfq) &&
2100 (ast_tvzero(chan->dtmf_tv) || ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) > AST_MIN_DTMF_GAP) ) {
2101 /* We have DTMF that has been deferred. Return it now */
2102 chan->dtmff.subclass = chan->dtmfq[0];
2103 /* Drop first digit from the buffer */
2104 memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
2106 if (ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY))
2107 chan->dtmff.frametype = AST_FRAME_DTMF_END;
2109 chan->dtmff.frametype = AST_FRAME_DTMF_BEGIN;
2110 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2111 chan->emulate_dtmf_digit = f->subclass;
2112 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2114 chan->dtmf_tv = ast_tvnow();
2118 /* Read and ignore anything on the alertpipe, but read only
2119 one sizeof(blah) per frame that we send from it */
2120 if (chan->alertpipe[0] > -1)
2121 read(chan->alertpipe[0], &blah, sizeof(blah));
2124 if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2127 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2129 /* IF we can't get event, assume it's an expired as-per the old interface */
2130 res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
2132 blah = ZT_EVENT_TIMER_EXPIRED;
2134 if (blah == ZT_EVENT_TIMER_PING) {
2135 if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
2136 /* Acknowledge PONG unless we need it again */
2137 if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
2138 ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
2141 } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
2142 ioctl(chan->timingfd, ZT_TIMERACK, &blah);
2143 if (chan->timingfunc) {
2144 /* save a copy of func/data before unlocking the channel */
2145 int (*func)(void *) = chan->timingfunc;
2146 void *data = chan->timingdata;
2147 ast_channel_unlock(chan);
2151 ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
2152 chan->timingdata = NULL;
2153 ast_channel_unlock(chan);
2155 /* cannot 'goto done' because the channel is already unlocked */
2156 return &ast_null_frame;
2158 ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
2161 if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) {
2162 /* if the AST_GENERATOR_FD is set, call the generator with args
2163 * set to -1 so it can do whatever it needs to.
2165 void *tmp = chan->generatordata;
2166 chan->generatordata = NULL; /* reset to let ast_write get through */
2167 chan->generator->generate(chan, tmp, -1, -1);
2168 chan->generatordata = tmp;
2169 f = &ast_null_frame;
2173 /* Check for pending read queue */
2174 if (!AST_LIST_EMPTY(&chan->readq)) {
2175 f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
2176 /* Interpret hangup and return NULL */
2177 /* XXX why not the same for frames from the channel ? */
2178 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
2183 chan->blocker = pthread_self();
2184 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
2185 if (chan->tech->exception)
2186 f = chan->tech->exception(chan);
2188 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
2189 f = &ast_null_frame;
2191 /* Clear the exception flag */
2192 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2193 } else if (chan->tech->read)
2194 f = chan->tech->read(chan);
2196 ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
2200 /* if the channel driver returned more than one frame, stuff the excess
2201 into the readq for the next ast_read call (note that we can safely assume
2202 that the readq is empty, because otherwise we would not have called into
2203 the channel driver and f would be only a single frame)
2205 if (AST_LIST_NEXT(f, frame_list)) {
2206 AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
2207 AST_LIST_NEXT(f, frame_list) = NULL;
2210 switch (f->frametype) {
2211 case AST_FRAME_CONTROL:
2212 if (f->subclass == AST_CONTROL_ANSWER) {
2213 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) {
2215 ast_log(LOG_DEBUG, "Ignoring answer on an inbound call!\n");
2217 f = &ast_null_frame;
2218 } else if (prestate == AST_STATE_UP) {
2220 ast_log(LOG_DEBUG, "Dropping duplicate answer!\n");
2222 f = &ast_null_frame;
2224 /* Answer the CDR */
2225 ast_setstate(chan, AST_STATE_UP);
2226 if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
2227 to keep from throwing off the basic order of the universe,
2228 we will try to keep this cdr from getting posted. */
2229 chan->cdr = ast_cdr_alloc();
2230 ast_cdr_init(chan->cdr, chan);
2231 ast_cdr_start(chan->cdr);
2234 ast_cdr_answer(chan->cdr);
2238 case AST_FRAME_DTMF_END:
2239 send_dtmf_event(chan, "Received", f->subclass, "No", "Yes");
2240 ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass, chan->name, f->len);
2241 /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2242 * However, only let emulation be forced if the other end cares about BEGIN frames */
2243 if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF) ||
2244 (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) ) {
2245 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2)
2246 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2248 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2250 f = &ast_null_frame;
2251 } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) {
2252 if (!ast_tvzero(chan->dtmf_tv) &&
2253 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) {
2254 /* If it hasn't been long enough, defer this digit */
2255 if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2)
2256 chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
2258 ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
2260 f = &ast_null_frame;
2262 /* There was no begin, turn this into a begin and send the end later */
2263 f->frametype = AST_FRAME_DTMF_BEGIN;
2264 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2265 chan->emulate_dtmf_digit = f->subclass;
2266 chan->dtmf_tv = ast_tvnow();
2268 if (f->len > AST_MIN_DTMF_DURATION)
2269 chan->emulate_dtmf_duration = f->len;
2271 chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION;
2273 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION;
2276 struct timeval now = ast_tvnow();
2277 ast_clear_flag(chan, AST_FLAG_IN_DTMF);
2279 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2280 if (f->len < AST_MIN_DTMF_DURATION) {
2281 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF);
2282 chan->emulate_dtmf_digit = f->subclass;
2283 chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len;
2284 f = &ast_null_frame;
2286 chan->dtmf_tv = now;
2289 case AST_FRAME_DTMF_BEGIN:
2290 send_dtmf_event(chan, "Received", f->subclass, "Yes", "No");
2291 ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass, chan->name);
2292 if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY) ||
2293 (!ast_tvzero(chan->dtmf_tv) &&
2294 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) {
2296 f = &ast_null_frame;
2298 ast_set_flag(chan, AST_FLAG_IN_DTMF);
2299 chan->dtmf_tv = ast_tvnow();
2302 case AST_FRAME_NULL:
2303 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2304 struct timeval now = ast_tvnow();
2305 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2306 chan->emulate_dtmf_duration = 0;
2309 f->frametype = AST_FRAME_DTMF_END;
2310 f->subclass = chan->emulate_dtmf_digit;
2311 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2312 chan->dtmf_tv = now;
2313 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2314 chan->emulate_dtmf_digit = 0;
2318 case AST_FRAME_VOICE:
2319 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2320 * is reached , because we want to make sure we pass at least one
2321 * voice frame through before starting the next digit, to ensure a gap
2322 * between DTMF digits. */
2323 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) {
2324 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF);
2325 chan->emulate_dtmf_digit = 0;
2328 if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) {
2330 f = &ast_null_frame;
2331 } else if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) {
2332 struct timeval now = ast_tvnow();
2333 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) {
2334 chan->emulate_dtmf_duration = 0;
2337 f->frametype = AST_FRAME_DTMF_END;
2338 f->subclass = chan->emulate_dtmf_digit;
2339 f->len = ast_tvdiff_ms(now, chan->dtmf_tv);
2340 chan->dtmf_tv = now;
2342 /* Drop voice frames while we're still in the middle of the digit */
2344 f = &ast_null_frame;
2346 } else if (!(f->subclass & chan->nativeformats)) {
2347 /* This frame can't be from the current native formats -- drop it on the
2349 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2350 chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
2352 f = &ast_null_frame;
2355 queue_frame_to_spies(chan, f, SPY_READ);
2357 if (chan->monitor && chan->monitor->read_stream ) {
2358 /* XXX what does this do ? */
2359 #ifndef MONITOR_CONSTANT_DELAY
2360 int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
2362 jump = chan->outsmpl - chan->insmpl;
2363 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1)
2364 ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2365 chan->insmpl += jump + f->samples;
2367 chan->insmpl+= f->samples;
2369 int jump = chan->outsmpl - chan->insmpl;
2370 if (jump - MONITOR_DELAY >= 0) {
2371 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2372 ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2373 chan->insmpl += jump;
2375 chan->insmpl += f->samples;
2377 if (chan->monitor->state == AST_MONITOR_RUNNING) {
2378 if (ast_writestream(chan->monitor->read_stream, f) < 0)
2379 ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
2383 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL)
2384 f = &ast_null_frame;
2386 /* Run generator sitting on the line if timing device not available
2387 * and synchronous generation of outgoing frames is necessary */
2388 if (chan->generatordata && !ast_internal_timing_enabled(chan)) {
2389 void *tmp = chan->generatordata;
2392 if (chan->timingfunc) {
2393 if (option_debug > 1)
2394 ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n");
2395 ast_settimeout(chan, 0, NULL, NULL);
2398 chan->generatordata = NULL; /* reset, to let writes go through */
2399 res = chan->generator->generate(chan, tmp, f->datalen, f->samples);
2400 chan->generatordata = tmp;
2402 if (option_debug > 1)
2403 ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
2404 ast_deactivate_generator(chan);
2407 } else if (f->frametype == AST_FRAME_CNG) {
2408 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
2409 if (option_debug > 1)
2410 ast_log(LOG_DEBUG, "Generator got CNG, switching to timed mode\n");
2411 ast_settimeout(chan, 160, generator_force, chan);
2416 /* Just pass it on! */
2420 /* Make sure we always return NULL in the future */
2421 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2422 if (chan->generator)
2423 ast_deactivate_generator(chan);
2424 /* End the CDR if appropriate */
2426 ast_cdr_end(chan->cdr);
2429 /* High bit prints debugging */
2430 if (chan->fin & DEBUGCHAN_FLAG)
2431 ast_frame_dump(chan->name, f, "<<");
2432 chan->fin = FRAMECOUNT_INC(chan->fin);
2435 if (chan->music_state && chan->generator && chan->generator->digit && f && f->frametype == AST_FRAME_DTMF_END)
2436 chan->generator->digit(chan, f->subclass);
2438 ast_channel_unlock(chan);
2442 int ast_internal_timing_enabled(struct ast_channel *chan)
2444 int ret = ast_opt_internal_timing && chan->timingfd > -1;
2445 if (option_debug > 4)
2446 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);
2450 struct ast_frame *ast_read(struct ast_channel *chan)
2452 return __ast_read(chan, 0);
2455 struct ast_frame *ast_read_noaudio(struct ast_channel *chan)
2457 return __ast_read(chan, 1);
2460 int ast_indicate(struct ast_channel *chan, int condition)
2462 return ast_indicate_data(chan, condition, NULL, 0);
2465 int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
2469 ast_channel_lock(chan);
2470 /* Stop if we're a zombie or need a soft hangup */
2471 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
2472 ast_channel_unlock(chan);
2475 if (chan->tech->indicate)
2476 res = chan->tech->indicate(chan, condition, data, datalen);
2477 ast_channel_unlock(chan);
2478 if (!chan->tech->indicate || res) {
2480 * Device does not support (that) indication, lets fake
2481 * it by doing our own tone generation. (PM2002)
2484 ast_playtones_stop(chan);
2486 const struct ind_tone_zone_sound *ts = NULL;
2487 switch (condition) {
2488 case AST_CONTROL_RINGING:
2489 ts = ast_get_indication_tone(chan->zone, "ring");
2491 case AST_CONTROL_BUSY:
2492 ts = ast_get_indication_tone(chan->zone, "busy");
2494 case AST_CONTROL_CONGESTION:
2495 ts = ast_get_indication_tone(chan->zone, "congestion");
2498 if (ts && ts->data[0]) {
2500 ast_log(LOG_DEBUG, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
2501 ast_playtones_start(chan,0,ts->data, 1);
2503 } else if (condition == AST_CONTROL_PROGRESS) {
2504 /* ast_playtones_stop(chan); */
2505 } else if (condition == AST_CONTROL_PROCEEDING) {
2506 /* Do nothing, really */
2507 } else if (condition == AST_CONTROL_HOLD) {
2508 /* Do nothing.... */
2509 } else if (condition == AST_CONTROL_UNHOLD) {
2510 /* Do nothing.... */
2511 } else if (condition == AST_CONTROL_VIDUPDATE) {
2512 /* Do nothing.... */
2515 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
2523 int ast_recvchar(struct ast_channel *chan, int timeout)
2526 char *buf = ast_recvtext(chan, timeout);
2528 return -1; /* error or timeout */
2529 c = *(unsigned char *)buf;
2534 char *ast_recvtext(struct ast_channel *chan, int timeout)
2540 struct ast_frame *f;
2541 if (ast_check_hangup(chan))
2543 res = ast_waitfor(chan, timeout);
2544 if (res <= 0) /* timeout or error */
2546 timeout = res; /* update timeout */
2549 break; /* no frame */
2550 if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
2551 done = 1; /* force a break */
2552 else if (f->frametype == AST_FRAME_TEXT) { /* what we want */
2553 buf = ast_strndup((char *) f->data, f->datalen); /* dup and break */
2561 int ast_sendtext(struct ast_channel *chan, const char *text)
2564 /* Stop if we're a zombie or need a soft hangup */
2565 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2567 CHECK_BLOCKING(chan);
2568 if (chan->tech->send_text)
2569 res = chan->tech->send_text(chan, text);
2570 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2574 int ast_senddigit_begin(struct ast_channel *chan, char digit)
2576 /* Device does not support DTMF tones, lets fake
2577 * it by doing our own generation. */
2578 static const char* dtmf_tones[] = {
2597 if (!chan->tech->send_digit_begin)
2600 if (!chan->tech->send_digit_begin(chan, digit))
2603 if (digit >= '0' && digit <='9')
2604 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
2605 else if (digit >= 'A' && digit <= 'D')
2606 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
2607 else if (digit == '*')
2608 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
2609 else if (digit == '#')
2610 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
2614 ast_log(LOG_DEBUG, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
2620 int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
2624 if (chan->tech->send_digit_end)
2625 res = chan->tech->send_digit_end(chan, digit, duration);
2627 if (res && chan->generator)
2628 ast_playtones_stop(chan);
2633 int ast_senddigit(struct ast_channel *chan, char digit)
2635 if (chan->tech->send_digit_begin) {
2636 ast_senddigit_begin(chan, digit);
2637 ast_safe_sleep(chan, 100); /* XXX 100ms ... probably should be configurable */
2640 return ast_senddigit_end(chan, digit, 100);
2643 int ast_prod(struct ast_channel *chan)
2645 struct ast_frame a = { AST_FRAME_VOICE };
2648 /* Send an empty audio frame to get things moving */
2649 if (chan->_state != AST_STATE_UP) {
2651 ast_log(LOG_DEBUG, "Prodding channel '%s'\n", chan->name);
2652 a.subclass = chan->rawwriteformat;
2653 a.data = nothing + AST_FRIENDLY_OFFSET;
2655 if (ast_write(chan, &a))
2656 ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
2661 int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
2664 if (!chan->tech->write_video)
2666 res = ast_write(chan, fr);
2672 int ast_write(struct ast_channel *chan, struct ast_frame *fr)
2675 struct ast_frame *f = NULL;
2677 /* Stop if we're a zombie or need a soft hangup */
2678 ast_channel_lock(chan);
2679 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
2682 /* Handle any pending masquerades */
2683 if (chan->masq && ast_do_masquerade(chan)) {
2684 ast_log(LOG_WARNING, "Failed to perform masquerade\n");
2688 res = 0; /* XXX explain, why 0 ? */
2691 if (chan->generatordata) {
2692 if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
2693 ast_deactivate_generator(chan);
2695 if (fr->frametype == AST_FRAME_DTMF_END) {
2696 /* There is a generator running while we're in the middle of a digit.
2697 * It's probably inband DTMF, so go ahead and pass it so it can
2698 * stop the generator */
2699 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2700 ast_channel_unlock(chan);
2701 res = ast_senddigit_end(chan, fr->subclass, fr->len);
2702 ast_channel_lock(chan);
2703 CHECK_BLOCKING(chan);
2704 } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
2705 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
2706 res = (chan->tech->indicate == NULL) ? 0 :
2707 chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2709 res = 0; /* XXX explain, why 0 ? */
2713 /* High bit prints debugging */
2714 if (chan->fout & DEBUGCHAN_FLAG)
2715 ast_frame_dump(chan->name, fr, ">>");
2716 CHECK_BLOCKING(chan);
2717 switch (fr->frametype) {
2718 case AST_FRAME_CONTROL:
2719 res = (chan->tech->indicate == NULL) ? 0 :
2720 chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
2722 case AST_FRAME_DTMF_BEGIN:
2723 send_dtmf_event(chan, "Sent", fr->subclass, "Yes", "No");
2724 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2725 ast_channel_unlock(chan);
2726 res = ast_senddigit_begin(chan, fr->subclass);
2727 ast_channel_lock(chan);
2728 CHECK_BLOCKING(chan);
2730 case AST_FRAME_DTMF_END:
2731 send_dtmf_event(chan, "Sent", fr->subclass, "No", "Yes");
2732 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2733 ast_channel_unlock(chan);
2734 res = ast_senddigit_end(chan, fr->subclass, fr->len);
2735 ast_channel_lock(chan);
2736 CHECK_BLOCKING(chan);
2738 case AST_FRAME_TEXT:
2739 if (fr->subclass == AST_FORMAT_T140) {
2740 res = (chan->tech->write_text == NULL) ? 0 :
2741 chan->tech->write_text(chan, fr);
2743 res = (chan->tech->send_text == NULL) ? 0 :
2744 chan->tech->send_text(chan, (char *) fr->data);
2747 case AST_FRAME_HTML:
2748 res = (chan->tech->send_html == NULL) ? 0 :
2749 chan->tech->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen);
2751 case AST_FRAME_VIDEO:
2752 /* XXX Handle translation of video codecs one day XXX */
2753 res = (chan->tech->write_video == NULL) ? 0 :
2754 chan->tech->write_video(chan, fr);
2756 case AST_FRAME_MODEM:
2757 res = (chan->tech->write == NULL) ? 0 :
2758 chan->tech->write(chan, fr);
2760 case AST_FRAME_VOICE:
2761 if (chan->tech->write == NULL)
2762 break; /*! \todo XXX should return 0 maybe ? */
2764 /* If someone is whispering on this channel then we must ensure that we are always getting signed linear frames */
2765 if (ast_test_flag(chan, AST_FLAG_WHISPER)) {
2766 if (fr->subclass == AST_FORMAT_SLINEAR)
2769 ast_mutex_lock(&chan->whisper->lock);
2770 if (chan->writeformat != AST_FORMAT_SLINEAR) {
2771 /* Rebuild the translation path and set our write format back to signed linear */
2772 chan->whisper->original_format = chan->writeformat;
2773 ast_set_write_format(chan, AST_FORMAT_SLINEAR);
2774 if (chan->whisper->path)
2775 ast_translator_free_path(chan->whisper->path);
2776 chan->whisper->path = ast_translator_build_path(AST_FORMAT_SLINEAR, chan->whisper->original_format);
2778 /* Translate frame using the above translation path */
2779 f = (chan->whisper->path) ? ast_translate(chan->whisper->path, fr, 0) : fr;
2780 ast_mutex_unlock(&chan->whisper->lock);
2783 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
2784 if (fr->subclass == chan->rawwriteformat)
2787 f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
2790 /* If we have no frame of audio, then we have to bail out */
2796 /* If spies are on the channel then queue the frame out to them */
2798 queue_frame_to_spies(chan, f, SPY_WRITE);
2800 /* If Monitor is running on this channel, then we have to write frames out there too */
2801 if (chan->monitor && chan->monitor->write_stream) {
2802 /* XXX must explain this code */
2803 #ifndef MONITOR_CONSTANT_DELAY
2804 int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
2806 jump = chan->insmpl - chan->outsmpl;
2807 if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
2808 ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2809 chan->outsmpl += jump + f->samples;
2811 chan->outsmpl += f->samples;
2813 int jump = chan->insmpl - chan->outsmpl;
2814 if (jump - MONITOR_DELAY >= 0) {
2815 if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1)
2816 ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2817 chan->outsmpl += jump;
2819 chan->outsmpl += f->samples;
2821 if (chan->monitor->state == AST_MONITOR_RUNNING) {
2822 if (ast_writestream(chan->monitor->write_stream, f) < 0)
2823 ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
2827 /* Finally the good part! Write this out to the channel */
2828 if (ast_test_flag(chan, AST_FLAG_WHISPER)) {
2829 /* frame is assumed to be in SLINEAR, since that is
2830 required for whisper mode */
2831 ast_frame_adjust_volume(f, -2);
2832 if (ast_slinfactory_available(&chan->whisper->sf) >= f->samples) {
2833 short buf[f->samples];
2834 struct ast_frame whisper = {
2835 .frametype = AST_FRAME_VOICE,
2836 .subclass = AST_FORMAT_SLINEAR,
2838 .datalen = sizeof(buf),
2839 .samples = f->samples,
2842 ast_mutex_lock(&chan->whisper->lock);
2843 if (ast_slinfactory_read(&chan->whisper->sf, buf, f->samples))
2844 ast_frame_slinear_sum(f, &whisper);
2845 ast_mutex_unlock(&chan->whisper->lock);
2847 /* and now put it through the regular translator */
2848 f = (chan->writetrans) ? ast_translate(chan->writetrans, f, 0) : f;
2850 res = f ? chan->tech->write(chan, f) : 0;
2852 case AST_FRAME_NULL:
2858 /* At this point, fr is the incoming frame and f is NULL. Channels do
2859 * not expect to get NULL as a frame pointer and will segfault. Hence,
2860 * we output the original frame passed in. */
2861 res = chan->tech->write(chan, fr);
2867 ast_clear_flag(chan, AST_FLAG_BLOCKING);
2868 /* Consider a write failure to force a soft hangup */
2870 chan->_softhangup |= AST_SOFTHANGUP_DEV;
2872 chan->fout = FRAMECOUNT_INC(chan->fout);
2875 ast_channel_unlock(chan);
2879 static int set_format(struct ast_channel *chan, int fmt, int *rawformat, int *format,
2880 struct ast_trans_pvt **trans, const int direction)
2885 /* Make sure we only consider audio */
2886 fmt &= AST_FORMAT_AUDIO_MASK;
2888 native = chan->nativeformats;
2889 /* Find a translation path from the native format to one of the desired formats */
2892 res = ast_translator_best_choice(&fmt, &native);
2895 res = ast_translator_best_choice(&native, &fmt);
2898 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
2899 ast_getformatname(native), ast_getformatname(fmt));
2903 /* Now we have a good choice for both. */
2904 ast_channel_lock(chan);
2906 if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
2907 /* the channel is already in these formats, so nothing to do */
2908 ast_channel_unlock(chan);
2912 *rawformat = native;
2913 /* User perspective is fmt */
2915 /* Free any read translation we have right now */
2917 ast_translator_free_path(*trans);
2918 /* Build a translation path from the raw format to the desired format */
2921 *trans = ast_translator_build_path(*format, *rawformat);
2924 *trans = ast_translator_build_path(*rawformat, *format);
2925 ast_channel_unlock(chan);
2927 ast_log(LOG_DEBUG, "Set channel %s to %s format %s\n", chan->name,
2928 direction ? "write" : "read", ast_getformatname(fmt));
2932 int ast_set_read_format(struct ast_channel *chan, int fmt)
2934 return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
2935 &chan->readtrans, 0);
2938 int ast_set_write_format(struct ast_channel *chan, int fmt)
2940 return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
2941 &chan->writetrans, 1);
2944 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)
2948 struct ast_channel *chan;
2954 outstate = &dummy_outstate; /* make outstate always a valid pointer */
2956 chan = ast_request(type, format, data, &cause);
2958 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
2959 /* compute error and return */
2960 if (cause == AST_CAUSE_BUSY)
2961 *outstate = AST_CONTROL_BUSY;
2962 else if (cause == AST_CAUSE_CONGESTION)
2963 *outstate = AST_CONTROL_CONGESTION;
2969 ast_set_variables(chan, oh->vars);
2970 /* XXX why is this necessary, for the parent_channel perhaps ? */
2971 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
2972 ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
2973 if (oh->parent_channel) {
2974 ast_channel_inherit_variables(oh->parent_channel, chan);
2975 ast_channel_datastore_inherit(oh->parent_channel, chan);
2978 ast_cdr_setaccount(chan, oh->account);
2980 ast_set_callerid(chan, cid_num, cid_name, cid_num);
2984 if (!chan->cdr) { /* up till now, this insertion hasn't been done. Therefore,
2985 to keep from throwing off the basic order of the universe,
2986 we will try to keep this cdr from getting posted. */
2987 chan->cdr = ast_cdr_alloc();
2988 ast_cdr_init(chan->cdr, chan);
2989 ast_cdr_start(chan->cdr);
2991 if (ast_call(chan, data, 0)) { /* ast_call failed... */
2992 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
2994 res = 1; /* mark success in case chan->_state is already AST_STATE_UP */
2995 while (timeout && chan->_state != AST_STATE_UP) {
2996 struct ast_frame *f;
2997 res = ast_waitfor(chan, timeout);
2998 if (res <= 0) /* error, timeout, or done */
3004 *outstate = AST_CONTROL_HANGUP;
3008 if (f->frametype == AST_FRAME_CONTROL) {
3009 switch (f->subclass) {
3010 case AST_CONTROL_RINGING: /* record but keep going */
3011 *outstate = f->subclass;
3014 case AST_CONTROL_BUSY:
3015 case AST_CONTROL_CONGESTION:
3016 case AST_CONTROL_ANSWER:
3017 *outstate = f->subclass;
3018 timeout = 0; /* trick to force exit from the while() */
3022 case AST_CONTROL_PROGRESS:
3023 case AST_CONTROL_PROCEEDING:
3024 case AST_CONTROL_HOLD:
3025 case AST_CONTROL_UNHOLD:
3026 case AST_CONTROL_VIDUPDATE:
3027 case -1: /* Ignore -- just stopping indications */
3031 ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
3040 if (!ast_strlen_zero(oh->context))
3041 ast_copy_string(chan->context, oh->context, sizeof(chan->context));