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 #if defined(HAVE_ZAPTEL) || defined (HAVE_DAHDI)
41 #include <sys/ioctl.h>
42 #include "asterisk/dahdi_compat.h"
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 */
75 #define MONITOR_CONSTANT_DELAY
76 #define MONITOR_DELAY 150 * 8 /* 150 ms of MONITORING DELAY */
79 /*! Prevent new channel allocation if shutting down. */
80 static int shutting_down
;
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
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
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
{
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)
167 struct ast_variable
*var
=NULL
, *prev
= NULL
;
168 AST_LIST_TRAVERSE(&backends
, cl
, list
) {
170 if ((prev
->next
= ast_variable_new(cl
->tech
->type
, cl
->tech
->description
)))
173 var
= ast_variable_new(cl
->tech
->type
, cl
->tech
->description
);
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"
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");
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");
199 AST_LIST_UNLOCK(&channels
);
200 ast_cli(fd
, "----------\n%d channel drivers registered.\n", count_chan
);
201 return RESULT_SUCCESS
;
207 static int show_channeltype_deprecated(int fd
, int argc
, char *argv
[])
209 struct chanlist
*cl
= NULL
;
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
))) {
227 ast_cli(fd
, "\n%s is not a registered channel driver.\n", argv
[2]);
228 AST_LIST_UNLOCK(&channels
);
229 return RESULT_FAILURE
;
233 "-- Info about channel driver: %s --\n"
234 " Device State: %s\n"
237 " Capabilities: %d\n"
241 " Image Support: %s\n"
242 " Text Support: %s\n",
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
;
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
))) {
280 ast_cli(fd
, "\n%s is not a registered channel driver.\n", argv
[3]);
281 AST_LIST_UNLOCK(&channels
);
282 return RESULT_FAILURE
;
286 "-- Info about channel driver: %s --\n"
287 " Device State: %s\n"
290 " Capabilities: %d\n"
294 " Image Support: %s\n"
295 " Text Support: %s\n",
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
)
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
);
335 static char *complete_channeltypes(const char *line
, const char *word
, int pos
, int state
)
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
);
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
,
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 */
390 if (!chan
->tech_pvt
) /* yes if no technology private data */
392 if (!chan
->whentohangup
) /* no if no hangup scheduled */
394 if (chan
->whentohangup
> time(NULL
)) /* no if hangup time has not come yet. */
396 chan
->_softhangup
|= AST_SOFTHANGUP_TIMEOUT
; /* record event */
400 static int ast_check_hangup_locked(struct ast_channel
*chan
)
403 ast_channel_lock(chan
);
404 res
= ast_check_hangup(chan
);
405 ast_channel_unlock(chan
);
409 /*! \brief printf the string into a correctly sized mallocd buffer, and return the buffer */
410 char *ast_safe_string_alloc(const char *fmt
, ...)
417 len
= vsnprintf(buf
, 1, fmt
, args
);
420 if (!(b2
= ast_malloc(len
+ 1)))
424 vsnprintf(b2
, len
+ 1, fmt
, args
);
430 /*! \brief Initiate system shutdown */
431 void ast_begin_shutdown(int hangup
)
433 struct ast_channel
*c
;
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
;
448 AST_LIST_LOCK(&channels
);
449 AST_LIST_TRAVERSE(&channels
, c
, chan_list
)
451 AST_LIST_UNLOCK(&channels
);
455 /*! \brief Cancel a shutdown in progress */
456 void ast_cancel_shutdown(void)
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
);
475 /*! \brief Compare a offset with when to hangup channel */
476 int ast_channel_cmpwhentohangup(struct ast_channel
*chan
, time_t offset
)
480 if (chan
->whentohangup
== 0) {
481 return (offset
== 0) ? 0 : -1;
483 if (offset
== 0) /* XXX why is this special ? */
486 whentohangup
= offset
+ time (NULL
);
487 if (chan
->whentohangup
< whentohangup
)
489 else if (chan
->whentohangup
== whentohangup
)
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
);
512 if (!(chan
= ast_calloc(1, sizeof(*chan
)))) {
513 AST_LIST_UNLOCK(&channels
);
517 AST_LIST_INSERT_HEAD(&backends
, chan
, list
);
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
);
530 void ast_channel_unregister(const struct ast_channel_tech
*tech
)
532 struct chanlist
*chan
;
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
);
543 if (option_verbose
> 1)
544 ast_verbose(VERBOSE_PREFIX_2
"Unregistered channel type '%s'\n", tech
->type
);
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");
563 AST_LIST_TRAVERSE(&backends
, chanls
, list
) {
564 if (!strcasecmp(name
, chanls
->tech
->type
)) {
570 AST_LIST_UNLOCK(&channels
);
575 /*! \brief Gives the string form of a given hangup cause */
576 const char *ast_cause2str(int cause
)
580 for (x
=0; x
< sizeof(causes
) / sizeof(causes
[0]); x
++) {
581 if (causes
[x
].cause
== cause
)
582 return causes
[x
].desc
;
588 /*! \brief Convert a symbolic hangup cause to number */
589 int ast_str2cause(const char *name
)
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
;
600 /*! \brief Gives the string form of a given channel state */
601 char *ast_state2str(enum ast_channel_state state
)
608 case AST_STATE_RESERVED
:
610 case AST_STATE_OFFHOOK
:
612 case AST_STATE_DIALING
:
616 case AST_STATE_RINGING
:
622 case AST_STATE_DIALING_OFFHOOK
:
623 return "Dialing Offhook";
624 case AST_STATE_PRERING
:
627 if (!(buf
= ast_threadstorage_get(&state2str_threadbuf
, STATE2STR_BUFSIZE
)))
629 snprintf(buf
, STATE2STR_BUFSIZE
, "Unknown (%d)", state
);
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
:
640 case AST_TRANS_CAP_DIGITAL
:
642 case AST_TRANS_CAP_RESTRICTED_DIGITAL
:
643 return "RESTRICTED_DIGITAL";
644 case AST_TRANS_CAP_3_1K_AUDIO
:
646 case AST_TRANS_CAP_DIGITAL_W_TONES
:
647 return "DIGITAL_W_TONES";
648 case AST_TRANS_CAP_VIDEO
:
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 */
663 /*! Okay, ulaw is used by all telephony equipment, so start with it */
665 /*! Unless of course, you're a silly European, so then prefer ALAW */
667 /*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */
669 /*! Okay, well, signed linear is easy to translate into other stuff */
671 /*! G.726 is standard ADPCM, in RFC3551 packing order */
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 */
677 /*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
678 translate and sounds pretty good */
680 /*! iLBC is not too bad */
682 /*! Speex is free, but computationally more expensive than GSM */
684 /*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
687 /*! G.729a is faster than 723 and slightly less expensive */
689 /*! Down to G.723.1 which is proprietary but at least designed for voice */
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
++)
700 ast_log(LOG_WARNING
, "Don't know any of 0x%x formats\n", fmts
);
704 static const struct ast_channel_tech null_tech
= {
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
;
715 struct varshead
*headp
;
718 /* If shutting down, don't allocate any new channels */
720 ast_log(LOG_WARNING
, "Channel allocation failed: Refusing due to active shutdown\n");
724 if (!(tmp
= ast_calloc(1, sizeof(*tmp
))))
727 if (!(tmp
->sched
= sched_context_create())) {
728 ast_log(LOG_WARNING
, "Channel allocation failed: Unable to create schedule context\n");
733 if ((ast_string_field_init(tmp
, 128))) {
734 sched_context_destroy(tmp
->sched
);
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,
742 for (x
= 0; x
< AST_MAX_FDS
- 2; x
++)
748 tmp
->timingfd
= open("/dev/zap/timer", O_RDWR
);
750 tmp
->timingfd
= open("/dev/dahdi/timer", O_RDWR
);
753 if (tmp
->timingfd
> -1) {
754 /* Check if timing interface supports new
757 if (!ioctl(tmp
->timingfd
, DAHDI_TIMERPONG
, &flags
))
765 if (pipe(tmp
->alertpipe
)) {
766 ast_log(LOG_WARNING
, "Channel allocation failed: Can't create alert pipe!\n");
769 if (tmp
->timingfd
> -1)
770 close(tmp
->timingfd
);
772 sched_context_destroy(tmp
->sched
);
773 ast_string_field_free_memory(tmp
);
777 flags
= fcntl(tmp
->alertpipe
[0], F_GETFL
);
778 if (fcntl(tmp
->alertpipe
[0], F_SETFL
, flags
| O_NONBLOCK
) < 0) {
779 ast_log(LOG_WARNING
, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno
, strerror(errno
));
780 close(tmp
->alertpipe
[0]);
781 close(tmp
->alertpipe
[1]);
782 goto alertpipe_failed
;
784 flags
= fcntl(tmp
->alertpipe
[1], F_GETFL
);
785 if (fcntl(tmp
->alertpipe
[1], F_SETFL
, flags
| O_NONBLOCK
) < 0) {
786 ast_log(LOG_WARNING
, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno
, strerror(errno
));
787 close(tmp
->alertpipe
[0]);
788 close(tmp
->alertpipe
[1]);
789 goto alertpipe_failed
;
792 } else /* Make sure we've got it done right if they don't */
793 tmp
->alertpipe
[0] = tmp
->alertpipe
[1] = -1;
795 /* Always watch the alertpipe */
796 tmp
->fds
[AST_ALERT_FD
] = tmp
->alertpipe
[0];
797 /* And timing pipe */
798 tmp
->fds
[AST_TIMING_FD
] = tmp
->timingfd
;
799 ast_string_field_set(tmp
, name
, "**Unknown**");
806 tmp
->fin
= global_fin
;
807 tmp
->fout
= global_fout
;
809 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME
)) {
810 ast_string_field_build(tmp
, uniqueid
, "%li.%d", (long) time(NULL
),
811 ast_atomic_fetchadd_int(&uniqueint
, 1));
813 ast_string_field_build(tmp
, uniqueid
, "%s-%li.%d", ast_config_AST_SYSTEM_NAME
,
814 (long) time(NULL
), ast_atomic_fetchadd_int(&uniqueint
, 1));
817 tmp
->cid
.cid_name
= ast_strdup(cid_name
);
818 tmp
->cid
.cid_num
= ast_strdup(cid_num
);
820 if (!ast_strlen_zero(name_fmt
)) {
821 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
822 * And they all use slightly different formats for their name string.
823 * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
824 * This means, that the stringfields must have a routine that takes the va_lists directly, and
825 * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
826 * This new function was written so this can be accomplished.
828 va_start(ap1
, name_fmt
);
829 va_start(ap2
, name_fmt
);
830 ast_string_field_build_va(tmp
, name
, name_fmt
, ap1
, ap2
);
835 /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */
837 /* These 4 variables need to be set up for the cdr_init() to work right */
839 tmp
->amaflags
= amaflag
;
841 tmp
->amaflags
= ast_default_amaflags
;
843 if (!ast_strlen_zero(acctcode
))
844 ast_string_field_set(tmp
, accountcode
, acctcode
);
846 ast_string_field_set(tmp
, accountcode
, ast_default_accountcode
);
848 if (!ast_strlen_zero(context
))
849 ast_copy_string(tmp
->context
, context
, sizeof(tmp
->context
));
851 strcpy(tmp
->context
, "default");
853 if (!ast_strlen_zero(exten
))
854 ast_copy_string(tmp
->exten
, exten
, sizeof(tmp
->exten
));
856 strcpy(tmp
->exten
, "s");
860 tmp
->cdr
= ast_cdr_alloc();
861 ast_cdr_init(tmp
->cdr
, tmp
);
862 ast_cdr_start(tmp
->cdr
);
864 headp
= &tmp
->varshead
;
865 AST_LIST_HEAD_INIT_NOLOCK(headp
);
867 ast_mutex_init(&tmp
->lock
);
869 AST_LIST_HEAD_INIT_NOLOCK(&tmp
->datastores
);
871 ast_string_field_set(tmp
, language
, defaultlanguage
);
873 tmp
->tech
= &null_tech
;
875 AST_LIST_LOCK(&channels
);
876 AST_LIST_INSERT_HEAD(&channels
, tmp
, chan_list
);
877 AST_LIST_UNLOCK(&channels
);
880 * and now, since the channel structure is built, and has its name, let's
881 * call the manager event generator with this Newchannel event. This is the
882 * proper and correct place to make this call, but you sure do have to pass
883 * a lot of data into this func to do it here!
885 if (!ast_strlen_zero(name_fmt
)) {
886 manager_event(EVENT_FLAG_CALL
, "Newchannel",
889 "CallerIDNum: %s\r\n"
890 "CallerIDName: %s\r\n"
892 tmp
->name
, ast_state2str(state
),
893 S_OR(cid_num
, "<unknown>"),
894 S_OR(cid_name
, "<unknown>"),
901 /*! \brief Queue an outgoing media frame */
902 int ast_queue_frame(struct ast_channel
*chan
, struct ast_frame
*fin
)
905 struct ast_frame
*cur
;
909 /* Build us a copy and free the original one */
910 if (!(f
= ast_frdup(fin
))) {
911 ast_log(LOG_WARNING
, "Unable to duplicate frame\n");
914 ast_channel_lock(chan
);
916 /* See if the last frame on the queue is a hangup, if so don't queue anything */
917 if ((cur
= AST_LIST_LAST(&chan
->readq
)) && (cur
->frametype
== AST_FRAME_CONTROL
) && (cur
->subclass
== AST_CONTROL_HANGUP
)) {
919 ast_channel_unlock(chan
);
923 /* Count how many frames exist on the queue */
924 AST_LIST_TRAVERSE(&chan
->readq
, cur
, frame_list
) {
928 /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
929 if (((fin
->frametype
== AST_FRAME_VOICE
) && (qlen
> 96)) || (qlen
> 128)) {
930 if (fin
->frametype
!= AST_FRAME_VOICE
) {
931 ast_log(LOG_WARNING
, "Exceptionally long queue length queuing to %s\n", chan
->name
);
932 ast_assert(fin
->frametype
== AST_FRAME_VOICE
);
935 ast_log(LOG_DEBUG
, "Dropping voice to exceptionally long queue on %s\n", chan
->name
);
937 ast_channel_unlock(chan
);
941 AST_LIST_INSERT_TAIL(&chan
->readq
, f
, frame_list
);
942 if (chan
->alertpipe
[1] > -1) {
943 if (write(chan
->alertpipe
[1], &blah
, sizeof(blah
)) != sizeof(blah
))
944 ast_log(LOG_WARNING
, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
945 chan
->name
, f
->frametype
, f
->subclass
, qlen
, strerror(errno
));
947 } else if (chan
->timingfd
> -1) {
948 ioctl(chan
->timingfd
, DAHDI_TIMERPING
, &blah
);
950 } else if (ast_test_flag(chan
, AST_FLAG_BLOCKING
)) {
951 pthread_kill(chan
->blocker
, SIGURG
);
953 ast_channel_unlock(chan
);
957 /*! \brief Queue a hangup frame for channel */
958 int ast_queue_hangup(struct ast_channel
*chan
)
960 struct ast_frame f
= { AST_FRAME_CONTROL
, AST_CONTROL_HANGUP
};
961 /* Yeah, let's not change a lock-critical value without locking */
962 if (!ast_channel_trylock(chan
)) {
963 chan
->_softhangup
|= AST_SOFTHANGUP_DEV
;
964 ast_channel_unlock(chan
);
966 return ast_queue_frame(chan
, &f
);
969 /*! \brief Queue a control frame */
970 int ast_queue_control(struct ast_channel
*chan
, enum ast_control_frame_type control
)
972 struct ast_frame f
= { AST_FRAME_CONTROL
, };
974 f
.subclass
= control
;
976 return ast_queue_frame(chan
, &f
);
979 /*! \brief Queue a control frame with payload */
980 int ast_queue_control_data(struct ast_channel
*chan
, enum ast_control_frame_type control
,
981 const void *data
, size_t datalen
)
983 struct ast_frame f
= { AST_FRAME_CONTROL
, };
985 f
.subclass
= control
;
986 f
.data
= (void *) data
;
989 return ast_queue_frame(chan
, &f
);
992 /*! \brief Set defer DTMF flag on channel */
993 int ast_channel_defer_dtmf(struct ast_channel
*chan
)
998 pre
= ast_test_flag(chan
, AST_FLAG_DEFER_DTMF
);
999 ast_set_flag(chan
, AST_FLAG_DEFER_DTMF
);
1004 /*! \brief Unset defer DTMF flag on channel */
1005 void ast_channel_undefer_dtmf(struct ast_channel
*chan
)
1008 ast_clear_flag(chan
, AST_FLAG_DEFER_DTMF
);
1012 * \brief Helper function to find channels.
1014 * It supports these modes:
1016 * prev != NULL : get channel next in list after prev
1017 * name != NULL : get channel with matching name
1018 * name != NULL && namelen != 0 : get channel whose name starts with prefix
1019 * exten != NULL : get channel whose exten or macroexten matches
1020 * context != NULL && exten != NULL : get channel whose context or macrocontext
1022 * It returns with the channel's lock held. If getting the individual lock fails,
1023 * unlock and retry quickly up to 10 times, then give up.
1025 * \note XXX Note that this code has cost O(N) because of the need to verify
1026 * that the object is still on the global list.
1028 * \note XXX also note that accessing fields (e.g. c->name in ast_log())
1029 * can only be done with the lock held or someone could delete the
1030 * object while we work on it. This causes some ugliness in the code.
1031 * Note that removing the first ast_log() may be harmful, as it would
1032 * shorten the retry period and possibly cause failures.
1033 * We should definitely go for a better scheme that is deadlock-free.
1035 static struct ast_channel
*channel_find_locked(const struct ast_channel
*prev
,
1036 const char *name
, const int namelen
,
1037 const char *context
, const char *exten
)
1039 const char *msg
= prev
? "deadlock" : "initial deadlock";
1041 struct ast_channel
*c
;
1042 const struct ast_channel
*_prev
= prev
;
1044 for (retries
= 0; retries
< 200; retries
++) {
1046 /* Reset prev on each retry. See note below for the reason. */
1048 AST_LIST_LOCK(&channels
);
1049 AST_LIST_TRAVERSE(&channels
, c
, chan_list
) {
1050 if (prev
) { /* look for last item, first, before any evaluation */
1051 if (c
!= prev
) /* not this one */
1053 /* found, prepare to return c->next */
1054 if ((c
= AST_LIST_NEXT(c
, chan_list
)) == NULL
) break;
1056 * We're done searching through the list for the previous item.
1057 * Any item after this point, we want to evaluate for a match.
1058 * If we didn't set prev to NULL here, then we would only
1059 * return matches for the first matching item (since the above
1060 * "if (c != prev)" would not permit any other potential
1061 * matches to reach the additional matching logic, below).
1062 * Instead, it would just iterate until it once again found the
1063 * original match, then iterate down to the end of the list and
1068 if (name
) { /* want match by name */
1069 if ((!namelen
&& strcasecmp(c
->name
, name
)) ||
1070 (namelen
&& strncasecmp(c
->name
, name
, namelen
)))
1071 continue; /* name match failed */
1073 if (context
&& strcasecmp(c
->context
, context
) &&
1074 strcasecmp(c
->macrocontext
, context
))
1075 continue; /* context match failed */
1076 if (strcasecmp(c
->exten
, exten
) &&
1077 strcasecmp(c
->macroexten
, exten
))
1078 continue; /* exten match failed */
1080 /* if we get here, c points to the desired record */
1083 /* exit if chan not found or mutex acquired successfully */
1084 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
1085 done
= c
== NULL
|| ast_channel_trylock(c
) == 0;
1088 ast_log(LOG_DEBUG
, "Avoiding %s for channel '%p'\n", msg
, c
);
1089 if (retries
== 199) {
1090 /* We are about to fail due to a deadlock, so report this
1091 * while we still have the list lock.
1094 ast_log(LOG_DEBUG
, "Failure, could not lock '%p' after %d retries!\n", c
, retries
);
1095 /* As we have deadlocked, we will skip this channel and
1096 * see if there is another match.
1097 * NOTE: No point doing this for a full-name match,
1098 * as there can be no more matches.
1100 if (!(name
&& !namelen
)) {
1106 AST_LIST_UNLOCK(&channels
);
1109 /* If we reach this point we basically tried to lock a channel and failed. Instead of
1110 * starting from the beginning of the list we can restore our saved pointer to the previous
1111 * channel and start from there.
1114 usleep(1); /* give other threads a chance before retrying */
1120 /*! \brief Browse channels in use */
1121 struct ast_channel
*ast_channel_walk_locked(const struct ast_channel
*prev
)
1123 return channel_find_locked(prev
, NULL
, 0, NULL
, NULL
);
1126 /*! \brief Get channel by name and lock it */
1127 struct ast_channel
*ast_get_channel_by_name_locked(const char *name
)
1129 return channel_find_locked(NULL
, name
, 0, NULL
, NULL
);
1132 /*! \brief Get channel by name prefix and lock it */
1133 struct ast_channel
*ast_get_channel_by_name_prefix_locked(const char *name
, const int namelen
)
1135 return channel_find_locked(NULL
, name
, namelen
, NULL
, NULL
);
1138 /*! \brief Get next channel by name prefix and lock it */
1139 struct ast_channel
*ast_walk_channel_by_name_prefix_locked(const struct ast_channel
*chan
, const char *name
,
1142 return channel_find_locked(chan
, name
, namelen
, NULL
, NULL
);
1145 /*! \brief Get channel by exten (and optionally context) and lock it */
1146 struct ast_channel
*ast_get_channel_by_exten_locked(const char *exten
, const char *context
)
1148 return channel_find_locked(NULL
, NULL
, 0, context
, exten
);
1151 /*! \brief Get next channel by exten (and optionally context) and lock it */
1152 struct ast_channel
*ast_walk_channel_by_exten_locked(const struct ast_channel
*chan
, const char *exten
,
1153 const char *context
)
1155 return channel_find_locked(chan
, NULL
, 0, context
, exten
);
1158 /*! \brief Wait, look for hangups and condition arg */
1159 int ast_safe_sleep_conditional(struct ast_channel
*chan
, int ms
, int (*cond
)(void*), void *data
)
1161 struct ast_frame
*f
;
1164 if (cond
&& ((*cond
)(data
) == 0))
1166 ms
= ast_waitfor(chan
, ms
);
1179 /*! \brief Wait, look for hangups */
1180 int ast_safe_sleep(struct ast_channel
*chan
, int ms
)
1182 return ast_safe_sleep_conditional(chan
, ms
, NULL
, NULL
);
1185 static void free_cid(struct ast_callerid
*cid
)
1188 free(cid
->cid_dnid
);
1192 free(cid
->cid_name
);
1196 free(cid
->cid_rdnis
);
1199 /*! \brief Free a channel structure */
1200 void ast_channel_free(struct ast_channel
*chan
)
1203 struct ast_var_t
*vardata
;
1204 struct ast_frame
*f
;
1205 struct varshead
*headp
;
1206 struct ast_datastore
*datastore
= NULL
;
1207 char name
[AST_CHANNEL_NAME
], *dashptr
;
1209 headp
=&chan
->varshead
;
1211 AST_LIST_LOCK(&channels
);
1212 if (!AST_LIST_REMOVE(&channels
, chan
, chan_list
)) {
1213 AST_LIST_UNLOCK(&channels
);
1214 ast_log(LOG_ERROR
, "Unable to find channel in list to free. Assuming it has already been done.\n");
1216 /* Lock and unlock the channel just to be sure nobody has it locked still
1217 due to a reference retrieved from the channel list. */
1218 ast_channel_lock(chan
);
1219 ast_channel_unlock(chan
);
1221 /* Get rid of each of the data stores on the channel */
1222 while ((datastore
= AST_LIST_REMOVE_HEAD(&chan
->datastores
, entry
)))
1223 /* Free the data store */
1224 ast_channel_datastore_free(datastore
);
1226 /* Lock and unlock the channel just to be sure nobody has it locked still
1227 due to a reference that was stored in a datastore. (i.e. app_chanspy) */
1228 ast_channel_lock(chan
);
1229 ast_channel_unlock(chan
);
1231 if (chan
->tech_pvt
) {
1232 ast_log(LOG_WARNING
, "Channel '%s' may not have been hung up properly\n", chan
->name
);
1233 free(chan
->tech_pvt
);
1237 sched_context_destroy(chan
->sched
);
1239 ast_copy_string(name
, chan
->name
, sizeof(name
));
1240 if ((dashptr
= strrchr(name
, '-'))) {
1244 /* Stop monitoring */
1246 chan
->monitor
->stop( chan
, 0 );
1248 /* If there is native format music-on-hold state, free it */
1249 if (chan
->music_state
)
1250 ast_moh_cleanup(chan
);
1252 /* Free translators */
1253 if (chan
->readtrans
)
1254 ast_translator_free_path(chan
->readtrans
);
1255 if (chan
->writetrans
)
1256 ast_translator_free_path(chan
->writetrans
);
1258 ast_log(LOG_WARNING
, "PBX may not have been terminated properly on '%s'\n", chan
->name
);
1259 free_cid(&chan
->cid
);
1260 /* Close pipes if appropriate */
1261 if ((fd
= chan
->alertpipe
[0]) > -1)
1263 if ((fd
= chan
->alertpipe
[1]) > -1)
1265 if ((fd
= chan
->timingfd
) > -1)
1267 while ((f
= AST_LIST_REMOVE_HEAD(&chan
->readq
, frame_list
)))
1270 /* loop over the variables list, freeing all data and deleting list items */
1271 /* no need to lock the list, as the channel is already locked */
1273 while ((vardata
= AST_LIST_REMOVE_HEAD(headp
, entries
)))
1274 ast_var_delete(vardata
);
1276 ast_app_group_discard(chan
);
1278 /* Destroy the jitterbuffer */
1279 ast_jb_destroy(chan
);
1282 ast_cdr_discard(chan
->cdr
);
1286 ast_mutex_destroy(&chan
->lock
);
1288 ast_string_field_free_memory(chan
);
1290 AST_LIST_UNLOCK(&channels
);
1292 ast_device_state_changed_literal(name
);
1295 struct ast_datastore
*ast_channel_datastore_alloc(const struct ast_datastore_info
*info
, char *uid
)
1297 struct ast_datastore
*datastore
= NULL
;
1299 /* Make sure we at least have type so we can identify this */
1304 /* Allocate memory for datastore and clear it */
1305 datastore
= ast_calloc(1, sizeof(*datastore
));
1306 if (datastore
== NULL
) {
1310 datastore
->info
= info
;
1312 datastore
->uid
= ast_strdup(uid
);
1317 int ast_channel_datastore_free(struct ast_datastore
*datastore
)
1321 /* Using the destroy function (if present) destroy the data */
1322 if (datastore
->info
->destroy
!= NULL
&& datastore
->data
!= NULL
) {
1323 datastore
->info
->destroy(datastore
->data
);
1324 datastore
->data
= NULL
;
1327 /* Free allocated UID memory */
1328 if (datastore
->uid
!= NULL
) {
1329 free(datastore
->uid
);
1330 datastore
->uid
= NULL
;
1333 /* Finally free memory used by ourselves */
1339 int ast_channel_datastore_inherit(struct ast_channel
*from
, struct ast_channel
*to
)
1341 struct ast_datastore
*datastore
= NULL
, *datastore2
;
1343 AST_LIST_TRAVERSE(&from
->datastores
, datastore
, entry
) {
1344 if (datastore
->inheritance
> 0) {
1345 datastore2
= ast_channel_datastore_alloc(datastore
->info
, datastore
->uid
);
1347 datastore2
->data
= datastore
->info
->duplicate(datastore
->data
);
1348 datastore2
->inheritance
= datastore
->inheritance
== DATASTORE_INHERIT_FOREVER
? DATASTORE_INHERIT_FOREVER
: datastore
->inheritance
- 1;
1349 AST_LIST_INSERT_TAIL(&to
->datastores
, datastore2
, entry
);
1356 int ast_channel_datastore_add(struct ast_channel
*chan
, struct ast_datastore
*datastore
)
1360 AST_LIST_INSERT_HEAD(&chan
->datastores
, datastore
, entry
);
1365 int ast_channel_datastore_remove(struct ast_channel
*chan
, struct ast_datastore
*datastore
)
1367 struct ast_datastore
*datastore2
= NULL
;
1370 /* Find our position and remove ourselves */
1371 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan
->datastores
, datastore2
, entry
) {
1372 if (datastore2
== datastore
) {
1373 AST_LIST_REMOVE_CURRENT(&chan
->datastores
, entry
);
1378 AST_LIST_TRAVERSE_SAFE_END
1383 struct ast_datastore
*ast_channel_datastore_find(struct ast_channel
*chan
, const struct ast_datastore_info
*info
, char *uid
)
1385 struct ast_datastore
*datastore
= NULL
;
1390 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan
->datastores
, datastore
, entry
) {
1391 if (datastore
->info
== info
) {
1392 if (uid
!= NULL
&& datastore
->uid
!= NULL
) {
1393 if (!strcasecmp(uid
, datastore
->uid
)) {
1394 /* Matched by type AND uid */
1398 /* Matched by type at least */
1403 AST_LIST_TRAVERSE_SAFE_END
1408 /*! \brief Softly hangup a channel, don't lock */
1409 int ast_softhangup_nolock(struct ast_channel
*chan
, int cause
)
1412 ast_log(LOG_DEBUG
, "Soft-Hanging up channel '%s'\n", chan
->name
);
1413 /* Inform channel driver that we need to be hung up, if it cares */
1414 chan
->_softhangup
|= cause
;
1415 ast_queue_frame(chan
, &ast_null_frame
);
1416 /* Interrupt any poll call or such */
1417 if (ast_test_flag(chan
, AST_FLAG_BLOCKING
))
1418 pthread_kill(chan
->blocker
, SIGURG
);
1422 /*! \brief Softly hangup a channel, lock */
1423 int ast_softhangup(struct ast_channel
*chan
, int cause
)
1426 ast_channel_lock(chan
);
1427 res
= ast_softhangup_nolock(chan
, cause
);
1428 ast_channel_unlock(chan
);
1432 static void free_translation(struct ast_channel
*clone
)
1434 if (clone
->writetrans
)
1435 ast_translator_free_path(clone
->writetrans
);
1436 if (clone
->readtrans
)
1437 ast_translator_free_path(clone
->readtrans
);
1438 clone
->writetrans
= NULL
;
1439 clone
->readtrans
= NULL
;
1440 clone
->rawwriteformat
= clone
->nativeformats
;
1441 clone
->rawreadformat
= clone
->nativeformats
;
1444 /*! \brief Hangup a channel */
1445 int ast_hangup(struct ast_channel
*chan
)
1449 /* Don't actually hang up a channel that will masquerade as someone else, or
1450 if someone is going to masquerade as us */
1451 ast_channel_lock(chan
);
1453 if (chan
->audiohooks
) {
1454 ast_audiohook_detach_list(chan
->audiohooks
);
1455 chan
->audiohooks
= NULL
;
1458 ast_autoservice_stop(chan
);
1461 if (ast_do_masquerade(chan
))
1462 ast_log(LOG_WARNING
, "Failed to perform masquerade\n");
1466 ast_log(LOG_WARNING
, "%s getting hung up, but someone is trying to masq into us?!?\n", chan
->name
);
1467 ast_channel_unlock(chan
);
1470 /* If this channel is one which will be masqueraded into something,
1471 mark it as a zombie already, so we know to free it later */
1473 ast_set_flag(chan
, AST_FLAG_ZOMBIE
);
1474 ast_channel_unlock(chan
);
1477 free_translation(chan
);
1478 /* Close audio stream */
1480 ast_closestream(chan
->stream
);
1481 chan
->stream
= NULL
;
1483 /* Close video stream */
1484 if (chan
->vstream
) {
1485 ast_closestream(chan
->vstream
);
1486 chan
->vstream
= NULL
;
1489 sched_context_destroy(chan
->sched
);
1493 if (chan
->generatordata
) /* Clear any tone stuff remaining */
1494 chan
->generator
->release(chan
, chan
->generatordata
);
1495 chan
->generatordata
= NULL
;
1496 chan
->generator
= NULL
;
1497 if (ast_test_flag(chan
, AST_FLAG_BLOCKING
)) {
1498 ast_log(LOG_WARNING
, "Hard hangup called by thread %ld on %s, while fd "
1499 "is blocked by thread %ld in procedure %s! Expect a failure\n",
1500 (long)pthread_self(), chan
->name
, (long)chan
->blocker
, chan
->blockproc
);
1501 ast_assert(ast_test_flag(chan
, AST_FLAG_BLOCKING
) == 0);
1503 if (!ast_test_flag(chan
, AST_FLAG_ZOMBIE
)) {
1505 ast_log(LOG_DEBUG
, "Hanging up channel '%s'\n", chan
->name
);
1506 if (chan
->tech
->hangup
)
1507 res
= chan
->tech
->hangup(chan
);
1510 ast_log(LOG_DEBUG
, "Hanging up zombie '%s'\n", chan
->name
);
1513 ast_channel_unlock(chan
);
1514 manager_event(EVENT_FLAG_CALL
, "Hangup",
1518 "Cause-txt: %s\r\n",
1522 ast_cause2str(chan
->hangupcause
)
1525 if (chan
->cdr
&& !ast_test_flag(chan
->cdr
, AST_CDR_FLAG_BRIDGED
) &&
1526 !ast_test_flag(chan
->cdr
, AST_CDR_FLAG_POST_DISABLED
) &&
1527 (chan
->cdr
->disposition
!= AST_CDR_NULL
|| ast_test_flag(chan
->cdr
, AST_CDR_FLAG_DIALED
))) {
1529 ast_cdr_end(chan
->cdr
);
1530 ast_cdr_detach(chan
->cdr
);
1534 ast_channel_free(chan
);
1539 int ast_answer(struct ast_channel
*chan
)
1542 ast_channel_lock(chan
);
1543 /* You can't answer an outbound call */
1544 if (ast_test_flag(chan
, AST_FLAG_OUTGOING
)) {
1545 ast_channel_unlock(chan
);
1548 /* Stop if we're a zombie or need a soft hangup */
1549 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
)) {
1550 ast_channel_unlock(chan
);
1553 switch(chan
->_state
) {
1554 case AST_STATE_RINGING
:
1555 case AST_STATE_RING
:
1556 if (chan
->tech
->answer
)
1557 res
= chan
->tech
->answer(chan
);
1558 ast_setstate(chan
, AST_STATE_UP
);
1559 ast_cdr_answer(chan
->cdr
);
1566 chan
->visible_indication
= 0;
1567 ast_channel_unlock(chan
);
1571 void ast_deactivate_generator(struct ast_channel
*chan
)
1573 ast_channel_lock(chan
);
1574 if (chan
->generatordata
) {
1575 if (chan
->generator
&& chan
->generator
->release
)
1576 chan
->generator
->release(chan
, chan
->generatordata
);
1577 chan
->generatordata
= NULL
;
1578 chan
->generator
= NULL
;
1579 chan
->fds
[AST_GENERATOR_FD
] = -1;
1580 ast_clear_flag(chan
, AST_FLAG_WRITE_INT
);
1581 ast_settimeout(chan
, 0, NULL
, NULL
);
1583 ast_channel_unlock(chan
);
1586 static int generator_force(const void *data
)
1588 /* Called if generator doesn't have data */
1591 int (*generate
)(struct ast_channel
*chan
, void *tmp
, int datalen
, int samples
) = NULL
;
1592 struct ast_channel
*chan
= (struct ast_channel
*)data
;
1594 ast_channel_lock(chan
);
1595 tmp
= chan
->generatordata
;
1596 chan
->generatordata
= NULL
;
1597 if (chan
->generator
)
1598 generate
= chan
->generator
->generate
;
1599 ast_channel_unlock(chan
);
1601 if (!tmp
|| !generate
)
1604 res
= generate(chan
, tmp
, 0, ast_format_rate(chan
->writeformat
& AST_FORMAT_AUDIO_MASK
) / 50);
1606 chan
->generatordata
= tmp
;
1610 ast_log(LOG_DEBUG
, "Auto-deactivating generator\n");
1611 ast_deactivate_generator(chan
);
1617 int ast_activate_generator(struct ast_channel
*chan
, struct ast_generator
*gen
, void *params
)
1621 ast_channel_lock(chan
);
1623 if (chan
->generatordata
) {
1624 if (chan
->generator
&& chan
->generator
->release
)
1625 chan
->generator
->release(chan
, chan
->generatordata
);
1626 chan
->generatordata
= NULL
;
1630 if (gen
->alloc
&& !(chan
->generatordata
= gen
->alloc(chan
, params
))) {
1635 ast_settimeout(chan
, 160, generator_force
, chan
);
1636 chan
->generator
= gen
;
1639 ast_channel_unlock(chan
);
1644 /*! \brief Wait for x amount of time on a file descriptor to have input. */
1645 int ast_waitfor_n_fd(int *fds
, int n
, int *ms
, int *exception
)
1648 ast_waitfor_nandfds(NULL
, 0, fds
, n
, exception
, &winner
, ms
);
1652 /*! \brief Wait for x amount of time on a file descriptor to have input. */
1653 struct ast_channel
*ast_waitfor_nandfds(struct ast_channel
**c
, int n
, int *fds
, int nfds
,
1654 int *exception
, int *outfd
, int *ms
)
1656 struct timeval start
= { 0 , 0 };
1657 struct pollfd
*pfds
= NULL
;
1663 long whentohangup
= 0, diff
;
1664 struct ast_channel
*winner
= NULL
;
1670 if ((sz
= n
* AST_MAX_FDS
+ nfds
)) {
1671 pfds
= alloca(sizeof(*pfds
) * sz
);
1672 fdmap
= alloca(sizeof(*fdmap
) * sz
);
1680 /* Perform any pending masquerades */
1681 for (x
=0; x
< n
; x
++) {
1682 ast_channel_lock(c
[x
]);
1684 if (ast_do_masquerade(c
[x
])) {
1685 ast_log(LOG_WARNING
, "Masquerade failed\n");
1687 ast_channel_unlock(c
[x
]);
1691 if (c
[x
]->whentohangup
) {
1694 diff
= c
[x
]->whentohangup
- now
;
1696 /* Should already be hungup */
1697 c
[x
]->_softhangup
|= AST_SOFTHANGUP_TIMEOUT
;
1698 ast_channel_unlock(c
[x
]);
1701 if (!whentohangup
|| (diff
< whentohangup
))
1702 whentohangup
= diff
;
1704 ast_channel_unlock(c
[x
]);
1706 /* Wait full interval */
1709 rms
= whentohangup
* 1000; /* timeout in milliseconds */
1710 if (*ms
>= 0 && *ms
< rms
) /* original *ms still smaller */
1714 * Build the pollfd array, putting the channels' fds first,
1715 * followed by individual fds. Order is important because
1716 * individual fd's must have priority over channel fds.
1719 for (x
=0; x
<n
; x
++) {
1720 for (y
=0; y
<AST_MAX_FDS
; y
++) {
1721 fdmap
[max
].fdno
= y
; /* fd y is linked to this pfds */
1722 fdmap
[max
].chan
= x
; /* channel x is linked to this pfds */
1723 max
+= ast_add_fd(&pfds
[max
], c
[x
]->fds
[y
]);
1725 CHECK_BLOCKING(c
[x
]);
1727 /* Add the individual fds */
1728 for (x
=0; x
<nfds
; x
++) {
1729 fdmap
[max
].chan
= -1;
1730 max
+= ast_add_fd(&pfds
[max
], fds
[x
]);
1734 start
= ast_tvnow();
1736 if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1741 res
= poll(pfds
, max
, kbrms
);
1744 } while (!res
&& (rms
> 0));
1746 res
= poll(pfds
, max
, rms
);
1749 ast_clear_flag(c
[x
], AST_FLAG_BLOCKING
);
1750 if (res
< 0) { /* Simulate a timeout if we were interrupted */
1755 if (whentohangup
) { /* if we have a timeout, check who expired */
1757 for (x
=0; x
<n
; x
++) {
1758 if (c
[x
]->whentohangup
&& now
>= c
[x
]->whentohangup
) {
1759 c
[x
]->_softhangup
|= AST_SOFTHANGUP_TIMEOUT
;
1765 if (res
== 0) { /* no fd ready, reset timeout and done */
1766 *ms
= 0; /* XXX use 0 since we may not have an exact timeout. */
1770 * Then check if any channel or fd has a pending event.
1771 * Remember to check channels first and fds last, as they
1772 * must have priority on setting 'winner'
1774 for (x
= 0; x
< max
; x
++) {
1775 res
= pfds
[x
].revents
;
1778 if (fdmap
[x
].chan
>= 0) { /* this is a channel */
1779 winner
= c
[fdmap
[x
].chan
]; /* override previous winners */
1781 ast_set_flag(winner
, AST_FLAG_EXCEPTION
);
1783 ast_clear_flag(winner
, AST_FLAG_EXCEPTION
);
1784 winner
->fdno
= fdmap
[x
].fdno
;
1785 } else { /* this is an fd */
1787 *outfd
= pfds
[x
].fd
;
1789 *exception
= (res
& POLLPRI
) ? -1 : 0;
1794 *ms
-= ast_tvdiff_ms(ast_tvnow(), start
);
1801 struct ast_channel
*ast_waitfor_n(struct ast_channel
**c
, int n
, int *ms
)
1803 return ast_waitfor_nandfds(c
, n
, NULL
, 0, NULL
, NULL
, ms
);
1806 int ast_waitfor(struct ast_channel
*c
, int ms
)
1808 int oldms
= ms
; /* -1 if no timeout */
1810 ast_waitfor_nandfds(&c
, 1, NULL
, 0, NULL
, NULL
, &ms
);
1811 if ((ms
< 0) && (oldms
< 0))
1816 /* XXX never to be called with ms = -1 */
1817 int ast_waitfordigit(struct ast_channel
*c
, int ms
)
1819 return ast_waitfordigit_full(c
, ms
, -1, -1);
1822 int ast_settimeout(struct ast_channel
*c
, int samples
, int (*func
)(const void *data
), void *data
)
1826 if (c
->timingfd
> -1) {
1832 ast_log(LOG_DEBUG
, "Scheduling timer at %d sample intervals\n", samples
);
1833 res
= ioctl(c
->timingfd
, DAHDI_TIMERCONFIG
, &samples
);
1834 c
->timingfunc
= func
;
1835 c
->timingdata
= data
;
1841 int ast_waitfordigit_full(struct ast_channel
*c
, int ms
, int audiofd
, int cmdfd
)
1843 /* Stop if we're a zombie or need a soft hangup */
1844 if (ast_test_flag(c
, AST_FLAG_ZOMBIE
) || ast_check_hangup(c
))
1847 /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
1848 ast_set_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1850 /* Wait for a digit, no more than ms milliseconds total. */
1852 struct ast_channel
*rchan
;
1856 rchan
= ast_waitfor_nandfds(&c
, 1, &cmdfd
, (cmdfd
> -1) ? 1 : 0, NULL
, &outfd
, &ms
);
1857 if (!rchan
&& outfd
< 0 && ms
) {
1858 if (errno
== 0 || errno
== EINTR
)
1860 ast_log(LOG_WARNING
, "Wait failed (%s)\n", strerror(errno
));
1861 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1863 } else if (outfd
> -1) {
1864 /* The FD we were watching has something waiting */
1865 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1869 struct ast_frame
*f
= ast_read(c
);
1873 switch(f
->frametype
) {
1874 case AST_FRAME_DTMF_BEGIN
:
1876 case AST_FRAME_DTMF_END
:
1879 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1881 case AST_FRAME_CONTROL
:
1882 switch(f
->subclass
) {
1883 case AST_CONTROL_HANGUP
:
1885 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1887 case AST_CONTROL_RINGING
:
1888 case AST_CONTROL_ANSWER
:
1889 case AST_CONTROL_SRCUPDATE
:
1893 ast_log(LOG_WARNING
, "Unexpected control subclass '%d'\n", f
->subclass
);
1897 case AST_FRAME_VOICE
:
1898 /* Write audio if appropriate */
1900 write(audiofd
, f
->data
, f
->datalen
);
1909 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1911 return 0; /* Time is up */
1914 static void ast_read_generator_actions(struct ast_channel
*chan
, struct ast_frame
*f
)
1916 if (chan
->generatordata
&& !ast_internal_timing_enabled(chan
)) {
1917 void *tmp
= chan
->generatordata
;
1918 int (*generate
)(struct ast_channel
*chan
, void *tmp
, int datalen
, int samples
) = NULL
;
1922 if (chan
->timingfunc
) {
1923 if (option_debug
> 1)
1924 ast_log(LOG_DEBUG
, "Generator got voice, switching to phase locked mode\n");
1925 ast_settimeout(chan
, 0, NULL
, NULL
);
1928 chan
->generatordata
= NULL
; /* reset, to let writes go through */
1930 if (f
->subclass
!= chan
->writeformat
) {
1932 factor
= ((float) ast_format_rate(chan
->writeformat
)) / ((float) ast_format_rate(f
->subclass
));
1933 samples
= (int) ( ((float) f
->samples
) * factor
);
1935 samples
= f
->samples
;
1938 if (chan
->generator
->generate
) {
1939 generate
= chan
->generator
->generate
;
1941 /* This unlock is here based on two assumptions that hold true at this point in the
1942 * code. 1) this function is only called from within __ast_read() and 2) all generators
1943 * call ast_write() in their generate callback.
1945 * The reason this is added is so that when ast_write is called, the lock that occurs
1946 * there will not recursively lock the channel. Doing this will cause intended deadlock
1947 * avoidance not to work in deeper functions
1949 ast_channel_unlock(chan
);
1950 res
= generate(chan
, tmp
, f
->datalen
, samples
);
1951 ast_channel_lock(chan
);
1952 chan
->generatordata
= tmp
;
1954 if (option_debug
> 1)
1955 ast_log(LOG_DEBUG
, "Auto-deactivating generator\n");
1956 ast_deactivate_generator(chan
);
1959 } else if (f
->frametype
== AST_FRAME_CNG
) {
1960 if (chan
->generator
&& !chan
->timingfunc
&& (chan
->timingfd
> -1)) {
1961 if (option_debug
> 1)
1962 ast_log(LOG_DEBUG
, "Generator got CNG, switching to timed mode\n");
1963 ast_settimeout(chan
, 160, generator_force
, chan
);
1968 static struct ast_frame
*__ast_read(struct ast_channel
*chan
, int dropaudio
)
1970 struct ast_frame
*f
= NULL
; /* the return value */
1975 /* this function is very long so make sure there is only one return
1976 * point at the end (there are only two exceptions to this).
1978 while(ast_channel_trylock(chan
)) {
1980 /*cannot goto done since the channel is not locked*/
1981 return &ast_null_frame
;
1986 if (ast_do_masquerade(chan
))
1987 ast_log(LOG_WARNING
, "Failed to perform masquerade\n");
1989 f
= &ast_null_frame
;
1993 /* Stop if we're a zombie or need a soft hangup */
1994 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
)) {
1995 if (chan
->generator
)
1996 ast_deactivate_generator(chan
);
1999 prestate
= chan
->_state
;
2001 if (!ast_test_flag(chan
, AST_FLAG_DEFER_DTMF
| AST_FLAG_EMULATE_DTMF
| AST_FLAG_IN_DTMF
) &&
2002 !ast_strlen_zero(chan
->dtmfq
) &&
2003 (ast_tvzero(chan
->dtmf_tv
) || ast_tvdiff_ms(ast_tvnow(), chan
->dtmf_tv
) > AST_MIN_DTMF_GAP
) ) {
2004 /* We have DTMF that has been deferred. Return it now */
2005 chan
->dtmff
.subclass
= chan
->dtmfq
[0];
2006 /* Drop first digit from the buffer */
2007 memmove(chan
->dtmfq
, chan
->dtmfq
+ 1, sizeof(chan
->dtmfq
) - 1);
2009 if (ast_test_flag(chan
, AST_FLAG_END_DTMF_ONLY
)) {
2010 ast_log(LOG_DTMF
, "DTMF end emulation of '%c' queued on %s\n", f
->subclass
, chan
->name
);
2011 chan
->dtmff
.frametype
= AST_FRAME_DTMF_END
;
2013 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
);
2014 chan
->dtmff
.frametype
= AST_FRAME_DTMF_BEGIN
;
2015 ast_set_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2016 chan
->emulate_dtmf_digit
= f
->subclass
;
2017 chan
->emulate_dtmf_duration
= AST_DEFAULT_EMULATE_DTMF_DURATION
;
2019 chan
->dtmf_tv
= ast_tvnow();
2023 /* Read and ignore anything on the alertpipe, but read only
2024 one sizeof(blah) per frame that we send from it */
2025 if (chan
->alertpipe
[0] > -1) {
2026 int flags
= fcntl(chan
->alertpipe
[0], F_GETFL
);
2027 /* For some odd reason, the alertpipe occasionally loses nonblocking status,
2028 * which immediately causes a deadlock scenario. Detect and prevent this. */
2029 if ((flags
& O_NONBLOCK
) == 0) {
2030 ast_log(LOG_ERROR
, "Alertpipe on channel %s lost O_NONBLOCK?!!\n", chan
->name
);
2031 if (fcntl(chan
->alertpipe
[0], F_SETFL
, flags
| O_NONBLOCK
) < 0) {
2032 ast_log(LOG_WARNING
, "Unable to set alertpipe nonblocking! (%d: %s)\n", errno
, strerror(errno
));
2033 f
= &ast_null_frame
;
2037 read(chan
->alertpipe
[0], &blah
, sizeof(blah
));
2041 if (chan
->timingfd
> -1 && chan
->fdno
== AST_TIMING_FD
&& ast_test_flag(chan
, AST_FLAG_EXCEPTION
)) {
2044 ast_clear_flag(chan
, AST_FLAG_EXCEPTION
);
2046 /* IF we can't get event, assume it's an expired as-per the old interface */
2047 res
= ioctl(chan
->timingfd
, DAHDI_GETEVENT
, &blah
);
2049 blah
= DAHDI_EVENT_TIMER_EXPIRED
;
2051 if (blah
== DAHDI_EVENT_TIMER_PING
) {
2052 if (AST_LIST_EMPTY(&chan
->readq
) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan
->readq
), frame_list
)) {
2053 /* Acknowledge PONG unless we need it again */
2054 if (ioctl(chan
->timingfd
, DAHDI_TIMERPONG
, &blah
)) {
2055 ast_log(LOG_WARNING
, "Failed to pong timer on '%s': %s\n", chan
->name
, strerror(errno
));
2058 } else if (blah
== DAHDI_EVENT_TIMER_EXPIRED
) {
2059 ioctl(chan
->timingfd
, DAHDI_TIMERACK
, &blah
);
2060 if (chan
->timingfunc
) {
2061 /* save a copy of func/data before unlocking the channel */
2062 int (*func
)(const void *) = chan
->timingfunc
;
2063 void *data
= chan
->timingdata
;
2064 ast_channel_unlock(chan
);
2068 ioctl(chan
->timingfd
, DAHDI_TIMERCONFIG
, &blah
);
2069 chan
->timingdata
= NULL
;
2070 ast_channel_unlock(chan
);
2072 /* cannot 'goto done' because the channel is already unlocked */
2073 return &ast_null_frame
;
2075 ast_log(LOG_NOTICE
, "No/unknown event '%d' on timer for '%s'?\n", blah
, chan
->name
);
2078 if (chan
->fds
[AST_GENERATOR_FD
] > -1 && chan
->fdno
== AST_GENERATOR_FD
) {
2079 /* if the AST_GENERATOR_FD is set, call the generator with args
2080 * set to -1 so it can do whatever it needs to.
2082 void *tmp
= chan
->generatordata
;
2083 chan
->generatordata
= NULL
; /* reset to let ast_write get through */
2084 chan
->generator
->generate(chan
, tmp
, -1, -1);
2085 chan
->generatordata
= tmp
;
2086 f
= &ast_null_frame
;
2090 /* Check for pending read queue */
2091 if (!AST_LIST_EMPTY(&chan
->readq
)) {
2092 f
= AST_LIST_REMOVE_HEAD(&chan
->readq
, frame_list
);
2093 /* Interpret hangup and return NULL */
2094 /* XXX why not the same for frames from the channel ? */
2095 if (f
->frametype
== AST_FRAME_CONTROL
&& f
->subclass
== AST_CONTROL_HANGUP
) {
2100 chan
->blocker
= pthread_self();
2101 if (ast_test_flag(chan
, AST_FLAG_EXCEPTION
)) {
2102 if (chan
->tech
->exception
)
2103 f
= chan
->tech
->exception(chan
);
2105 ast_log(LOG_WARNING
, "Exception flag set on '%s', but no exception handler\n", chan
->name
);
2106 f
= &ast_null_frame
;
2108 /* Clear the exception flag */
2109 ast_clear_flag(chan
, AST_FLAG_EXCEPTION
);
2110 } else if (chan
->tech
->read
)
2111 f
= chan
->tech
->read(chan
);
2113 ast_log(LOG_WARNING
, "No read routine on channel %s\n", chan
->name
);
2117 /* if the channel driver returned more than one frame, stuff the excess
2118 into the readq for the next ast_read call (note that we can safely assume
2119 that the readq is empty, because otherwise we would not have called into
2120 the channel driver and f would be only a single frame)
2122 if (AST_LIST_NEXT(f
, frame_list
)) {
2123 AST_LIST_HEAD_SET_NOLOCK(&chan
->readq
, AST_LIST_NEXT(f
, frame_list
));
2124 AST_LIST_NEXT(f
, frame_list
) = NULL
;
2127 switch (f
->frametype
) {
2128 case AST_FRAME_CONTROL
:
2129 if (f
->subclass
== AST_CONTROL_ANSWER
) {
2130 if (!ast_test_flag(chan
, AST_FLAG_OUTGOING
)) {
2132 ast_log(LOG_DEBUG
, "Ignoring answer on an inbound call!\n");
2134 f
= &ast_null_frame
;
2135 } else if (prestate
== AST_STATE_UP
) {
2137 ast_log(LOG_DEBUG
, "Dropping duplicate answer!\n");
2139 f
= &ast_null_frame
;
2141 /* Answer the CDR */
2142 ast_setstate(chan
, AST_STATE_UP
);
2143 /* removed a call to ast_cdr_answer(chan->cdr) from here. */
2147 case AST_FRAME_DTMF_END
:
2148 ast_log(LOG_DTMF
, "DTMF end '%c' received on %s, duration %ld ms\n", f
->subclass
, chan
->name
, f
->len
);
2149 /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2150 * However, only let emulation be forced if the other end cares about BEGIN frames */
2151 if ( ast_test_flag(chan
, AST_FLAG_DEFER_DTMF
) ||
2152 (ast_test_flag(chan
, AST_FLAG_EMULATE_DTMF
) && !ast_test_flag(chan
, AST_FLAG_END_DTMF_ONLY
)) ) {
2153 if (strlen(chan
->dtmfq
) < sizeof(chan
->dtmfq
) - 2) {
2154 ast_log(LOG_DTMF
, "DTMF end '%c' put into dtmf queue on %s\n", f
->subclass
, chan
->name
);
2155 chan
->dtmfq
[strlen(chan
->dtmfq
)] = f
->subclass
;
2157 ast_log(LOG_WARNING
, "Dropping deferred DTMF digits on %s\n", chan
->name
);
2159 f
= &ast_null_frame
;
2160 } else if (!ast_test_flag(chan
, AST_FLAG_IN_DTMF
| AST_FLAG_END_DTMF_ONLY
)) {
2161 if (!ast_tvzero(chan
->dtmf_tv
) &&
2162 ast_tvdiff_ms(ast_tvnow(), chan
->dtmf_tv
) < AST_MIN_DTMF_GAP
) {
2163 /* If it hasn't been long enough, defer this digit */
2164 if (strlen(chan
->dtmfq
) < sizeof(chan
->dtmfq
) - 2) {
2165 ast_log(LOG_DTMF
, "DTMF end '%c' put into dtmf queue on %s\n", f
->subclass
, chan
->name
);
2166 chan
->dtmfq
[strlen(chan
->dtmfq
)] = f
->subclass
;
2168 ast_log(LOG_WARNING
, "Dropping deferred DTMF digits on %s\n", chan
->name
);
2170 f
= &ast_null_frame
;
2172 /* There was no begin, turn this into a begin and send the end later */
2173 f
->frametype
= AST_FRAME_DTMF_BEGIN
;
2174 ast_set_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2175 chan
->emulate_dtmf_digit
= f
->subclass
;
2176 chan
->dtmf_tv
= ast_tvnow();
2178 if (f
->len
> AST_MIN_DTMF_DURATION
)
2179 chan
->emulate_dtmf_duration
= f
->len
;
2181 chan
->emulate_dtmf_duration
= AST_MIN_DTMF_DURATION
;
2183 chan
->emulate_dtmf_duration
= AST_DEFAULT_EMULATE_DTMF_DURATION
;
2184 ast_log(LOG_DTMF
, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f
->subclass
, chan
->emulate_dtmf_duration
, chan
->name
);
2186 if (chan
->audiohooks
) {
2187 struct ast_frame
*old_frame
= f
;
2188 f
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_READ
, f
);
2190 ast_frfree(old_frame
);
2193 struct timeval now
= ast_tvnow();
2194 if (ast_test_flag(chan
, AST_FLAG_IN_DTMF
)) {
2195 ast_log(LOG_DTMF
, "DTMF end accepted with begin '%c' on %s\n", f
->subclass
, chan
->name
);
2196 ast_clear_flag(chan
, AST_FLAG_IN_DTMF
);
2198 f
->len
= ast_tvdiff_ms(now
, chan
->dtmf_tv
);
2199 } else if (!f
->len
) {
2200 ast_log(LOG_DTMF
, "DTMF end accepted without begin '%c' on %s\n", f
->subclass
, chan
->name
);
2201 f
->len
= AST_MIN_DTMF_DURATION
;
2203 if (f
->len
< AST_MIN_DTMF_DURATION
&& !ast_test_flag(chan
, AST_FLAG_END_DTMF_ONLY
)) {
2204 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
);
2205 ast_set_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2206 chan
->emulate_dtmf_digit
= f
->subclass
;
2207 chan
->emulate_dtmf_duration
= AST_MIN_DTMF_DURATION
- f
->len
;
2209 f
= &ast_null_frame
;
2211 ast_log(LOG_DTMF
, "DTMF end passthrough '%c' on %s\n", f
->subclass
, chan
->name
);
2212 if (f
->len
< AST_MIN_DTMF_DURATION
) {
2213 f
->len
= AST_MIN_DTMF_DURATION
;
2215 chan
->dtmf_tv
= now
;
2217 if (chan
->audiohooks
) {
2218 struct ast_frame
*old_frame
= f
;
2219 f
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_READ
, f
);
2221 ast_frfree(old_frame
);
2225 case AST_FRAME_DTMF_BEGIN
:
2226 ast_log(LOG_DTMF
, "DTMF begin '%c' received on %s\n", f
->subclass
, chan
->name
);
2227 if ( ast_test_flag(chan
, AST_FLAG_DEFER_DTMF
| AST_FLAG_END_DTMF_ONLY
| AST_FLAG_EMULATE_DTMF
) ||
2228 (!ast_tvzero(chan
->dtmf_tv
) &&
2229 ast_tvdiff_ms(ast_tvnow(), chan
->dtmf_tv
) < AST_MIN_DTMF_GAP
) ) {
2230 ast_log(LOG_DTMF
, "DTMF begin ignored '%c' on %s\n", f
->subclass
, chan
->name
);
2232 f
= &ast_null_frame
;
2234 ast_set_flag(chan
, AST_FLAG_IN_DTMF
);
2235 chan
->dtmf_tv
= ast_tvnow();
2236 ast_log(LOG_DTMF
, "DTMF begin passthrough '%c' on %s\n", f
->subclass
, chan
->name
);
2239 case AST_FRAME_NULL
:
2240 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2241 * is reached , because we want to make sure we pass at least one
2242 * voice frame through before starting the next digit, to ensure a gap
2243 * between DTMF digits. */
2244 if (ast_test_flag(chan
, AST_FLAG_EMULATE_DTMF
)) {
2245 struct timeval now
= ast_tvnow();
2246 if (!chan
->emulate_dtmf_duration
) {
2247 ast_clear_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2248 chan
->emulate_dtmf_digit
= 0;
2249 } else if (ast_tvdiff_ms(now
, chan
->dtmf_tv
) >= chan
->emulate_dtmf_duration
) {
2250 chan
->emulate_dtmf_duration
= 0;
2253 f
->frametype
= AST_FRAME_DTMF_END
;
2254 f
->subclass
= chan
->emulate_dtmf_digit
;
2255 f
->len
= ast_tvdiff_ms(now
, chan
->dtmf_tv
);
2256 chan
->dtmf_tv
= now
;
2257 ast_clear_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2258 chan
->emulate_dtmf_digit
= 0;
2259 ast_log(LOG_DTMF
, "DTMF end emulation of '%c' queued on %s\n", f
->subclass
, chan
->name
);
2263 case AST_FRAME_VOICE
:
2264 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2265 * is reached , because we want to make sure we pass at least one
2266 * voice frame through before starting the next digit, to ensure a gap
2267 * between DTMF digits. */
2268 if (ast_test_flag(chan
, AST_FLAG_EMULATE_DTMF
) && !chan
->emulate_dtmf_duration
) {
2269 ast_clear_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2270 chan
->emulate_dtmf_digit
= 0;
2273 if (dropaudio
|| ast_test_flag(chan
, AST_FLAG_IN_DTMF
)) {
2275 ast_read_generator_actions(chan
, f
);
2277 f
= &ast_null_frame
;
2280 if (ast_test_flag(chan
, AST_FLAG_EMULATE_DTMF
) && !ast_test_flag(chan
, AST_FLAG_IN_DTMF
)) {
2281 struct timeval now
= ast_tvnow();
2282 if (ast_tvdiff_ms(now
, chan
->dtmf_tv
) >= chan
->emulate_dtmf_duration
) {
2283 chan
->emulate_dtmf_duration
= 0;
2286 f
->frametype
= AST_FRAME_DTMF_END
;
2287 f
->subclass
= chan
->emulate_dtmf_digit
;
2288 f
->len
= ast_tvdiff_ms(now
, chan
->dtmf_tv
);
2289 chan
->dtmf_tv
= now
;
2290 if (chan
->audiohooks
) {
2291 struct ast_frame
*old_frame
= f
;
2292 f
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_READ
, f
);
2294 ast_frfree(old_frame
);
2296 ast_log(LOG_DTMF
, "DTMF end emulation of '%c' queued on %s\n", f
->subclass
, chan
->name
);
2298 /* Drop voice frames while we're still in the middle of the digit */
2300 f
= &ast_null_frame
;
2302 } else if ((f
->frametype
== AST_FRAME_VOICE
) && !(f
->subclass
& chan
->nativeformats
)) {
2303 /* This frame is not one of the current native formats -- drop it on the floor */
2305 ast_log(LOG_NOTICE
, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2306 chan
->name
, ast_getformatname(f
->subclass
), ast_getformatname_multiple(to
, sizeof(to
), chan
->nativeformats
));
2308 f
= &ast_null_frame
;
2309 } else if ((f
->frametype
== AST_FRAME_VOICE
)) {
2310 if (chan
->audiohooks
) {
2311 struct ast_frame
*old_frame
= f
;
2312 f
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_READ
, f
);
2314 ast_frfree(old_frame
);
2316 if (chan
->monitor
&& chan
->monitor
->read_stream
) {
2317 /* XXX what does this do ? */
2318 #ifndef MONITOR_CONSTANT_DELAY
2319 int jump
= chan
->outsmpl
- chan
->insmpl
- 4 * f
->samples
;
2321 jump
= chan
->outsmpl
- chan
->insmpl
;
2322 if (ast_seekstream(chan
->monitor
->read_stream
, jump
, SEEK_FORCECUR
) == -1)
2323 ast_log(LOG_WARNING
, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2324 chan
->insmpl
+= jump
+ f
->samples
;
2326 chan
->insmpl
+= f
->samples
;
2328 int jump
= chan
->outsmpl
- chan
->insmpl
;
2329 if (jump
- MONITOR_DELAY
>= 0) {
2330 if (ast_seekstream(chan
->monitor
->read_stream
, jump
- f
->samples
, SEEK_FORCECUR
) == -1)
2331 ast_log(LOG_WARNING
, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2332 chan
->insmpl
+= jump
;
2334 chan
->insmpl
+= f
->samples
;
2336 if (chan
->monitor
->state
== AST_MONITOR_RUNNING
) {
2337 if (ast_writestream(chan
->monitor
->read_stream
, f
) < 0)
2338 ast_log(LOG_WARNING
, "Failed to write data to channel monitor read stream\n");
2342 if (chan
->readtrans
&& (f
= ast_translate(chan
->readtrans
, f
, 1)) == NULL
)
2343 f
= &ast_null_frame
;
2345 /* Run generator sitting on the line if timing device not available
2346 * and synchronous generation of outgoing frames is necessary */
2347 ast_read_generator_actions(chan
, f
);
2350 /* Just pass it on! */
2354 /* Make sure we always return NULL in the future */
2355 chan
->_softhangup
|= AST_SOFTHANGUP_DEV
;
2356 if (chan
->generator
)
2357 ast_deactivate_generator(chan
);
2358 /* We no longer End the CDR here */
2361 /* High bit prints debugging */
2362 if (chan
->fin
& DEBUGCHAN_FLAG
)
2363 ast_frame_dump(chan
->name
, f
, "<<");
2364 chan
->fin
= FRAMECOUNT_INC(chan
->fin
);
2367 ast_channel_unlock(chan
);
2371 int ast_internal_timing_enabled(struct ast_channel
*chan
)
2373 int ret
= ast_opt_internal_timing
&& chan
->timingfd
> -1;
2374 if (option_debug
> 4)
2375 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
);
2379 struct ast_frame
*ast_read(struct ast_channel
*chan
)
2381 return __ast_read(chan
, 0);
2384 struct ast_frame
*ast_read_noaudio(struct ast_channel
*chan
)
2386 return __ast_read(chan
, 1);
2389 int ast_indicate(struct ast_channel
*chan
, int condition
)
2391 return ast_indicate_data(chan
, condition
, NULL
, 0);
2394 int ast_indicate_data(struct ast_channel
*chan
, int condition
, const void *data
, size_t datalen
)
2398 ast_channel_lock(chan
);
2399 /* Stop if we're a zombie or need a soft hangup */
2400 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
)) {
2401 ast_channel_unlock(chan
);
2404 if (chan
->tech
->indicate
)
2405 res
= chan
->tech
->indicate(chan
, condition
, data
, datalen
);
2406 ast_channel_unlock(chan
);
2407 if (!chan
->tech
->indicate
|| res
) {
2409 * Device does not support (that) indication, lets fake
2410 * it by doing our own tone generation. (PM2002)
2413 ast_playtones_stop(chan
);
2415 const struct ind_tone_zone_sound
*ts
= NULL
;
2416 switch (condition
) {
2417 case AST_CONTROL_RINGING
:
2418 ts
= ast_get_indication_tone(chan
->zone
, "ring");
2420 case AST_CONTROL_BUSY
:
2421 ts
= ast_get_indication_tone(chan
->zone
, "busy");
2423 case AST_CONTROL_CONGESTION
:
2424 ts
= ast_get_indication_tone(chan
->zone
, "congestion");
2427 if (ts
&& ts
->data
[0]) {
2429 ast_log(LOG_DEBUG
, "Driver for channel '%s' does not support indication %d, emulating it\n", chan
->name
, condition
);
2430 ast_playtones_start(chan
,0,ts
->data
, 1);
2432 chan
->visible_indication
= condition
;
2433 } else if (condition
== AST_CONTROL_PROGRESS
) {
2434 /* ast_playtones_stop(chan); */
2435 } else if (condition
== AST_CONTROL_PROCEEDING
) {
2436 /* Do nothing, really */
2437 } else if (condition
== AST_CONTROL_HOLD
) {
2438 /* Do nothing.... */
2439 } else if (condition
== AST_CONTROL_UNHOLD
) {
2440 /* Do nothing.... */
2441 } else if (condition
== AST_CONTROL_VIDUPDATE
) {
2442 /* Do nothing.... */
2443 } else if (condition
== AST_CONTROL_SRCUPDATE
) {
2447 ast_log(LOG_WARNING
, "Unable to handle indication %d for '%s'\n", condition
, chan
->name
);
2452 chan
->visible_indication
= condition
;
2457 int ast_recvchar(struct ast_channel
*chan
, int timeout
)
2460 char *buf
= ast_recvtext(chan
, timeout
);
2462 return -1; /* error or timeout */
2463 c
= *(unsigned char *)buf
;
2468 char *ast_recvtext(struct ast_channel
*chan
, int timeout
)
2474 struct ast_frame
*f
;
2475 if (ast_check_hangup(chan
))
2477 res
= ast_waitfor(chan
, timeout
);
2478 if (res
<= 0) /* timeout or error */
2480 timeout
= res
; /* update timeout */
2483 break; /* no frame */
2484 if (f
->frametype
== AST_FRAME_CONTROL
&& f
->subclass
== AST_CONTROL_HANGUP
)
2485 done
= 1; /* force a break */
2486 else if (f
->frametype
== AST_FRAME_TEXT
) { /* what we want */
2487 buf
= ast_strndup((char *) f
->data
, f
->datalen
); /* dup and break */
2495 int ast_sendtext(struct ast_channel
*chan
, const char *text
)
2498 /* Stop if we're a zombie or need a soft hangup */
2499 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
))
2501 CHECK_BLOCKING(chan
);
2502 if (chan
->tech
->send_text
)
2503 res
= chan
->tech
->send_text(chan
, text
);
2504 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2508 int ast_senddigit_begin(struct ast_channel
*chan
, char digit
)
2510 /* Device does not support DTMF tones, lets fake
2511 * it by doing our own generation. */
2512 static const char* dtmf_tones
[] = {
2531 if (!chan
->tech
->send_digit_begin
)
2534 if (!chan
->tech
->send_digit_begin(chan
, digit
))
2537 if (digit
>= '0' && digit
<='9')
2538 ast_playtones_start(chan
, 0, dtmf_tones
[digit
-'0'], 0);
2539 else if (digit
>= 'A' && digit
<= 'D')
2540 ast_playtones_start(chan
, 0, dtmf_tones
[digit
-'A'+10], 0);
2541 else if (digit
== '*')
2542 ast_playtones_start(chan
, 0, dtmf_tones
[14], 0);
2543 else if (digit
== '#')
2544 ast_playtones_start(chan
, 0, dtmf_tones
[15], 0);
2548 ast_log(LOG_DEBUG
, "Unable to generate DTMF tone '%c' for '%s'\n", digit
, chan
->name
);
2554 int ast_senddigit_end(struct ast_channel
*chan
, char digit
, unsigned int duration
)
2558 if (chan
->tech
->send_digit_end
)
2559 res
= chan
->tech
->send_digit_end(chan
, digit
, duration
);
2561 if (res
&& chan
->generator
)
2562 ast_playtones_stop(chan
);
2567 int ast_senddigit(struct ast_channel
*chan
, char digit
)
2569 if (chan
->tech
->send_digit_begin
) {
2570 ast_senddigit_begin(chan
, digit
);
2571 ast_safe_sleep(chan
, AST_DEFAULT_EMULATE_DTMF_DURATION
);
2574 return ast_senddigit_end(chan
, digit
, AST_DEFAULT_EMULATE_DTMF_DURATION
);
2577 int ast_prod(struct ast_channel
*chan
)
2579 struct ast_frame a
= { AST_FRAME_VOICE
};
2582 /* Send an empty audio frame to get things moving */
2583 if (chan
->_state
!= AST_STATE_UP
) {
2585 ast_log(LOG_DEBUG
, "Prodding channel '%s'\n", chan
->name
);
2586 a
.subclass
= chan
->rawwriteformat
;
2587 a
.data
= nothing
+ AST_FRIENDLY_OFFSET
;
2589 if (ast_write(chan
, &a
))
2590 ast_log(LOG_WARNING
, "Prodding channel '%s' failed\n", chan
->name
);
2595 int ast_write_video(struct ast_channel
*chan
, struct ast_frame
*fr
)
2598 if (!chan
->tech
->write_video
)
2600 res
= ast_write(chan
, fr
);
2606 int ast_write(struct ast_channel
*chan
, struct ast_frame
*fr
)
2610 struct ast_frame
*f
= NULL
, *f2
= NULL
;
2612 /*Deadlock avoidance*/
2613 while(ast_channel_trylock(chan
)) {
2614 /*cannot goto done since the channel is not locked*/
2617 ast_log(LOG_DEBUG
, "Deadlock avoided for write to channel '%s'\n", chan
->name
);
2622 /* Stop if we're a zombie or need a soft hangup */
2623 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
))
2626 /* Handle any pending masquerades */
2627 if (chan
->masq
&& ast_do_masquerade(chan
)) {
2628 ast_log(LOG_WARNING
, "Failed to perform masquerade\n");
2632 res
= 0; /* XXX explain, why 0 ? */
2635 if (chan
->generatordata
) {
2636 if (ast_test_flag(chan
, AST_FLAG_WRITE_INT
))
2637 ast_deactivate_generator(chan
);
2639 if (fr
->frametype
== AST_FRAME_DTMF_END
) {
2640 /* There is a generator running while we're in the middle of a digit.
2641 * It's probably inband DTMF, so go ahead and pass it so it can
2642 * stop the generator */
2643 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2644 ast_channel_unlock(chan
);
2645 res
= ast_senddigit_end(chan
, fr
->subclass
, fr
->len
);
2646 ast_channel_lock(chan
);
2647 CHECK_BLOCKING(chan
);
2648 } else if (fr
->frametype
== AST_FRAME_CONTROL
&& fr
->subclass
== AST_CONTROL_UNHOLD
) {
2649 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
2650 res
= (chan
->tech
->indicate
== NULL
) ? 0 :
2651 chan
->tech
->indicate(chan
, fr
->subclass
, fr
->data
, fr
->datalen
);
2653 res
= 0; /* XXX explain, why 0 ? */
2657 /* High bit prints debugging */
2658 if (chan
->fout
& DEBUGCHAN_FLAG
)
2659 ast_frame_dump(chan
->name
, fr
, ">>");
2660 CHECK_BLOCKING(chan
);
2661 switch(fr
->frametype
) {
2662 case AST_FRAME_CONTROL
:
2663 res
= (chan
->tech
->indicate
== NULL
) ? 0 :
2664 chan
->tech
->indicate(chan
, fr
->subclass
, fr
->data
, fr
->datalen
);
2666 case AST_FRAME_DTMF_BEGIN
:
2667 if (chan
->audiohooks
) {
2668 struct ast_frame
*old_frame
= fr
;
2669 fr
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_WRITE
, fr
);
2670 if (old_frame
!= fr
)
2673 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2674 ast_channel_unlock(chan
);
2675 res
= ast_senddigit_begin(chan
, fr
->subclass
);
2676 ast_channel_lock(chan
);
2677 CHECK_BLOCKING(chan
);
2679 case AST_FRAME_DTMF_END
:
2680 if (chan
->audiohooks
) {
2681 struct ast_frame
*old_frame
= fr
;
2682 fr
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_WRITE
, fr
);
2683 if (old_frame
!= fr
)
2686 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2687 ast_channel_unlock(chan
);
2688 res
= ast_senddigit_end(chan
, fr
->subclass
, fr
->len
);
2689 ast_channel_lock(chan
);
2690 CHECK_BLOCKING(chan
);
2692 case AST_FRAME_TEXT
:
2693 res
= (chan
->tech
->send_text
== NULL
) ? 0 :
2694 chan
->tech
->send_text(chan
, (char *) fr
->data
);
2696 case AST_FRAME_HTML
:
2697 res
= (chan
->tech
->send_html
== NULL
) ? 0 :
2698 chan
->tech
->send_html(chan
, fr
->subclass
, (char *) fr
->data
, fr
->datalen
);
2700 case AST_FRAME_VIDEO
:
2701 /* XXX Handle translation of video codecs one day XXX */
2702 res
= (chan
->tech
->write_video
== NULL
) ? 0 :
2703 chan
->tech
->write_video(chan
, fr
);
2705 case AST_FRAME_MODEM
:
2706 res
= (chan
->tech
->write
== NULL
) ? 0 :
2707 chan
->tech
->write(chan
, fr
);
2709 case AST_FRAME_VOICE
:
2710 if (chan
->tech
->write
== NULL
)
2711 break; /*! \todo XXX should return 0 maybe ? */
2713 if (chan
->audiohooks
) {
2714 struct ast_frame
*old_frame
= fr
;
2715 fr
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_WRITE
, fr
);
2716 if (old_frame
!= fr
)
2720 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
2721 if (fr
->subclass
== chan
->rawwriteformat
)
2724 f
= (chan
->writetrans
) ? ast_translate(chan
->writetrans
, fr
, 0) : fr
;
2726 /* If we have no frame of audio, then we have to bail out */
2732 /* If Monitor is running on this channel, then we have to write frames out there too */
2733 if (chan
->monitor
&& chan
->monitor
->write_stream
) {
2734 /* XXX must explain this code */
2735 #ifndef MONITOR_CONSTANT_DELAY
2736 int jump
= chan
->insmpl
- chan
->outsmpl
- 4 * f
->samples
;
2738 jump
= chan
->insmpl
- chan
->outsmpl
;
2739 if (ast_seekstream(chan
->monitor
->write_stream
, jump
, SEEK_FORCECUR
) == -1)
2740 ast_log(LOG_WARNING
, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2741 chan
->outsmpl
+= jump
+ f
->samples
;
2743 chan
->outsmpl
+= f
->samples
;
2745 int jump
= chan
->insmpl
- chan
->outsmpl
;
2746 if (jump
- MONITOR_DELAY
>= 0) {
2747 if (ast_seekstream(chan
->monitor
->write_stream
, jump
- f
->samples
, SEEK_FORCECUR
) == -1)
2748 ast_log(LOG_WARNING
, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2749 chan
->outsmpl
+= jump
;
2751 chan
->outsmpl
+= f
->samples
;
2753 if (chan
->monitor
->state
== AST_MONITOR_RUNNING
) {
2754 if (ast_writestream(chan
->monitor
->write_stream
, f
) < 0)
2755 ast_log(LOG_WARNING
, "Failed to write data to channel monitor write stream\n");
2760 res
= chan
->tech
->write(chan
,f
);
2764 case AST_FRAME_NULL
:
2770 /* At this point, fr is the incoming frame and f is NULL. Channels do
2771 * not expect to get NULL as a frame pointer and will segfault. Hence,
2772 * we output the original frame passed in. */
2773 res
= chan
->tech
->write(chan
, fr
);
2781 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2782 /* Consider a write failure to force a soft hangup */
2784 chan
->_softhangup
|= AST_SOFTHANGUP_DEV
;
2786 chan
->fout
= FRAMECOUNT_INC(chan
->fout
);
2789 ast_channel_unlock(chan
);
2793 static int set_format(struct ast_channel
*chan
, int fmt
, int *rawformat
, int *format
,
2794 struct ast_trans_pvt
**trans
, const int direction
)
2798 char from
[200], to
[200];
2800 /* Make sure we only consider audio */
2801 fmt
&= AST_FORMAT_AUDIO_MASK
;
2803 native
= chan
->nativeformats
;
2804 /* Find a translation path from the native format to one of the desired formats */
2807 res
= ast_translator_best_choice(&fmt
, &native
);
2810 res
= ast_translator_best_choice(&native
, &fmt
);
2813 ast_log(LOG_WARNING
, "Unable to find a codec translation path from %s to %s\n",
2814 ast_getformatname_multiple(from
, sizeof(from
), native
),
2815 ast_getformatname_multiple(to
, sizeof(to
), fmt
));
2819 /* Now we have a good choice for both. */
2820 ast_channel_lock(chan
);
2822 if ((*rawformat
== native
) && (*format
== fmt
) && ((*rawformat
== *format
) || (*trans
))) {
2823 /* the channel is already in these formats, so nothing to do */
2824 ast_channel_unlock(chan
);
2828 *rawformat
= native
;
2829 /* User perspective is fmt */
2831 /* Free any read translation we have right now */
2833 ast_translator_free_path(*trans
);
2834 /* Build a translation path from the raw format to the desired format */
2837 *trans
= ast_translator_build_path(*format
, *rawformat
);
2840 *trans
= ast_translator_build_path(*rawformat
, *format
);
2841 ast_channel_unlock(chan
);
2843 ast_log(LOG_DEBUG
, "Set channel %s to %s format %s\n", chan
->name
,
2844 direction
? "write" : "read", ast_getformatname(fmt
));
2848 int ast_set_read_format(struct ast_channel
*chan
, int fmt
)
2850 return set_format(chan
, fmt
, &chan
->rawreadformat
, &chan
->readformat
,
2851 &chan
->readtrans
, 0);
2854 int ast_set_write_format(struct ast_channel
*chan
, int fmt
)
2856 return set_format(chan
, fmt
, &chan
->rawwriteformat
, &chan
->writeformat
,
2857 &chan
->writetrans
, 1);
2860 char *ast_channel_reason2str(int reason
)
2862 switch (reason
) /* the following appear to be the only ones actually returned by request_and_dial */
2865 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
2866 case AST_CONTROL_HANGUP
:
2868 case AST_CONTROL_RING
:
2869 return "Local Ring";
2870 case AST_CONTROL_RINGING
:
2871 return "Remote end Ringing";
2872 case AST_CONTROL_ANSWER
:
2873 return "Remote end has Answered";
2874 case AST_CONTROL_BUSY
:
2875 return "Remote end is Busy";
2876 case AST_CONTROL_CONGESTION
:
2877 return "Congestion (circuits busy)";
2879 return "Unknown Reason!!";
2883 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
)
2887 struct ast_channel
*chan
;
2889 int last_subclass
= 0;
2894 outstate
= &dummy_outstate
; /* make outstate always a valid pointer */
2896 chan
= ast_request(type
, format
, data
, &cause
);
2898 ast_log(LOG_NOTICE
, "Unable to request channel %s/%s\n", type
, (char *)data
);
2899 /* compute error and return */
2900 if (cause
== AST_CAUSE_BUSY
)
2901 *outstate
= AST_CONTROL_BUSY
;
2902 else if (cause
== AST_CAUSE_CONGESTION
)
2903 *outstate
= AST_CONTROL_CONGESTION
;
2909 ast_set_variables(chan
, oh
->vars
);
2910 /* XXX why is this necessary, for the parent_channel perhaps ? */
2911 if (!ast_strlen_zero(oh
->cid_num
) && !ast_strlen_zero(oh
->cid_name
))
2912 ast_set_callerid(chan
, oh
->cid_num
, oh
->cid_name
, oh
->cid_num
);
2913 if (oh
->parent_channel
)
2914 ast_channel_inherit_variables(oh
->parent_channel
, chan
);
2916 ast_cdr_setaccount(chan
, oh
->account
);
2918 ast_set_callerid(chan
, cid_num
, cid_name
, cid_num
);
2920 if (ast_call(chan
, data
, 0)) { /* ast_call failed... */
2921 ast_log(LOG_NOTICE
, "Unable to call channel %s/%s\n", type
, (char *)data
);
2923 res
= 1; /* mark success in case chan->_state is already AST_STATE_UP */
2924 while (timeout
&& chan
->_state
!= AST_STATE_UP
) {
2925 struct ast_frame
*f
;
2926 res
= ast_waitfor(chan
, timeout
);
2927 if (res
<= 0) /* error, timeout, or done */
2933 *outstate
= AST_CONTROL_HANGUP
;
2937 if (f
->frametype
== AST_FRAME_CONTROL
) {
2938 switch (f
->subclass
) {
2939 case AST_CONTROL_RINGING
: /* record but keep going */
2940 *outstate
= f
->subclass
;
2943 case AST_CONTROL_BUSY
:
2944 case AST_CONTROL_CONGESTION
:
2945 case AST_CONTROL_ANSWER
:
2946 *outstate
= f
->subclass
;
2947 timeout
= 0; /* trick to force exit from the while() */
2951 case AST_CONTROL_PROGRESS
:
2952 case AST_CONTROL_PROCEEDING
:
2953 case AST_CONTROL_HOLD
:
2954 case AST_CONTROL_UNHOLD
:
2955 case AST_CONTROL_VIDUPDATE
:
2956 case AST_CONTROL_SRCUPDATE
:
2957 case -1: /* Ignore -- just stopping indications */
2961 ast_log(LOG_NOTICE
, "Don't know what to do with control frame %d\n", f
->subclass
);
2963 last_subclass
= f
->subclass
;
2971 if (!ast_strlen_zero(oh
->context
))
2972 ast_copy_string(chan
->context
, oh
->context
, sizeof(chan
->context
));
2973 if (!ast_strlen_zero(oh
->exten
))
2974 ast_copy_string(chan
->exten
, oh
->exten
, sizeof(chan
->exten
));
2976 chan
->priority
= oh
->priority
;
2978 if (chan
->_state
== AST_STATE_UP
)
2979 *outstate
= AST_CONTROL_ANSWER
;
2982 if ( AST_CONTROL_RINGING
== last_subclass
)
2983 chan
->hangupcause
= AST_CAUSE_NO_ANSWER
;
2984 if (!chan
->cdr
&& (chan
->cdr
= ast_cdr_alloc()))
2985 ast_cdr_init(chan
->cdr
, chan
);
2988 snprintf(tmp
, sizeof(tmp
), "%s/%s", type
, (char *)data
);
2989 ast_cdr_setapp(chan
->cdr
,"Dial",tmp
);
2990 ast_cdr_update(chan
);
2991 ast_cdr_start(chan
->cdr
);
2992 ast_cdr_end(chan
->cdr
);
2993 /* If the cause wasn't handled properly */
2994 if (ast_cdr_disposition(chan
->cdr
,chan
->hangupcause
))
2995 ast_cdr_failed(chan
->cdr
);
3003 struct ast_channel
*ast_request_and_dial(const char *type
, int format
, void *data
, int timeout
, int *outstate
, const char *cidnum
, const char *cidname
)
3005 return __ast_request_and_dial(type
, format
, data
, timeout
, outstate
, cidnum
, cidname
, NULL
);
3008 struct ast_channel
*ast_request(const char *type
, int format
, void *data
, int *cause
)
3010 struct chanlist
*chan
;
3011 struct ast_channel
*c
;
3016 int videoformat
= format
& AST_FORMAT_VIDEO_MASK
;
3020 *cause
= AST_CAUSE_NOTDEFINED
;
3022 if (AST_LIST_LOCK(&channels
)) {
3023 ast_log(LOG_WARNING
, "Unable to lock channel list\n");
3027 AST_LIST_TRAVERSE(&backends
, chan
, list
) {
3028 if (strcasecmp(type
, chan
->tech
->type
))
3031 capabilities
= chan
->tech
->capabilities
;
3032 fmt
= format
& AST_FORMAT_AUDIO_MASK
;
3033 res
= ast_translator_best_choice(&fmt
, &capabilities
);
3035 ast_log(LOG_WARNING
, "No translator path exists for channel type %s (native %d) to %d\n", type
, chan
->tech
->capabilities
, format
);
3036 *cause
= AST_CAUSE_BEARERCAPABILITY_NOTAVAIL
;
3037 AST_LIST_UNLOCK(&channels
);
3040 AST_LIST_UNLOCK(&channels
);
3041 if (!chan
->tech
->requester
)
3044 if (!(c
= chan
->tech
->requester(type
, capabilities
| videoformat
, data
, cause
)))
3047 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
3051 ast_log(LOG_WARNING
, "No channel type registered for '%s'\n", type
);
3052 *cause
= AST_CAUSE_NOSUCHDRIVER
;
3053 AST_LIST_UNLOCK(&channels
);
3058 int ast_call(struct ast_channel
*chan
, char *addr
, int timeout
)
3060 /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
3061 If the remote end does not answer within the timeout, then do NOT hang up, but
3064 /* Stop if we're a zombie or need a soft hangup */
3065 ast_channel_lock(chan
);
3066 if (!ast_test_flag(chan
, AST_FLAG_ZOMBIE
) && !ast_check_hangup(chan
)) {
3068 ast_set_flag(chan
->cdr
, AST_CDR_FLAG_DIALED
);
3069 if (chan
->tech
->call
)
3070 res
= chan
->tech
->call(chan
, addr
, timeout
);
3071 ast_set_flag(chan
, AST_FLAG_OUTGOING
);
3073 ast_channel_unlock(chan
);
3078 \brief Transfer a call to dest, if the channel supports transfer
3082 \arg the manager interface
3084 int ast_transfer(struct ast_channel
*chan
, char *dest
)
3088 /* Stop if we're a zombie or need a soft hangup */
3089 ast_channel_lock(chan
);
3090 if (!ast_test_flag(chan
, AST_FLAG_ZOMBIE
) && !ast_check_hangup(chan
)) {
3091 if (chan
->tech
->transfer
) {
3092 res
= chan
->tech
->transfer(chan
, dest
);
3098 ast_channel_unlock(chan
);
3102 int ast_readstring(struct ast_channel
*c
, char *s
, int len
, int timeout
, int ftimeout
, char *enders
)
3104 return ast_readstring_full(c
, s
, len
, timeout
, ftimeout
, enders
, -1, -1);
3107 int ast_readstring_full(struct ast_channel
*c
, char *s
, int len
, int timeout
, int ftimeout
, char *enders
, int audiofd
, int ctrlfd
)
3109 int pos
= 0; /* index in the buffer where we accumulate digits */
3112 /* Stop if we're a zombie or need a soft hangup */
3113 if (ast_test_flag(c
, AST_FLAG_ZOMBIE
) || ast_check_hangup(c
))
3120 d
= ast_waitstream_full(c
, AST_DIGIT_ANY
, audiofd
, ctrlfd
);
3124 d
= ast_waitfordigit_full(c
, to
, audiofd
, ctrlfd
);
3126 d
= ast_waitfordigit_full(c
, to
, audiofd
, ctrlfd
);
3138 if (!strchr(enders
, d
))
3140 if (strchr(enders
, d
) || (pos
>= len
)) {
3150 int ast_channel_supports_html(struct ast_channel
*chan
)
3152 return (chan
->tech
->send_html
) ? 1 : 0;
3155 int ast_channel_sendhtml(struct ast_channel
*chan
, int subclass
, const char *data
, int datalen
)
3157 if (chan
->tech
->send_html
)
3158 return chan
->tech
->send_html(chan
, subclass
, data
, datalen
);
3162 int ast_channel_sendurl(struct ast_channel
*chan
, const char *url
)
3164 return ast_channel_sendhtml(chan
, AST_HTML_URL
, url
, strlen(url
) + 1);
3167 int ast_channel_make_compatible(struct ast_channel
*chan
, struct ast_channel
*peer
)
3172 if (chan
->readformat
== peer
->writeformat
&& chan
->writeformat
== peer
->readformat
) {
3173 /* Already compatible! Moving on ... */
3177 /* Set up translation from the chan to the peer */
3178 src
= chan
->nativeformats
;
3179 dst
= peer
->nativeformats
;
3180 if (ast_translator_best_choice(&dst
, &src
) < 0) {
3181 ast_log(LOG_WARNING
, "No path to translate from %s(%d) to %s(%d)\n", chan
->name
, src
, peer
->name
, dst
);
3185 /* if the best path is not 'pass through', then
3186 transcoding is needed; if desired, force transcode path
3187 to use SLINEAR between channels, but only if there is
3188 no direct conversion available */
3189 if ((src
!= dst
) && ast_opt_transcode_via_slin
&&
3190 (ast_translate_path_steps(dst
, src
) != 1))
3191 dst
= AST_FORMAT_SLINEAR
;
3192 if (ast_set_read_format(chan
, dst
) < 0) {
3193 ast_log(LOG_WARNING
, "Unable to set read format on channel %s to %d\n", chan
->name
, dst
);
3196 if (ast_set_write_format(peer
, dst
) < 0) {
3197 ast_log(LOG_WARNING
, "Unable to set write format on channel %s to %d\n", peer
->name
, dst
);
3201 /* Set up translation from the peer to the chan */
3202 src
= peer
->nativeformats
;
3203 dst
= chan
->nativeformats
;
3204 if (ast_translator_best_choice(&dst
, &src
) < 0) {
3205 ast_log(LOG_WARNING
, "No path to translate from %s(%d) to %s(%d)\n", peer
->name
, src
, chan
->name
, dst
);
3209 /* if the best path is not 'pass through', then
3210 transcoding is needed; if desired, force transcode path
3211 to use SLINEAR between channels, but only if there is
3212 no direct conversion available */
3213 if ((src
!= dst
) && ast_opt_transcode_via_slin
&&
3214 (ast_translate_path_steps(dst
, src
) != 1))
3215 dst
= AST_FORMAT_SLINEAR
;
3216 if (ast_set_read_format(peer
, dst
) < 0) {
3217 ast_log(LOG_WARNING
, "Unable to set read format on channel %s to %d\n", peer
->name
, dst
);
3220 if (ast_set_write_format(chan
, dst
) < 0) {
3221 ast_log(LOG_WARNING
, "Unable to set write format on channel %s to %d\n", chan
->name
, dst
);
3227 int ast_channel_masquerade(struct ast_channel
*original
, struct ast_channel
*clone
)
3230 struct ast_channel
*final_orig
, *final_clone
, *base
;
3233 final_orig
= original
;
3234 final_clone
= clone
;
3236 ast_channel_lock(original
);
3237 while (ast_channel_trylock(clone
)) {
3238 ast_channel_unlock(original
);
3240 ast_channel_lock(original
);
3243 /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent)
3244 and if so, we don't really want to masquerade it, but its proxy */
3245 if (original
->_bridge
&& (original
->_bridge
!= ast_bridged_channel(original
)) && (original
->_bridge
->_bridge
!= original
))
3246 final_orig
= original
->_bridge
;
3248 if (clone
->_bridge
&& (clone
->_bridge
!= ast_bridged_channel(clone
)) && (clone
->_bridge
->_bridge
!= clone
))
3249 final_clone
= clone
->_bridge
;
3251 if (final_clone
->tech
->get_base_channel
&& (base
= final_clone
->tech
->get_base_channel(final_clone
))) {
3255 if ((final_orig
!= original
) || (final_clone
!= clone
)) {
3256 /* Lots and lots of deadlock avoidance. The main one we're competing with
3257 * is ast_write(), which locks channels recursively, when working with a
3259 if (ast_channel_trylock(final_orig
)) {
3260 ast_channel_unlock(clone
);
3261 ast_channel_unlock(original
);
3264 if (ast_channel_trylock(final_clone
)) {
3265 ast_channel_unlock(final_orig
);
3266 ast_channel_unlock(clone
);
3267 ast_channel_unlock(original
);
3270 ast_channel_unlock(clone
);
3271 ast_channel_unlock(original
);
3272 original
= final_orig
;
3273 clone
= final_clone
;
3276 if (original
== clone
) {
3277 ast_log(LOG_WARNING
, "Can't masquerade channel '%s' into itself!\n", original
->name
);
3278 ast_channel_unlock(clone
);
3279 ast_channel_unlock(original
);
3284 ast_log(LOG_DEBUG
, "Planning to masquerade channel %s into the structure of %s\n",
3285 clone
->name
, original
->name
);
3286 if (original
->masq
) {
3287 ast_log(LOG_WARNING
, "%s is already going to masquerade as %s\n",
3288 original
->masq
->name
, original
->name
);
3289 } else if (clone
->masqr
) {
3290 ast_log(LOG_WARNING
, "%s is already going to masquerade as %s\n",
3291 clone
->name
, clone
->masqr
->name
);
3293 original
->masq
= clone
;
3294 clone
->masqr
= original
;
3295 ast_queue_frame(original
, &ast_null_frame
);
3296 ast_queue_frame(clone
, &ast_null_frame
);
3298 ast_log(LOG_DEBUG
, "Done planning to masquerade channel %s into the structure of %s\n", clone
->name
, original
->name
);
3302 ast_channel_unlock(clone
);
3303 ast_channel_unlock(original
);
3308 void ast_change_name(struct ast_channel
*chan
, char *newname
)
3310 manager_event(EVENT_FLAG_CALL
, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan
->name
, newname
, chan
->uniqueid
);
3311 ast_string_field_set(chan
, name
, newname
);
3314 void ast_channel_inherit_variables(const struct ast_channel
*parent
, struct ast_channel
*child
)
3316 struct ast_var_t
*current
, *newvar
;
3317 const char *varname
;
3319 AST_LIST_TRAVERSE(&parent
->varshead
, current
, entries
) {
3322 varname
= ast_var_full_name(current
);
3326 if (varname
[0] == '_') {
3328 if (varname
[1] == '_')
3334 newvar
= ast_var_assign(&varname
[1], ast_var_value(current
));
3336 AST_LIST_INSERT_TAIL(&child
->varshead
, newvar
, entries
);
3338 ast_log(LOG_DEBUG
, "Copying soft-transferable variable %s.\n", ast_var_name(newvar
));
3342 newvar
= ast_var_assign(ast_var_full_name(current
), ast_var_value(current
));
3344 AST_LIST_INSERT_TAIL(&child
->varshead
, newvar
, entries
);
3346 ast_log(LOG_DEBUG
, "Copying hard-transferable variable %s.\n", ast_var_name(newvar
));
3351 ast_log(LOG_DEBUG
, "Not copying variable %s.\n", ast_var_name(current
));
3358 \brief Clone channel variables from 'clone' channel into 'original' channel
3360 All variables except those related to app_groupcount are cloned.
3361 Variables are actually _removed_ from 'clone' channel, presumably
3362 because it will subsequently be destroyed.
3364 \note Assumes locks will be in place on both channels when called.
3366 static void clone_variables(struct ast_channel
*original
, struct ast_channel
*clone
)
3368 struct ast_var_t
*current
, *newvar
;
3369 /* Append variables from clone channel into original channel */
3370 /* XXX Is this always correct? We have to in order to keep MACROS working XXX */
3371 if (AST_LIST_FIRST(&clone
->varshead
))
3372 AST_LIST_APPEND_LIST(&original
->varshead
, &clone
->varshead
, entries
);
3374 /* then, dup the varshead list into the clone */
3376 AST_LIST_TRAVERSE(&original
->varshead
, current
, entries
) {
3377 newvar
= ast_var_assign(current
->name
, current
->value
);
3379 AST_LIST_INSERT_TAIL(&clone
->varshead
, newvar
, entries
);
3384 \brief Masquerade a channel
3386 \note Assumes channel will be locked when called
3388 int ast_do_masquerade(struct ast_channel
*original
)
3393 struct ast_frame
*cur
;
3394 const struct ast_channel_tech
*t
;
3396 struct ast_callerid tmpcid
;
3397 struct ast_channel
*clone
= original
->masq
;
3398 struct ast_cdr
*cdr
;
3399 int rformat
= original
->readformat
;
3400 int wformat
= original
->writeformat
;
3406 if (option_debug
> 3)
3407 ast_log(LOG_DEBUG
, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
3408 clone
->name
, clone
->_state
, original
->name
, original
->_state
);
3410 /* XXX This is a seriously wacked out operation. We're essentially putting the guts of
3411 the clone channel into the original channel. Start by killing off the original
3412 channel's backend. I'm not sure we're going to keep this function, because
3413 while the features are nice, the cost is very high in terms of pure nastiness. XXX */
3415 /* We need the clone's lock, too */
3416 ast_channel_lock(clone
);
3418 if (option_debug
> 1)
3419 ast_log(LOG_DEBUG
, "Got clone lock for masquerade on '%s' at %p\n", clone
->name
, &clone
->lock
);
3421 /* Having remembered the original read/write formats, we turn off any translation on either
3423 free_translation(clone
);
3424 free_translation(original
);
3427 /* Unlink the masquerade */
3428 original
->masq
= NULL
;
3429 clone
->masqr
= NULL
;
3431 /* Save the original name */
3432 ast_copy_string(orig
, original
->name
, sizeof(orig
));
3433 /* Save the new name */
3434 ast_copy_string(newn
, clone
->name
, sizeof(newn
));
3435 /* Create the masq name */
3436 snprintf(masqn
, sizeof(masqn
), "%s<MASQ>", newn
);
3438 /* Copy the name from the clone channel */
3439 ast_string_field_set(original
, name
, newn
);
3441 /* Mangle the name of the clone channel */
3442 ast_string_field_set(clone
, name
, masqn
);
3444 /* Notify any managers of the change, first the masq then the other */
3445 manager_event(EVENT_FLAG_CALL
, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", newn
, masqn
, clone
->uniqueid
);
3446 manager_event(EVENT_FLAG_CALL
, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", orig
, newn
, original
->uniqueid
);
3448 /* Swap the technologies */
3450 original
->tech
= clone
->tech
;
3454 cdr
= original
->cdr
;
3455 original
->cdr
= clone
->cdr
;
3458 t_pvt
= original
->tech_pvt
;
3459 original
->tech_pvt
= clone
->tech_pvt
;
3460 clone
->tech_pvt
= t_pvt
;
3462 /* Swap the alertpipes */
3463 for (i
= 0; i
< 2; i
++) {
3464 x
= original
->alertpipe
[i
];
3465 original
->alertpipe
[i
] = clone
->alertpipe
[i
];
3466 clone
->alertpipe
[i
] = x
;
3470 * Swap the readq's. The end result should be this:
3472 * 1) All frames should be on the new (original) channel.
3473 * 2) Any frames that were already on the new channel before this
3474 * masquerade need to be at the end of the readq, after all of the
3475 * frames on the old (clone) channel.
3476 * 3) The alertpipe needs to get poked for every frame that was already
3477 * on the new channel, since we are now using the alert pipe from the
3478 * old (clone) channel.
3481 AST_LIST_HEAD_NOLOCK(, ast_frame
) tmp_readq
;
3482 AST_LIST_HEAD_SET_NOLOCK(&tmp_readq
, NULL
);
3484 AST_LIST_APPEND_LIST(&tmp_readq
, &original
->readq
, frame_list
);
3485 AST_LIST_APPEND_LIST(&original
->readq
, &clone
->readq
, frame_list
);
3487 while ((cur
= AST_LIST_REMOVE_HEAD(&tmp_readq
, frame_list
))) {
3488 AST_LIST_INSERT_TAIL(&original
->readq
, cur
, frame_list
);
3489 if (original
->alertpipe
[1] > -1) {
3491 write(original
->alertpipe
[1], &poke
, sizeof(poke
));
3496 /* Swap the raw formats */
3497 x
= original
->rawreadformat
;
3498 original
->rawreadformat
= clone
->rawreadformat
;
3499 clone
->rawreadformat
= x
;
3500 x
= original
->rawwriteformat
;
3501 original
->rawwriteformat
= clone
->rawwriteformat
;
3502 clone
->rawwriteformat
= x
;
3504 clone
->_softhangup
= AST_SOFTHANGUP_DEV
;
3506 /* And of course, so does our current state. Note we need not
3507 call ast_setstate since the event manager doesn't really consider
3508 these separate. We do this early so that the clone has the proper
3509 state of the original channel. */
3510 origstate
= original
->_state
;
3511 original
->_state
= clone
->_state
;
3512 clone
->_state
= origstate
;
3514 if (clone
->tech
->fixup
){
3515 res
= clone
->tech
->fixup(original
, clone
);
3517 ast_log(LOG_WARNING
, "Fixup failed on channel %s, strange things may happen.\n", clone
->name
);
3520 /* Start by disconnecting the original's physical side */
3521 if (clone
->tech
->hangup
)
3522 res
= clone
->tech
->hangup(clone
);
3524 ast_log(LOG_WARNING
, "Hangup failed! Strange things may happen!\n");
3525 ast_channel_unlock(clone
);
3529 snprintf(zombn
, sizeof(zombn
), "%s<ZOMBIE>", orig
);
3530 /* Mangle the name of the clone channel */
3531 ast_string_field_set(clone
, name
, zombn
);
3532 manager_event(EVENT_FLAG_CALL
, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", masqn
, zombn
, clone
->uniqueid
);
3534 /* Update the type. */
3535 t_pvt
= original
->monitor
;
3536 original
->monitor
= clone
->monitor
;
3537 clone
->monitor
= t_pvt
;
3539 /* Keep the same language. */
3540 ast_string_field_set(original
, language
, clone
->language
);
3541 /* Copy the FD's other than the generator fd */
3542 for (x
= 0; x
< AST_MAX_FDS
; x
++) {
3543 if (x
!= AST_GENERATOR_FD
)
3544 original
->fds
[x
] = clone
->fds
[x
];
3547 ast_app_group_update(clone
, original
);
3548 /* Move data stores over */
3549 if (AST_LIST_FIRST(&clone
->datastores
)) {
3550 struct ast_datastore
*ds
;
3551 AST_LIST_APPEND_LIST(&original
->datastores
, &clone
->datastores
, entry
);
3552 AST_LIST_TRAVERSE(&original
->datastores
, ds
, entry
) {
3553 if (ds
->info
->chan_fixup
)
3554 ds
->info
->chan_fixup(ds
->data
, clone
, original
);
3558 clone_variables(original
, clone
);
3559 /* Presense of ADSI capable CPE follows clone */
3560 original
->adsicpe
= clone
->adsicpe
;
3561 /* Bridge remains the same */
3562 /* CDR fields remain the same */
3563 /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */
3564 /* Application and data remain the same */
3565 /* Clone exception becomes real one, as with fdno */
3566 ast_copy_flags(original
, clone
, AST_FLAG_EXCEPTION
);
3567 original
->fdno
= clone
->fdno
;
3568 /* Schedule context remains the same */
3569 /* Stream stuff stays the same */
3570 /* Keep the original state. The fixup code will need to work with it most likely */
3572 /* Just swap the whole structures, nevermind the allocations, they'll work themselves
3574 tmpcid
= original
->cid
;
3575 original
->cid
= clone
->cid
;
3576 clone
->cid
= tmpcid
;
3578 /* Restore original timing file descriptor */
3579 original
->fds
[AST_TIMING_FD
] = original
->timingfd
;
3581 /* Our native formats are different now */
3582 original
->nativeformats
= clone
->nativeformats
;
3584 /* Context, extension, priority, app data, jump table, remain the same */
3585 /* pvt switches. pbx stays the same, as does next */
3587 /* Set the write format */
3588 ast_set_write_format(original
, wformat
);
3590 /* Set the read format */
3591 ast_set_read_format(original
, rformat
);
3593 /* Copy the music class */
3594 ast_string_field_set(original
, musicclass
, clone
->musicclass
);
3597 ast_log(LOG_DEBUG
, "Putting channel %s in %d/%d formats\n", original
->name
, wformat
, rformat
);
3599 /* Okay. Last thing is to let the channel driver know about all this mess, so he
3600 can fix up everything as best as possible */
3601 if (original
->tech
->fixup
) {
3602 res
= original
->tech
->fixup(clone
, original
);
3604 ast_log(LOG_WARNING
, "Channel for type '%s' could not fixup channel %s\n",
3605 original
->tech
->type
, original
->name
);
3606 ast_channel_unlock(clone
);
3610 ast_log(LOG_WARNING
, "Channel type '%s' does not have a fixup routine (for %s)! Bad things may happen.\n",
3611 original
->tech
->type
, original
->name
);
3613 /* If an indication is currently playing maintain it on the channel that is taking the place of original */
3614 if (original
->visible_indication
)
3615 ast_indicate(original
, original
->visible_indication
);
3617 /* Now, at this point, the "clone" channel is totally F'd up. We mark it as
3618 a zombie so nothing tries to touch it. If it's already been marked as a
3619 zombie, then free it now (since it already is considered invalid). */
3620 if (ast_test_flag(clone
, AST_FLAG_ZOMBIE
)) {
3622 ast_log(LOG_DEBUG
, "Destroying channel clone '%s'\n", clone
->name
);
3623 ast_channel_unlock(clone
);
3624 manager_event(EVENT_FLAG_CALL
, "Hangup",
3628 "Cause-txt: %s\r\n",
3632 ast_cause2str(clone
->hangupcause
)
3634 ast_channel_free(clone
);
3637 ast_log(LOG_DEBUG
, "Released clone lock on '%s'\n", clone
->name
);
3638 ast_set_flag(clone
, AST_FLAG_ZOMBIE
);
3639 ast_queue_frame(clone
, &ast_null_frame
);
3640 ast_channel_unlock(clone
);
3643 /* Signal any blocker */
3644 if (ast_test_flag(original
, AST_FLAG_BLOCKING
))
3645 pthread_kill(original
->blocker
, SIGURG
);
3647 ast_log(LOG_DEBUG
, "Done Masquerading %s (%d)\n", original
->name
, original
->_state
);
3651 void ast_set_callerid(struct ast_channel
*chan
, const char *callerid
, const char *calleridname
, const char *ani
)
3653 ast_channel_lock(chan
);
3656 if (chan
->cid
.cid_num
)
3657 free(chan
->cid
.cid_num
);
3658 chan
->cid
.cid_num
= ast_strdup(callerid
);
3661 if (chan
->cid
.cid_name
)
3662 free(chan
->cid
.cid_name
);
3663 chan
->cid
.cid_name
= ast_strdup(calleridname
);
3666 if (chan
->cid
.cid_ani
)
3667 free(chan
->cid
.cid_ani
);
3668 chan
->cid
.cid_ani
= ast_strdup(ani
);
3670 manager_event(EVENT_FLAG_CALL
, "Newcallerid",
3673 "CallerIDName: %s\r\n"
3675 "CID-CallingPres: %d (%s)\r\n",
3677 S_OR(chan
->cid
.cid_num
, "<Unknown>"),
3678 S_OR(chan
->cid
.cid_name
, "<Unknown>"),
3681 ast_describe_caller_presentation(chan
->cid
.cid_pres
)
3684 ast_channel_unlock(chan
);
3687 int ast_setstate(struct ast_channel
*chan
, enum ast_channel_state state
)
3689 char name
[AST_CHANNEL_NAME
], *dashptr
;
3690 int oldstate
= chan
->_state
;
3692 if (oldstate
== state
)
3695 ast_copy_string(name
, chan
->name
, sizeof(name
));
3696 if ((dashptr
= strrchr(name
, '-'))) {
3700 chan
->_state
= state
;
3701 ast_device_state_changed_literal(name
);
3702 /* setstate used to conditionally report Newchannel; this is no more */
3703 manager_event(EVENT_FLAG_CALL
,
3708 "CallerIDName: %s\r\n"
3710 chan
->name
, ast_state2str(chan
->_state
),
3711 S_OR(chan
->cid
.cid_num
, "<unknown>"),
3712 S_OR(chan
->cid
.cid_name
, "<unknown>"),
3718 /*! \brief Find bridged channel */
3719 struct ast_channel
*ast_bridged_channel(struct ast_channel
*chan
)
3721 struct ast_channel
*bridged
;
3722 bridged
= chan
->_bridge
;
3723 if (bridged
&& bridged
->tech
->bridged_channel
)
3724 bridged
= bridged
->tech
->bridged_channel(chan
, bridged
);
3728 static void bridge_playfile(struct ast_channel
*chan
, struct ast_channel
*peer
, const char *sound
, int remain
)
3730 int min
= 0, sec
= 0, check
;
3732 check
= ast_autoservice_start(peer
);
3737 if (remain
/ 60 > 1) {
3745 if (!strcmp(sound
,"timeleft")) { /* Queue support */
3746 ast_stream_and_wait(chan
, "vm-youhave", chan
->language
, "");
3748 ast_say_number(chan
, min
, AST_DIGIT_ANY
, chan
->language
, NULL
);
3749 ast_stream_and_wait(chan
, "queue-minutes", chan
->language
, "");
3752 ast_say_number(chan
, sec
, AST_DIGIT_ANY
, chan
->language
, NULL
);
3753 ast_stream_and_wait(chan
, "queue-seconds", chan
->language
, "");
3756 ast_stream_and_wait(chan
, sound
, chan
->language
, "");
3759 ast_autoservice_stop(peer
);
3762 static enum ast_bridge_result
ast_generic_bridge(struct ast_channel
*c0
, struct ast_channel
*c1
,
3763 struct ast_bridge_config
*config
, struct ast_frame
**fo
,
3764 struct ast_channel
**rc
, struct timeval bridge_end
)
3766 /* Copy voice back and forth between the two channels. */
3767 struct ast_channel
*cs
[3];
3768 struct ast_frame
*f
;
3769 enum ast_bridge_result res
= AST_BRIDGE_COMPLETE
;
3770 int o0nativeformats
;
3771 int o1nativeformats
;
3775 /* Indicates whether a frame was queued into a jitterbuffer */
3776 int frame_put_in_jb
= 0;
3782 pvt0
= c0
->tech_pvt
;
3783 pvt1
= c1
->tech_pvt
;
3784 o0nativeformats
= c0
->nativeformats
;
3785 o1nativeformats
= c1
->nativeformats
;
3786 watch_c0_dtmf
= config
->flags
& AST_BRIDGE_DTMF_CHANNEL_0
;
3787 watch_c1_dtmf
= config
->flags
& AST_BRIDGE_DTMF_CHANNEL_1
;
3789 /* Check the need of a jitterbuffer for each channel */
3790 jb_in_use
= ast_jb_do_usecheck(c0
, c1
);
3792 ast_jb_empty_and_reset(c0
, c1
);
3795 struct ast_channel
*who
, *other
;
3797 if ((c0
->tech_pvt
!= pvt0
) || (c1
->tech_pvt
!= pvt1
) ||
3798 (o0nativeformats
!= c0
->nativeformats
) ||
3799 (o1nativeformats
!= c1
->nativeformats
)) {
3800 /* Check for Masquerade, codec changes, etc */
3801 res
= AST_BRIDGE_RETRY
;
3804 if (bridge_end
.tv_sec
) {
3805 to
= ast_tvdiff_ms(bridge_end
, ast_tvnow());
3807 if (config
->timelimit
)
3808 res
= AST_BRIDGE_RETRY
;
3810 res
= AST_BRIDGE_COMPLETE
;
3815 /* Calculate the appropriate max sleep interval - in general, this is the time,
3816 left to the closest jb delivery moment */
3818 to
= ast_jb_get_when_to_wakeup(c0
, c1
, to
);
3819 who
= ast_waitfor_n(cs
, 2, &to
);
3821 /* No frame received within the specified timeout - check if we have to deliver now */
3823 ast_jb_get_and_deliver(c0
, c1
);
3824 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
|| c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
) {
3825 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
3826 c0
->_softhangup
= 0;
3827 if (c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
3828 c1
->_softhangup
= 0;
3839 ast_log(LOG_DEBUG
, "Didn't get a frame from channel: %s\n",who
->name
);
3843 other
= (who
== c0
) ? c1
: c0
; /* the 'other' channel */
3844 /* Try add the frame info the who's bridged channel jitterbuff */
3846 frame_put_in_jb
= !ast_jb_put(other
, f
);
3848 if ((f
->frametype
== AST_FRAME_CONTROL
) && !(config
->flags
& AST_BRIDGE_IGNORE_SIGS
)) {
3849 int bridge_exit
= 0;
3851 switch (f
->subclass
) {
3852 case AST_CONTROL_HOLD
:
3853 case AST_CONTROL_UNHOLD
:
3854 case AST_CONTROL_VIDUPDATE
:
3855 case AST_CONTROL_SRCUPDATE
:
3856 ast_indicate_data(other
, f
->subclass
, f
->data
, f
->datalen
);
3858 ast_jb_empty_and_reset(c0
, c1
);
3866 ast_log(LOG_DEBUG
, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f
->subclass
, who
->name
);
3872 if ((f
->frametype
== AST_FRAME_VOICE
) ||
3873 (f
->frametype
== AST_FRAME_DTMF_BEGIN
) ||
3874 (f
->frametype
== AST_FRAME_DTMF
) ||
3875 (f
->frametype
== AST_FRAME_VIDEO
) ||
3876 (f
->frametype
== AST_FRAME_IMAGE
) ||
3877 (f
->frametype
== AST_FRAME_HTML
) ||
3878 (f
->frametype
== AST_FRAME_MODEM
) ||
3879 (f
->frametype
== AST_FRAME_TEXT
)) {
3880 /* monitored dtmf causes exit from bridge */
3881 int monitored_source
= (who
== c0
) ? watch_c0_dtmf
: watch_c1_dtmf
;
3883 if (monitored_source
&&
3884 (f
->frametype
== AST_FRAME_DTMF_END
||
3885 f
->frametype
== AST_FRAME_DTMF_BEGIN
)) {
3889 ast_log(LOG_DEBUG
, "Got DTMF %s on channel (%s)\n",
3890 f
->frametype
== AST_FRAME_DTMF_END
? "end" : "begin",
3894 /* Write immediately frames, not passed through jb */
3895 if (!frame_put_in_jb
)
3896 ast_write(other
, f
);
3898 /* Check if we have to deliver now */
3900 ast_jb_get_and_deliver(c0
, c1
);
3902 /* XXX do we want to pass on also frames not matched above ? */
3905 /* Swap who gets priority */
3913 /*! \brief Bridge two channels together */
3914 enum ast_bridge_result
ast_channel_bridge(struct ast_channel
*c0
, struct ast_channel
*c1
,
3915 struct ast_bridge_config
*config
, struct ast_frame
**fo
, struct ast_channel
**rc
)
3917 struct ast_channel
*who
= NULL
;
3918 enum ast_bridge_result res
= AST_BRIDGE_COMPLETE
;
3921 int o0nativeformats
;
3922 int o1nativeformats
;
3923 long time_left_ms
=0;
3924 struct timeval nexteventts
= { 0, };
3925 char caller_warning
= 0;
3926 char callee_warning
= 0;
3929 ast_log(LOG_WARNING
, "%s is already in a bridge with %s\n",
3930 c0
->name
, c0
->_bridge
->name
);
3934 ast_log(LOG_WARNING
, "%s is already in a bridge with %s\n",
3935 c1
->name
, c1
->_bridge
->name
);
3939 /* Stop if we're a zombie or need a soft hangup */
3940 if (ast_test_flag(c0
, AST_FLAG_ZOMBIE
) || ast_check_hangup_locked(c0
) ||
3941 ast_test_flag(c1
, AST_FLAG_ZOMBIE
) || ast_check_hangup_locked(c1
))
3945 firstpass
= config
->firstpass
;
3946 config
->firstpass
= 0;
3948 if (ast_tvzero(config
->start_time
))
3949 config
->start_time
= ast_tvnow();
3950 time_left_ms
= config
->timelimit
;
3952 caller_warning
= ast_test_flag(&config
->features_caller
, AST_FEATURE_PLAY_WARNING
);
3953 callee_warning
= ast_test_flag(&config
->features_callee
, AST_FEATURE_PLAY_WARNING
);
3955 if (config
->start_sound
&& firstpass
) {
3957 bridge_playfile(c0
, c1
, config
->start_sound
, time_left_ms
/ 1000);
3959 bridge_playfile(c1
, c0
, config
->start_sound
, time_left_ms
/ 1000);
3962 /* Keep track of bridge */
3966 /* \todo XXX here should check that cid_num is not NULL */
3967 manager_event(EVENT_FLAG_CALL
, "Link",
3973 "CallerID2: %s\r\n",
3974 c0
->name
, c1
->name
, c0
->uniqueid
, c1
->uniqueid
, c0
->cid
.cid_num
, c1
->cid
.cid_num
);
3976 o0nativeformats
= c0
->nativeformats
;
3977 o1nativeformats
= c1
->nativeformats
;
3979 if (config
->feature_timer
) {
3980 nexteventts
= ast_tvadd(config
->start_time
, ast_samp2tv(config
->feature_timer
, 1000));
3981 } else if (config
->timelimit
) {
3982 nexteventts
= ast_tvadd(config
->start_time
, ast_samp2tv(config
->timelimit
, 1000));
3983 if (caller_warning
|| callee_warning
)
3984 nexteventts
= ast_tvsub(nexteventts
, ast_samp2tv(config
->play_warning
, 1000));
3987 if (!c0
->tech
->send_digit_begin
)
3988 ast_set_flag(c1
, AST_FLAG_END_DTMF_ONLY
);
3989 if (!c1
->tech
->send_digit_begin
)
3990 ast_set_flag(c0
, AST_FLAG_END_DTMF_ONLY
);
3992 /* Before we enter in and bridge these two together tell them both the source of audio has changed */
3993 ast_indicate(c0
, AST_CONTROL_SRCUPDATE
);
3994 ast_indicate(c1
, AST_CONTROL_SRCUPDATE
);
3996 for (/* ever */;;) {
3997 struct timeval now
= { 0, };
4002 if (!ast_tvzero(nexteventts
)) {
4004 to
= ast_tvdiff_ms(nexteventts
, now
);
4006 if (!config
->timelimit
) {
4007 res
= AST_BRIDGE_COMPLETE
;
4014 if (config
->timelimit
) {
4015 time_left_ms
= config
->timelimit
- ast_tvdiff_ms(now
, config
->start_time
);
4016 if (time_left_ms
< to
)
4019 if (time_left_ms
<= 0) {
4020 if (caller_warning
&& config
->end_sound
)
4021 bridge_playfile(c0
, c1
, config
->end_sound
, 0);
4022 if (callee_warning
&& config
->end_sound
)
4023 bridge_playfile(c1
, c0
, config
->end_sound
, 0);
4032 if (time_left_ms
>= 5000 && config
->warning_sound
&& config
->play_warning
) {
4033 int t
= (time_left_ms
+ 500) / 1000; /* round to nearest second */
4035 bridge_playfile(c0
, c1
, config
->warning_sound
, t
);
4037 bridge_playfile(c1
, c0
, config
->warning_sound
, t
);
4039 if (config
->warning_freq
&& (time_left_ms
> (config
->warning_freq
+ 5000)))
4040 nexteventts
= ast_tvadd(nexteventts
, ast_samp2tv(config
->warning_freq
, 1000));
4042 nexteventts
= ast_tvadd(config
->start_time
, ast_samp2tv(config
->timelimit
, 1000));
4046 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
|| c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
) {
4047 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
4048 c0
->_softhangup
= 0;
4049 if (c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
4050 c1
->_softhangup
= 0;
4054 ast_log(LOG_DEBUG
, "Unbridge signal received. Ending native bridge.\n");
4058 /* Stop if we're a zombie or need a soft hangup */
4059 if (ast_test_flag(c0
, AST_FLAG_ZOMBIE
) || ast_check_hangup_locked(c0
) ||
4060 ast_test_flag(c1
, AST_FLAG_ZOMBIE
) || ast_check_hangup_locked(c1
)) {
4066 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",
4068 ast_test_flag(c0
, AST_FLAG_ZOMBIE
) ? "Yes" : "No",
4069 ast_check_hangup(c0
) ? "Yes" : "No",
4070 ast_test_flag(c1
, AST_FLAG_ZOMBIE
) ? "Yes" : "No",
4071 ast_check_hangup(c1
) ? "Yes" : "No");
4075 /* See if the BRIDGEPEER variable needs to be updated */
4076 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c0
, "BRIDGEPEER")))
4077 pbx_builtin_setvar_helper(c0
, "BRIDGEPEER", c1
->name
);
4078 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c1
, "BRIDGEPEER")))
4079 pbx_builtin_setvar_helper(c1
, "BRIDGEPEER", c0
->name
);
4081 if (c0
->tech
->bridge
&&
4082 (config
->timelimit
== 0) &&
4083 (c0
->tech
->bridge
== c1
->tech
->bridge
) &&
4084 !nativefailed
&& !c0
->monitor
&& !c1
->monitor
&&
4085 !c0
->audiohooks
&& !c1
->audiohooks
&& !ast_test_flag(&(config
->features_callee
),AST_FEATURE_REDIRECT
) &&
4086 !ast_test_flag(&(config
->features_caller
),AST_FEATURE_REDIRECT
) &&
4087 !c0
->masq
&& !c0
->masqr
&& !c1
->masq
&& !c1
->masqr
) {
4088 /* Looks like they share a bridge method and nothing else is in the way */
4089 ast_set_flag(c0
, AST_FLAG_NBRIDGE
);
4090 ast_set_flag(c1
, AST_FLAG_NBRIDGE
);
4091 if ((res
= c0
->tech
->bridge(c0
, c1
, config
->flags
, fo
, rc
, to
)) == AST_BRIDGE_COMPLETE
) {
4092 /* \todo XXX here should check that cid_num is not NULL */
4093 manager_event(EVENT_FLAG_CALL
, "Unlink",
4099 "CallerID2: %s\r\n",
4100 c0
->name
, c1
->name
, c0
->uniqueid
, c1
->uniqueid
, c0
->cid
.cid_num
, c1
->cid
.cid_num
);
4102 ast_log(LOG_DEBUG
, "Returning from native bridge, channels: %s, %s\n", c0
->name
, c1
->name
);
4104 ast_clear_flag(c0
, AST_FLAG_NBRIDGE
);
4105 ast_clear_flag(c1
, AST_FLAG_NBRIDGE
);
4107 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
|| c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
4115 ast_clear_flag(c0
, AST_FLAG_NBRIDGE
);
4116 ast_clear_flag(c1
, AST_FLAG_NBRIDGE
);
4119 case AST_BRIDGE_RETRY
:
4122 if (option_verbose
> 2)
4123 ast_verbose(VERBOSE_PREFIX_3
"Native bridging %s and %s ended\n",
4124 c0
->name
, c1
->name
);
4126 case AST_BRIDGE_FAILED_NOWARN
:
4132 if (((c0
->writeformat
!= c1
->readformat
) || (c0
->readformat
!= c1
->writeformat
) ||
4133 (c0
->nativeformats
!= o0nativeformats
) || (c1
->nativeformats
!= o1nativeformats
)) &&
4134 !(c0
->generator
|| c1
->generator
)) {
4135 if (ast_channel_make_compatible(c0
, c1
)) {
4136 ast_log(LOG_WARNING
, "Can't make %s and %s compatible\n", c0
->name
, c1
->name
);
4137 /* \todo XXX here should check that cid_num is not NULL */
4138 manager_event(EVENT_FLAG_CALL
, "Unlink",
4144 "CallerID2: %s\r\n",
4145 c0
->name
, c1
->name
, c0
->uniqueid
, c1
->uniqueid
, c0
->cid
.cid_num
, c1
->cid
.cid_num
);
4146 return AST_BRIDGE_FAILED
;
4148 o0nativeformats
= c0
->nativeformats
;
4149 o1nativeformats
= c1
->nativeformats
;
4152 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c0
, "BRIDGEPEER")))
4153 pbx_builtin_setvar_helper(c0
, "BRIDGEPEER", c1
->name
);
4154 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c1
, "BRIDGEPEER")))
4155 pbx_builtin_setvar_helper(c1
, "BRIDGEPEER", c0
->name
);
4157 res
= ast_generic_bridge(c0
, c1
, config
, fo
, rc
, nexteventts
);
4158 if (res
!= AST_BRIDGE_RETRY
)
4162 ast_clear_flag(c0
, AST_FLAG_END_DTMF_ONLY
);
4163 ast_clear_flag(c1
, AST_FLAG_END_DTMF_ONLY
);
4165 /* Now that we have broken the bridge the source will change yet again */
4166 ast_indicate(c0
, AST_CONTROL_SRCUPDATE
);
4167 ast_indicate(c1
, AST_CONTROL_SRCUPDATE
);
4172 /* \todo XXX here should check that cid_num is not NULL */
4173 manager_event(EVENT_FLAG_CALL
, "Unlink",
4179 "CallerID2: %s\r\n",
4180 c0
->name
, c1
->name
, c0
->uniqueid
, c1
->uniqueid
, c0
->cid
.cid_num
, c1
->cid
.cid_num
);
4182 ast_log(LOG_DEBUG
, "Bridge stops bridging channels %s and %s\n", c0
->name
, c1
->name
);
4187 /*! \brief Sets an option on a channel */
4188 int ast_channel_setoption(struct ast_channel
*chan
, int option
, void *data
, int datalen
, int block
)
4192 if (chan
->tech
->setoption
) {
4193 res
= chan
->tech
->setoption(chan
, option
, data
, datalen
);
4201 /* XXX Implement blocking -- just wait for our option frame reply, discarding
4202 intermediate packets. XXX */
4203 ast_log(LOG_ERROR
, "XXX Blocking not implemented yet XXX\n");
4209 struct tonepair_def
{
4216 struct tonepair_state
{
4230 unsigned char offset
[AST_FRIENDLY_OFFSET
];
4234 static void tonepair_release(struct ast_channel
*chan
, void *params
)
4236 struct tonepair_state
*ts
= params
;
4239 ast_set_write_format(chan
, ts
->origwfmt
);
4243 static void *tonepair_alloc(struct ast_channel
*chan
, void *params
)
4245 struct tonepair_state
*ts
;
4246 struct tonepair_def
*td
= params
;
4248 if (!(ts
= ast_calloc(1, sizeof(*ts
))))
4250 ts
->origwfmt
= chan
->writeformat
;
4251 if (ast_set_write_format(chan
, AST_FORMAT_SLINEAR
)) {
4252 ast_log(LOG_WARNING
, "Unable to set '%s' to signed linear format (write)\n", chan
->name
);
4253 tonepair_release(NULL
, ts
);
4256 ts
->fac1
= 2.0 * cos(2.0 * M_PI
* (td
->freq1
/ 8000.0)) * 32768.0;
4258 ts
->v2_1
= sin(-4.0 * M_PI
* (td
->freq1
/ 8000.0)) * td
->vol
;
4259 ts
->v3_1
= sin(-2.0 * M_PI
* (td
->freq1
/ 8000.0)) * td
->vol
;
4261 ts
->fac2
= 2.0 * cos(2.0 * M_PI
* (td
->freq2
/ 8000.0)) * 32768.0;
4262 ts
->v2_2
= sin(-4.0 * M_PI
* (td
->freq2
/ 8000.0)) * td
->vol
;
4263 ts
->v3_2
= sin(-2.0 * M_PI
* (td
->freq2
/ 8000.0)) * td
->vol
;
4264 ts
->duration
= td
->duration
;
4267 /* Let interrupts interrupt :) */
4268 ast_set_flag(chan
, AST_FLAG_WRITE_INT
);
4272 static int tonepair_generator(struct ast_channel
*chan
, void *data
, int len
, int samples
)
4274 struct tonepair_state
*ts
= data
;
4277 /* we need to prepare a frame with 16 * timelen samples as we're
4278 * generating SLIN audio
4282 if (len
> sizeof(ts
->data
) / 2 - 1) {
4283 ast_log(LOG_WARNING
, "Can't generate that much data!\n");
4286 memset(&ts
->f
, 0, sizeof(ts
->f
));
4287 for (x
=0;x
<len
/2;x
++) {
4288 ts
->v1_1
= ts
->v2_1
;
4289 ts
->v2_1
= ts
->v3_1
;
4290 ts
->v3_1
= (ts
->fac1
* ts
->v2_1
>> 15) - ts
->v1_1
;
4292 ts
->v1_2
= ts
->v2_2
;
4293 ts
->v2_2
= ts
->v3_2
;
4294 ts
->v3_2
= (ts
->fac2
* ts
->v2_2
>> 15) - ts
->v1_2
;
4297 p
= ts
->v3_2
- 32768;
4299 p
= ((p
* 9) / 10) + 1;
4300 ts
->data
[x
] = (ts
->v3_1
* p
) >> 15;
4302 ts
->data
[x
] = ts
->v3_1
+ ts
->v3_2
;
4304 ts
->f
.frametype
= AST_FRAME_VOICE
;
4305 ts
->f
.subclass
= AST_FORMAT_SLINEAR
;
4306 ts
->f
.datalen
= len
;
4307 ts
->f
.samples
= samples
;
4308 ts
->f
.offset
= AST_FRIENDLY_OFFSET
;
4309 ts
->f
.data
= ts
->data
;
4310 ast_write(chan
, &ts
->f
);
4312 if (ts
->duration
> 0) {
4313 if (ts
->pos
>= ts
->duration
* 8)
4319 static struct ast_generator tonepair
= {
4320 alloc
: tonepair_alloc
,
4321 release
: tonepair_release
,
4322 generate
: tonepair_generator
,
4325 int ast_tonepair_start(struct ast_channel
*chan
, int freq1
, int freq2
, int duration
, int vol
)
4327 struct tonepair_def d
= { 0, };
4331 d
.duration
= duration
;
4332 d
.vol
= (vol
< 1) ? 8192 : vol
; /* force invalid to 8192 */
4333 if (ast_activate_generator(chan
, &tonepair
, &d
))
4338 void ast_tonepair_stop(struct ast_channel
*chan
)
4340 ast_deactivate_generator(chan
);
4343 int ast_tonepair(struct ast_channel
*chan
, int freq1
, int freq2
, int duration
, int vol
)
4347 if ((res
= ast_tonepair_start(chan
, freq1
, freq2
, duration
, vol
)))
4350 /* Give us some wiggle room */
4351 while (chan
->generatordata
&& ast_waitfor(chan
, 100) >= 0) {
4352 struct ast_frame
*f
= ast_read(chan
);
4361 ast_group_t
ast_get_group(const char *s
)
4365 int start
=0, finish
=0, x
;
4366 ast_group_t group
= 0;
4368 if (ast_strlen_zero(s
))
4373 while ((piece
= strsep(&c
, ","))) {
4374 if (sscanf(piece
, "%d-%d", &start
, &finish
) == 2) {
4376 } else if (sscanf(piece
, "%d", &start
)) {
4380 ast_log(LOG_ERROR
, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s
, piece
);
4383 for (x
= start
; x
<= finish
; x
++) {
4384 if ((x
> 63) || (x
< 0)) {
4385 ast_log(LOG_WARNING
, "Ignoring invalid group %d (maximum group is 63)\n", x
);
4387 group
|= ((ast_group_t
) 1 << x
);
4393 static int (*ast_moh_start_ptr
)(struct ast_channel
*, const char *, const char *) = NULL
;
4394 static void (*ast_moh_stop_ptr
)(struct ast_channel
*) = NULL
;
4395 static void (*ast_moh_cleanup_ptr
)(struct ast_channel
*) = NULL
;
4397 void ast_install_music_functions(int (*start_ptr
)(struct ast_channel
*, const char *, const char *),
4398 void (*stop_ptr
)(struct ast_channel
*),
4399 void (*cleanup_ptr
)(struct ast_channel
*))
4401 ast_moh_start_ptr
= start_ptr
;
4402 ast_moh_stop_ptr
= stop_ptr
;
4403 ast_moh_cleanup_ptr
= cleanup_ptr
;
4406 void ast_uninstall_music_functions(void)
4408 ast_moh_start_ptr
= NULL
;
4409 ast_moh_stop_ptr
= NULL
;
4410 ast_moh_cleanup_ptr
= NULL
;
4413 /*! \brief Turn on music on hold on a given channel */
4414 int ast_moh_start(struct ast_channel
*chan
, const char *mclass
, const char *interpclass
)
4416 if (ast_moh_start_ptr
)
4417 return ast_moh_start_ptr(chan
, mclass
, interpclass
);
4419 if (option_verbose
> 2) {
4420 ast_verbose(VERBOSE_PREFIX_3
"Music class %s requested but no musiconhold loaded.\n",
4421 mclass
? mclass
: (interpclass
? interpclass
: "default"));
4427 /*! \brief Turn off music on hold on a given channel */
4428 void ast_moh_stop(struct ast_channel
*chan
)
4430 if (ast_moh_stop_ptr
)
4431 ast_moh_stop_ptr(chan
);
4434 void ast_moh_cleanup(struct ast_channel
*chan
)
4436 if (ast_moh_cleanup_ptr
)
4437 ast_moh_cleanup_ptr(chan
);
4440 void ast_channels_init(void)
4442 ast_cli_register_multiple(cli_channel
, sizeof(cli_channel
) / sizeof(struct ast_cli_entry
));
4445 /*! \brief Print call group and pickup group ---*/
4446 char *ast_print_group(char *buf
, int buflen
, ast_group_t group
)
4454 if (!group
) /* Return empty string if no group */
4457 for (i
= 0; i
<= 63; i
++) { /* Max group is 63 */
4458 if (group
& ((ast_group_t
) 1 << i
)) {
4460 strncat(buf
, ", ", buflen
- strlen(buf
) - 1);
4464 snprintf(num
, sizeof(num
), "%u", i
);
4465 strncat(buf
, num
, buflen
- strlen(buf
) - 1);
4471 void ast_set_variables(struct ast_channel
*chan
, struct ast_variable
*vars
)
4473 struct ast_variable
*cur
;
4475 for (cur
= vars
; cur
; cur
= cur
->next
)
4476 pbx_builtin_setvar_helper(chan
, cur
->name
, cur
->value
);
4479 static void *silence_generator_alloc(struct ast_channel
*chan
, void *data
)
4481 /* just store the data pointer in the channel structure */
4485 static void silence_generator_release(struct ast_channel
*chan
, void *data
)
4490 static int silence_generator_generate(struct ast_channel
*chan
, void *data
, int len
, int samples
)
4493 struct ast_frame frame
= {
4494 .frametype
= AST_FRAME_VOICE
,
4495 .subclass
= AST_FORMAT_SLINEAR
,
4498 .datalen
= sizeof(buf
),
4500 memset(buf
, 0, sizeof(buf
));
4501 if (ast_write(chan
, &frame
))
4506 static struct ast_generator silence_generator
= {
4507 .alloc
= silence_generator_alloc
,
4508 .release
= silence_generator_release
,
4509 .generate
= silence_generator_generate
,
4512 struct ast_silence_generator
{
4513 int old_write_format
;
4516 struct ast_silence_generator
*ast_channel_start_silence_generator(struct ast_channel
*chan
)
4518 struct ast_silence_generator
*state
;
4520 if (!(state
= ast_calloc(1, sizeof(*state
)))) {
4524 state
->old_write_format
= chan
->writeformat
;
4526 if (ast_set_write_format(chan
, AST_FORMAT_SLINEAR
) < 0) {
4527 ast_log(LOG_ERROR
, "Could not set write format to SLINEAR\n");
4532 ast_activate_generator(chan
, &silence_generator
, state
);
4535 ast_log(LOG_DEBUG
, "Started silence generator on '%s'\n", chan
->name
);
4540 void ast_channel_stop_silence_generator(struct ast_channel
*chan
, struct ast_silence_generator
*state
)
4545 ast_deactivate_generator(chan
);
4548 ast_log(LOG_DEBUG
, "Stopped silence generator on '%s'\n", chan
->name
);
4550 if (ast_set_write_format(chan
, state
->old_write_format
) < 0)
4551 ast_log(LOG_ERROR
, "Could not return write format to its original state\n");
4557 /*! \ brief Convert channel reloadreason (ENUM) to text string for manager event */
4558 const char *channelreloadreason2txt(enum channelreloadreason reason
)
4561 case CHANNEL_MODULE_LOAD
:
4562 return "LOAD (Channel module load)";
4564 case CHANNEL_MODULE_RELOAD
:
4565 return "RELOAD (Channel module reload)";
4567 case CHANNEL_CLI_RELOAD
:
4568 return "CLIRELOAD (Channel module reload by CLI command)";
4571 return "MANAGERRELOAD (Channel module reload by manager)";
4575 #ifdef DEBUG_CHANNEL_LOCKS
4577 /*! \brief Unlock AST channel (and print debugging output)
4578 \note You need to enable DEBUG_CHANNEL_LOCKS for this function
4580 int __ast_channel_unlock(struct ast_channel
*chan
, const char *filename
, int lineno
, const char *func
)
4583 if (option_debug
> 2)
4584 ast_log(LOG_DEBUG
, "::::==== Unlocking AST channel %s\n", chan
->name
);
4588 ast_log(LOG_DEBUG
, "::::==== Unlocking non-existing channel \n");
4591 #ifdef DEBUG_THREADS
4592 res
= __ast_pthread_mutex_unlock(filename
, lineno
, func
, "(channel lock)", &chan
->lock
);
4594 res
= ast_mutex_unlock(&chan
->lock
);
4597 if (option_debug
> 2) {
4598 #ifdef DEBUG_THREADS
4600 if ((count
= chan
->lock
.reentrancy
))
4601 ast_log(LOG_DEBUG
, ":::=== Still have %d locks (recursive)\n", count
);
4605 ast_log(LOG_DEBUG
, "::::==== Channel %s was unlocked\n", chan
->name
);
4606 if (res
== EINVAL
) {
4608 ast_log(LOG_DEBUG
, "::::==== Channel %s had no lock by this thread. Failed unlocking\n", chan
->name
);
4612 /* We had no lock, so okay any way*/
4613 if (option_debug
> 3)
4614 ast_log(LOG_DEBUG
, "::::==== Channel %s was not locked at all \n", chan
->name
);
4620 /*! \brief Lock AST channel (and print debugging output)
4621 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
4622 int __ast_channel_lock(struct ast_channel
*chan
, const char *filename
, int lineno
, const char *func
)
4626 if (option_debug
> 3)
4627 ast_log(LOG_DEBUG
, "====:::: Locking AST channel %s\n", chan
->name
);
4629 #ifdef DEBUG_THREADS
4630 res
= __ast_pthread_mutex_lock(filename
, lineno
, func
, "(channel lock)", &chan
->lock
);
4632 res
= ast_mutex_lock(&chan
->lock
);
4635 if (option_debug
> 3) {
4636 #ifdef DEBUG_THREADS
4638 if ((count
= chan
->lock
.reentrancy
))
4639 ast_log(LOG_DEBUG
, ":::=== Now have %d locks (recursive)\n", count
);
4642 ast_log(LOG_DEBUG
, "::::==== Channel %s was locked\n", chan
->name
);
4643 if (res
== EDEADLK
) {
4644 /* We had no lock, so okey any way */
4645 if (option_debug
> 3)
4646 ast_log(LOG_DEBUG
, "::::==== Channel %s was not locked by us. Lock would cause deadlock.\n", chan
->name
);
4648 if (res
== EINVAL
) {
4649 if (option_debug
> 3)
4650 ast_log(LOG_DEBUG
, "::::==== Channel %s lock failed. No mutex.\n", chan
->name
);
4656 /*! \brief Lock AST channel (and print debugging output)
4657 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
4658 int __ast_channel_trylock(struct ast_channel
*chan
, const char *filename
, int lineno
, const char *func
)
4662 if (option_debug
> 2)
4663 ast_log(LOG_DEBUG
, "====:::: Trying to lock AST channel %s\n", chan
->name
);
4664 #ifdef DEBUG_THREADS
4665 res
= __ast_pthread_mutex_trylock(filename
, lineno
, func
, "(channel lock)", &chan
->lock
);
4667 res
= ast_mutex_trylock(&chan
->lock
);
4670 if (option_debug
> 2) {
4671 #ifdef DEBUG_THREADS
4673 if ((count
= chan
->lock
.reentrancy
))
4674 ast_log(LOG_DEBUG
, ":::=== Now have %d locks (recursive)\n", count
);
4677 ast_log(LOG_DEBUG
, "::::==== Channel %s was locked\n", chan
->name
);
4679 /* We failed to lock */
4680 if (option_debug
> 2)
4681 ast_log(LOG_DEBUG
, "::::==== Channel %s failed to lock. Not waiting around...\n", chan
->name
);
4683 if (res
== EDEADLK
) {
4684 /* We had no lock, so okey any way*/
4685 if (option_debug
> 2)
4686 ast_log(LOG_DEBUG
, "::::==== Channel %s was not locked. Lock would cause deadlock.\n", chan
->name
);
4688 if (res
== EINVAL
&& option_debug
> 2)
4689 ast_log(LOG_DEBUG
, "::::==== Channel %s lock failed. No mutex.\n", chan
->name
);
4697 * Wrappers for various ast_say_*() functions that call the full version
4698 * of the same functions.
4699 * The proper place would be say.c, but that file is optional and one
4700 * must be able to build asterisk even without it (using a loadable 'say'
4701 * implementation that only supplies the 'full' version of the functions.
4704 int ast_say_number(struct ast_channel
*chan
, int num
,
4705 const char *ints
, const char *language
, const char *options
)
4707 return ast_say_number_full(chan
, num
, ints
, language
, options
, -1, -1);
4710 int ast_say_enumeration(struct ast_channel
*chan
, int num
,
4711 const char *ints
, const char *language
, const char *options
)
4713 return ast_say_enumeration_full(chan
, num
, ints
, language
, options
, -1, -1);
4716 int ast_say_digits(struct ast_channel
*chan
, int num
,
4717 const char *ints
, const char *lang
)
4719 return ast_say_digits_full(chan
, num
, ints
, lang
, -1, -1);
4722 int ast_say_digit_str(struct ast_channel
*chan
, const char *str
,
4723 const char *ints
, const char *lang
)
4725 return ast_say_digit_str_full(chan
, str
, ints
, lang
, -1, -1);
4728 int ast_say_character_str(struct ast_channel
*chan
, const char *str
,
4729 const char *ints
, const char *lang
)
4731 return ast_say_character_str_full(chan
, str
, ints
, lang
, -1, -1);
4734 int ast_say_phonetic_str(struct ast_channel
*chan
, const char *str
,
4735 const char *ints
, const char *lang
)
4737 return ast_say_phonetic_str_full(chan
, str
, ints
, lang
, -1, -1);
4740 int ast_say_digits_full(struct ast_channel
*chan
, int num
,
4741 const char *ints
, const char *lang
, int audiofd
, int ctrlfd
)
4745 snprintf(buf
, sizeof(buf
), "%d", num
);
4746 return ast_say_digit_str_full(chan
, buf
, ints
, lang
, audiofd
, ctrlfd
);