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$")
41 #include <sys/ioctl.h>
42 #include <zaptel/zaptel.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
++)
746 tmp
->timingfd
= open("/dev/zap/timer", O_RDWR
);
747 if (tmp
->timingfd
> -1) {
748 /* Check if timing interface supports new
751 if (!ioctl(tmp
->timingfd
, ZT_TIMERPONG
, &flags
))
759 if (pipe(tmp
->alertpipe
)) {
760 ast_log(LOG_WARNING
, "Channel allocation failed: Can't create alert pipe!\n");
762 if (tmp
->timingfd
> -1)
763 close(tmp
->timingfd
);
765 sched_context_destroy(tmp
->sched
);
766 ast_string_field_free_memory(tmp
);
770 flags
= fcntl(tmp
->alertpipe
[0], F_GETFL
);
771 fcntl(tmp
->alertpipe
[0], F_SETFL
, flags
| O_NONBLOCK
);
772 flags
= fcntl(tmp
->alertpipe
[1], F_GETFL
);
773 fcntl(tmp
->alertpipe
[1], F_SETFL
, flags
| O_NONBLOCK
);
775 } else /* Make sure we've got it done right if they don't */
776 tmp
->alertpipe
[0] = tmp
->alertpipe
[1] = -1;
778 /* Always watch the alertpipe */
779 tmp
->fds
[AST_ALERT_FD
] = tmp
->alertpipe
[0];
780 /* And timing pipe */
781 tmp
->fds
[AST_TIMING_FD
] = tmp
->timingfd
;
782 ast_string_field_set(tmp
, name
, "**Unknown**");
789 tmp
->fin
= global_fin
;
790 tmp
->fout
= global_fout
;
792 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME
)) {
793 ast_string_field_build(tmp
, uniqueid
, "%li.%d", (long) time(NULL
),
794 ast_atomic_fetchadd_int(&uniqueint
, 1));
796 ast_string_field_build(tmp
, uniqueid
, "%s-%li.%d", ast_config_AST_SYSTEM_NAME
,
797 (long) time(NULL
), ast_atomic_fetchadd_int(&uniqueint
, 1));
800 tmp
->cid
.cid_name
= ast_strdup(cid_name
);
801 tmp
->cid
.cid_num
= ast_strdup(cid_num
);
803 if (!ast_strlen_zero(name_fmt
)) {
804 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
805 * And they all use slightly different formats for their name string.
806 * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
807 * This means, that the stringfields must have a routine that takes the va_lists directly, and
808 * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
809 * This new function was written so this can be accomplished.
811 va_start(ap1
, name_fmt
);
812 va_start(ap2
, name_fmt
);
813 ast_string_field_build_va(tmp
, name
, name_fmt
, ap1
, ap2
);
818 /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */
820 /* These 4 variables need to be set up for the cdr_init() to work right */
822 tmp
->amaflags
= amaflag
;
824 tmp
->amaflags
= ast_default_amaflags
;
826 if (!ast_strlen_zero(acctcode
))
827 ast_string_field_set(tmp
, accountcode
, acctcode
);
829 ast_string_field_set(tmp
, accountcode
, ast_default_accountcode
);
831 if (!ast_strlen_zero(context
))
832 ast_copy_string(tmp
->context
, context
, sizeof(tmp
->context
));
834 strcpy(tmp
->context
, "default");
836 if (!ast_strlen_zero(exten
))
837 ast_copy_string(tmp
->exten
, exten
, sizeof(tmp
->exten
));
839 strcpy(tmp
->exten
, "s");
843 tmp
->cdr
= ast_cdr_alloc();
844 ast_cdr_init(tmp
->cdr
, tmp
);
845 ast_cdr_start(tmp
->cdr
);
847 headp
= &tmp
->varshead
;
848 AST_LIST_HEAD_INIT_NOLOCK(headp
);
850 ast_mutex_init(&tmp
->lock
);
852 AST_LIST_HEAD_INIT_NOLOCK(&tmp
->datastores
);
854 ast_string_field_set(tmp
, language
, defaultlanguage
);
856 tmp
->tech
= &null_tech
;
858 AST_LIST_LOCK(&channels
);
859 AST_LIST_INSERT_HEAD(&channels
, tmp
, chan_list
);
860 AST_LIST_UNLOCK(&channels
);
863 * and now, since the channel structure is built, and has its name, let's
864 * call the manager event generator with this Newchannel event. This is the
865 * proper and correct place to make this call, but you sure do have to pass
866 * a lot of data into this func to do it here!
868 if (!ast_strlen_zero(name_fmt
)) {
869 manager_event(EVENT_FLAG_CALL
, "Newchannel",
872 "CallerIDNum: %s\r\n"
873 "CallerIDName: %s\r\n"
875 tmp
->name
, ast_state2str(state
),
876 S_OR(cid_num
, "<unknown>"),
877 S_OR(cid_name
, "<unknown>"),
884 /*! \brief Queue an outgoing media frame */
885 int ast_queue_frame(struct ast_channel
*chan
, struct ast_frame
*fin
)
888 struct ast_frame
*cur
;
892 /* Build us a copy and free the original one */
893 if (!(f
= ast_frdup(fin
))) {
894 ast_log(LOG_WARNING
, "Unable to duplicate frame\n");
897 ast_channel_lock(chan
);
899 /* See if the last frame on the queue is a hangup, if so don't queue anything */
900 if ((cur
= AST_LIST_LAST(&chan
->readq
)) && (cur
->frametype
== AST_FRAME_CONTROL
) && (cur
->subclass
== AST_CONTROL_HANGUP
)) {
902 ast_channel_unlock(chan
);
906 /* Count how many frames exist on the queue */
907 AST_LIST_TRAVERSE(&chan
->readq
, cur
, frame_list
) {
911 /* Allow up to 96 voice frames outstanding, and up to 128 total frames */
912 if (((fin
->frametype
== AST_FRAME_VOICE
) && (qlen
> 96)) || (qlen
> 128)) {
913 if (fin
->frametype
!= AST_FRAME_VOICE
) {
914 ast_log(LOG_WARNING
, "Exceptionally long queue length queuing to %s\n", chan
->name
);
918 ast_log(LOG_DEBUG
, "Dropping voice to exceptionally long queue on %s\n", chan
->name
);
920 ast_channel_unlock(chan
);
924 AST_LIST_INSERT_TAIL(&chan
->readq
, f
, frame_list
);
925 if (chan
->alertpipe
[1] > -1) {
926 if (write(chan
->alertpipe
[1], &blah
, sizeof(blah
)) != sizeof(blah
))
927 ast_log(LOG_WARNING
, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
928 chan
->name
, f
->frametype
, f
->subclass
, qlen
, strerror(errno
));
930 } else if (chan
->timingfd
> -1) {
931 ioctl(chan
->timingfd
, ZT_TIMERPING
, &blah
);
933 } else if (ast_test_flag(chan
, AST_FLAG_BLOCKING
)) {
934 pthread_kill(chan
->blocker
, SIGURG
);
936 ast_channel_unlock(chan
);
940 /*! \brief Queue a hangup frame for channel */
941 int ast_queue_hangup(struct ast_channel
*chan
)
943 struct ast_frame f
= { AST_FRAME_CONTROL
, AST_CONTROL_HANGUP
};
944 /* Yeah, let's not change a lock-critical value without locking */
945 if (!ast_channel_trylock(chan
)) {
946 chan
->_softhangup
|= AST_SOFTHANGUP_DEV
;
947 ast_channel_unlock(chan
);
949 return ast_queue_frame(chan
, &f
);
952 /*! \brief Queue a control frame */
953 int ast_queue_control(struct ast_channel
*chan
, enum ast_control_frame_type control
)
955 struct ast_frame f
= { AST_FRAME_CONTROL
, };
957 f
.subclass
= control
;
959 return ast_queue_frame(chan
, &f
);
962 /*! \brief Queue a control frame with payload */
963 int ast_queue_control_data(struct ast_channel
*chan
, enum ast_control_frame_type control
,
964 const void *data
, size_t datalen
)
966 struct ast_frame f
= { AST_FRAME_CONTROL
, };
968 f
.subclass
= control
;
969 f
.data
= (void *) data
;
972 return ast_queue_frame(chan
, &f
);
975 /*! \brief Set defer DTMF flag on channel */
976 int ast_channel_defer_dtmf(struct ast_channel
*chan
)
981 pre
= ast_test_flag(chan
, AST_FLAG_DEFER_DTMF
);
982 ast_set_flag(chan
, AST_FLAG_DEFER_DTMF
);
987 /*! \brief Unset defer DTMF flag on channel */
988 void ast_channel_undefer_dtmf(struct ast_channel
*chan
)
991 ast_clear_flag(chan
, AST_FLAG_DEFER_DTMF
);
995 * \brief Helper function to find channels.
997 * It supports these modes:
999 * prev != NULL : get channel next in list after prev
1000 * name != NULL : get channel with matching name
1001 * name != NULL && namelen != 0 : get channel whose name starts with prefix
1002 * exten != NULL : get channel whose exten or macroexten matches
1003 * context != NULL && exten != NULL : get channel whose context or macrocontext
1005 * It returns with the channel's lock held. If getting the individual lock fails,
1006 * unlock and retry quickly up to 10 times, then give up.
1008 * \note XXX Note that this code has cost O(N) because of the need to verify
1009 * that the object is still on the global list.
1011 * \note XXX also note that accessing fields (e.g. c->name in ast_log())
1012 * can only be done with the lock held or someone could delete the
1013 * object while we work on it. This causes some ugliness in the code.
1014 * Note that removing the first ast_log() may be harmful, as it would
1015 * shorten the retry period and possibly cause failures.
1016 * We should definitely go for a better scheme that is deadlock-free.
1018 static struct ast_channel
*channel_find_locked(const struct ast_channel
*prev
,
1019 const char *name
, const int namelen
,
1020 const char *context
, const char *exten
)
1022 const char *msg
= prev
? "deadlock" : "initial deadlock";
1024 struct ast_channel
*c
;
1025 const struct ast_channel
*_prev
= prev
;
1027 for (retries
= 0; retries
< 10; retries
++) {
1029 AST_LIST_LOCK(&channels
);
1030 AST_LIST_TRAVERSE(&channels
, c
, chan_list
) {
1032 if (prev
) { /* look for next item */
1033 if (c
!= prev
) /* not this one */
1035 /* found, prepare to return c->next */
1036 if ((c
= AST_LIST_NEXT(c
, chan_list
)) == NULL
) break;
1037 /* If prev was the last item on the channel list, then we just
1038 * want to return NULL, instead of trying to deref NULL in the
1042 /* We want prev to be NULL in case we end up doing more searching through
1043 * the channel list to find the channel (ie: name searching). If we didn't
1044 * set this to NULL the logic would just blow up
1045 * XXX Need a better explanation for this ...
1048 if (name
) { /* want match by name */
1049 if ((!namelen
&& strcasecmp(c
->name
, name
)) ||
1050 (namelen
&& strncasecmp(c
->name
, name
, namelen
)))
1051 continue; /* name match failed */
1053 if (context
&& strcasecmp(c
->context
, context
) &&
1054 strcasecmp(c
->macrocontext
, context
))
1055 continue; /* context match failed */
1056 if (strcasecmp(c
->exten
, exten
) &&
1057 strcasecmp(c
->macroexten
, exten
))
1058 continue; /* exten match failed */
1060 /* if we get here, c points to the desired record */
1063 /* exit if chan not found or mutex acquired successfully */
1064 /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
1065 done
= c
== NULL
|| ast_channel_trylock(c
) == 0;
1068 ast_log(LOG_DEBUG
, "Avoiding %s for channel '%p'\n", msg
, c
);
1070 /* We are about to fail due to a deadlock, so report this
1071 * while we still have the list lock.
1074 ast_log(LOG_DEBUG
, "Failure, could not lock '%p' after %d retries!\n", c
, retries
);
1075 /* As we have deadlocked, we will skip this channel and
1076 * see if there is another match.
1077 * NOTE: No point doing this for a full-name match,
1078 * as there can be no more matches.
1080 if (!(name
&& !namelen
)) {
1086 AST_LIST_UNLOCK(&channels
);
1089 /* If we reach this point we basically tried to lock a channel and failed. Instead of
1090 * starting from the beginning of the list we can restore our saved pointer to the previous
1091 * channel and start from there.
1094 usleep(1); /* give other threads a chance before retrying */
1100 /*! \brief Browse channels in use */
1101 struct ast_channel
*ast_channel_walk_locked(const struct ast_channel
*prev
)
1103 return channel_find_locked(prev
, NULL
, 0, NULL
, NULL
);
1106 /*! \brief Get channel by name and lock it */
1107 struct ast_channel
*ast_get_channel_by_name_locked(const char *name
)
1109 return channel_find_locked(NULL
, name
, 0, NULL
, NULL
);
1112 /*! \brief Get channel by name prefix and lock it */
1113 struct ast_channel
*ast_get_channel_by_name_prefix_locked(const char *name
, const int namelen
)
1115 return channel_find_locked(NULL
, name
, namelen
, NULL
, NULL
);
1118 /*! \brief Get next channel by name prefix and lock it */
1119 struct ast_channel
*ast_walk_channel_by_name_prefix_locked(const struct ast_channel
*chan
, const char *name
,
1122 return channel_find_locked(chan
, name
, namelen
, NULL
, NULL
);
1125 /*! \brief Get channel by exten (and optionally context) and lock it */
1126 struct ast_channel
*ast_get_channel_by_exten_locked(const char *exten
, const char *context
)
1128 return channel_find_locked(NULL
, NULL
, 0, context
, exten
);
1131 /*! \brief Get next channel by exten (and optionally context) and lock it */
1132 struct ast_channel
*ast_walk_channel_by_exten_locked(const struct ast_channel
*chan
, const char *exten
,
1133 const char *context
)
1135 return channel_find_locked(chan
, NULL
, 0, context
, exten
);
1138 /*! \brief Wait, look for hangups and condition arg */
1139 int ast_safe_sleep_conditional(struct ast_channel
*chan
, int ms
, int (*cond
)(void*), void *data
)
1141 struct ast_frame
*f
;
1144 if (cond
&& ((*cond
)(data
) == 0))
1146 ms
= ast_waitfor(chan
, ms
);
1159 /*! \brief Wait, look for hangups */
1160 int ast_safe_sleep(struct ast_channel
*chan
, int ms
)
1162 return ast_safe_sleep_conditional(chan
, ms
, NULL
, NULL
);
1165 static void free_cid(struct ast_callerid
*cid
)
1168 free(cid
->cid_dnid
);
1172 free(cid
->cid_name
);
1176 free(cid
->cid_rdnis
);
1179 /*! \brief Free a channel structure */
1180 void ast_channel_free(struct ast_channel
*chan
)
1183 struct ast_var_t
*vardata
;
1184 struct ast_frame
*f
;
1185 struct varshead
*headp
;
1186 struct ast_datastore
*datastore
= NULL
;
1187 char name
[AST_CHANNEL_NAME
];
1189 headp
=&chan
->varshead
;
1191 AST_LIST_LOCK(&channels
);
1192 if (!AST_LIST_REMOVE(&channels
, chan
, chan_list
)) {
1193 AST_LIST_UNLOCK(&channels
);
1194 ast_log(LOG_ERROR
, "Unable to find channel in list to free. Assuming it has already been done.\n");
1196 /* Lock and unlock the channel just to be sure nobody
1197 has it locked still */
1198 ast_channel_lock(chan
);
1199 ast_channel_unlock(chan
);
1200 if (chan
->tech_pvt
) {
1201 ast_log(LOG_WARNING
, "Channel '%s' may not have been hung up properly\n", chan
->name
);
1202 free(chan
->tech_pvt
);
1206 sched_context_destroy(chan
->sched
);
1208 ast_copy_string(name
, chan
->name
, sizeof(name
));
1210 /* Stop monitoring */
1212 chan
->monitor
->stop( chan
, 0 );
1214 /* If there is native format music-on-hold state, free it */
1215 if (chan
->music_state
)
1216 ast_moh_cleanup(chan
);
1218 /* Free translators */
1219 if (chan
->readtrans
)
1220 ast_translator_free_path(chan
->readtrans
);
1221 if (chan
->writetrans
)
1222 ast_translator_free_path(chan
->writetrans
);
1224 ast_log(LOG_WARNING
, "PBX may not have been terminated properly on '%s'\n", chan
->name
);
1225 free_cid(&chan
->cid
);
1226 ast_mutex_destroy(&chan
->lock
);
1227 /* Close pipes if appropriate */
1228 if ((fd
= chan
->alertpipe
[0]) > -1)
1230 if ((fd
= chan
->alertpipe
[1]) > -1)
1232 if ((fd
= chan
->timingfd
) > -1)
1234 while ((f
= AST_LIST_REMOVE_HEAD(&chan
->readq
, frame_list
)))
1237 /* Get rid of each of the data stores on the channel */
1238 while ((datastore
= AST_LIST_REMOVE_HEAD(&chan
->datastores
, entry
)))
1239 /* Free the data store */
1240 ast_channel_datastore_free(datastore
);
1241 AST_LIST_HEAD_INIT_NOLOCK(&chan
->datastores
);
1243 /* loop over the variables list, freeing all data and deleting list items */
1244 /* no need to lock the list, as the channel is already locked */
1246 while ((vardata
= AST_LIST_REMOVE_HEAD(headp
, entries
)))
1247 ast_var_delete(vardata
);
1249 ast_app_group_discard(chan
);
1251 /* Destroy the jitterbuffer */
1252 ast_jb_destroy(chan
);
1254 ast_string_field_free_memory(chan
);
1256 AST_LIST_UNLOCK(&channels
);
1258 ast_device_state_changed_literal(name
);
1261 struct ast_datastore
*ast_channel_datastore_alloc(const struct ast_datastore_info
*info
, char *uid
)
1263 struct ast_datastore
*datastore
= NULL
;
1265 /* Make sure we at least have type so we can identify this */
1270 /* Allocate memory for datastore and clear it */
1271 datastore
= ast_calloc(1, sizeof(*datastore
));
1272 if (datastore
== NULL
) {
1276 datastore
->info
= info
;
1278 datastore
->uid
= ast_strdup(uid
);
1283 int ast_channel_datastore_free(struct ast_datastore
*datastore
)
1287 /* Using the destroy function (if present) destroy the data */
1288 if (datastore
->info
->destroy
!= NULL
&& datastore
->data
!= NULL
) {
1289 datastore
->info
->destroy(datastore
->data
);
1290 datastore
->data
= NULL
;
1293 /* Free allocated UID memory */
1294 if (datastore
->uid
!= NULL
) {
1295 free(datastore
->uid
);
1296 datastore
->uid
= NULL
;
1299 /* Finally free memory used by ourselves */
1305 int ast_channel_datastore_inherit(struct ast_channel
*from
, struct ast_channel
*to
)
1307 struct ast_datastore
*datastore
= NULL
, *datastore2
;
1309 AST_LIST_TRAVERSE(&from
->datastores
, datastore
, entry
) {
1310 if (datastore
->inheritance
> 0) {
1311 datastore2
= ast_channel_datastore_alloc(datastore
->info
, datastore
->uid
);
1313 datastore2
->data
= datastore
->info
->duplicate(datastore
->data
);
1314 datastore2
->inheritance
= datastore
->inheritance
== DATASTORE_INHERIT_FOREVER
? DATASTORE_INHERIT_FOREVER
: datastore
->inheritance
- 1;
1315 AST_LIST_INSERT_TAIL(&to
->datastores
, datastore2
, entry
);
1322 int ast_channel_datastore_add(struct ast_channel
*chan
, struct ast_datastore
*datastore
)
1326 AST_LIST_INSERT_HEAD(&chan
->datastores
, datastore
, entry
);
1331 int ast_channel_datastore_remove(struct ast_channel
*chan
, struct ast_datastore
*datastore
)
1333 struct ast_datastore
*datastore2
= NULL
;
1336 /* Find our position and remove ourselves */
1337 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan
->datastores
, datastore2
, entry
) {
1338 if (datastore2
== datastore
) {
1339 AST_LIST_REMOVE_CURRENT(&chan
->datastores
, entry
);
1344 AST_LIST_TRAVERSE_SAFE_END
1349 struct ast_datastore
*ast_channel_datastore_find(struct ast_channel
*chan
, const struct ast_datastore_info
*info
, char *uid
)
1351 struct ast_datastore
*datastore
= NULL
;
1356 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan
->datastores
, datastore
, entry
) {
1357 if (datastore
->info
== info
) {
1358 if (uid
!= NULL
&& datastore
->uid
!= NULL
) {
1359 if (!strcasecmp(uid
, datastore
->uid
)) {
1360 /* Matched by type AND uid */
1364 /* Matched by type at least */
1369 AST_LIST_TRAVERSE_SAFE_END
1374 /*! \brief Softly hangup a channel, don't lock */
1375 int ast_softhangup_nolock(struct ast_channel
*chan
, int cause
)
1378 ast_log(LOG_DEBUG
, "Soft-Hanging up channel '%s'\n", chan
->name
);
1379 /* Inform channel driver that we need to be hung up, if it cares */
1380 chan
->_softhangup
|= cause
;
1381 ast_queue_frame(chan
, &ast_null_frame
);
1382 /* Interrupt any poll call or such */
1383 if (ast_test_flag(chan
, AST_FLAG_BLOCKING
))
1384 pthread_kill(chan
->blocker
, SIGURG
);
1388 /*! \brief Softly hangup a channel, lock */
1389 int ast_softhangup(struct ast_channel
*chan
, int cause
)
1392 ast_channel_lock(chan
);
1393 res
= ast_softhangup_nolock(chan
, cause
);
1394 ast_channel_unlock(chan
);
1398 static void free_translation(struct ast_channel
*clone
)
1400 if (clone
->writetrans
)
1401 ast_translator_free_path(clone
->writetrans
);
1402 if (clone
->readtrans
)
1403 ast_translator_free_path(clone
->readtrans
);
1404 clone
->writetrans
= NULL
;
1405 clone
->readtrans
= NULL
;
1406 clone
->rawwriteformat
= clone
->nativeformats
;
1407 clone
->rawreadformat
= clone
->nativeformats
;
1410 /*! \brief Hangup a channel */
1411 int ast_hangup(struct ast_channel
*chan
)
1414 struct ast_cdr
*cdr
= NULL
;
1416 /* Don't actually hang up a channel that will masquerade as someone else, or
1417 if someone is going to masquerade as us */
1418 ast_channel_lock(chan
);
1420 if (chan
->audiohooks
) {
1421 ast_audiohook_detach_list(chan
->audiohooks
);
1422 chan
->audiohooks
= NULL
;
1425 ast_autoservice_stop(chan
);
1428 if (ast_do_masquerade(chan
))
1429 ast_log(LOG_WARNING
, "Failed to perform masquerade\n");
1433 ast_log(LOG_WARNING
, "%s getting hung up, but someone is trying to masq into us?!?\n", chan
->name
);
1434 ast_channel_unlock(chan
);
1437 /* If this channel is one which will be masqueraded into something,
1438 mark it as a zombie already, so we know to free it later */
1440 ast_set_flag(chan
, AST_FLAG_ZOMBIE
);
1441 ast_channel_unlock(chan
);
1444 free_translation(chan
);
1445 /* Close audio stream */
1447 ast_closestream(chan
->stream
);
1448 chan
->stream
= NULL
;
1450 /* Close video stream */
1451 if (chan
->vstream
) {
1452 ast_closestream(chan
->vstream
);
1453 chan
->vstream
= NULL
;
1456 sched_context_destroy(chan
->sched
);
1460 if (chan
->generatordata
) /* Clear any tone stuff remaining */
1461 chan
->generator
->release(chan
, chan
->generatordata
);
1462 chan
->generatordata
= NULL
;
1463 chan
->generator
= NULL
;
1464 if (chan
->cdr
) { /* End the CDR if it hasn't already */
1465 ast_cdr_end(chan
->cdr
);
1469 if (ast_test_flag(chan
, AST_FLAG_BLOCKING
)) {
1470 ast_log(LOG_WARNING
, "Hard hangup called by thread %ld on %s, while fd "
1471 "is blocked by thread %ld in procedure %s! Expect a failure\n",
1472 (long)pthread_self(), chan
->name
, (long)chan
->blocker
, chan
->blockproc
);
1475 if (!ast_test_flag(chan
, AST_FLAG_ZOMBIE
)) {
1477 ast_log(LOG_DEBUG
, "Hanging up channel '%s'\n", chan
->name
);
1478 if (chan
->tech
->hangup
)
1479 res
= chan
->tech
->hangup(chan
);
1482 ast_log(LOG_DEBUG
, "Hanging up zombie '%s'\n", chan
->name
);
1485 ast_channel_unlock(chan
);
1486 manager_event(EVENT_FLAG_CALL
, "Hangup",
1490 "Cause-txt: %s\r\n",
1494 ast_cause2str(chan
->hangupcause
)
1496 ast_channel_free(chan
);
1499 ast_cdr_detach(cdr
);
1504 int ast_answer(struct ast_channel
*chan
)
1507 ast_channel_lock(chan
);
1508 /* You can't answer an outbound call */
1509 if (ast_test_flag(chan
, AST_FLAG_OUTGOING
)) {
1510 ast_channel_unlock(chan
);
1513 /* Stop if we're a zombie or need a soft hangup */
1514 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
)) {
1515 ast_channel_unlock(chan
);
1518 switch(chan
->_state
) {
1519 case AST_STATE_RINGING
:
1520 case AST_STATE_RING
:
1521 if (chan
->tech
->answer
)
1522 res
= chan
->tech
->answer(chan
);
1523 ast_setstate(chan
, AST_STATE_UP
);
1524 ast_cdr_answer(chan
->cdr
);
1527 ast_cdr_answer(chan
->cdr
);
1532 chan
->visible_indication
= 0;
1533 ast_channel_unlock(chan
);
1537 void ast_deactivate_generator(struct ast_channel
*chan
)
1539 ast_channel_lock(chan
);
1540 if (chan
->generatordata
) {
1541 if (chan
->generator
&& chan
->generator
->release
)
1542 chan
->generator
->release(chan
, chan
->generatordata
);
1543 chan
->generatordata
= NULL
;
1544 chan
->generator
= NULL
;
1545 chan
->fds
[AST_GENERATOR_FD
] = -1;
1546 ast_clear_flag(chan
, AST_FLAG_WRITE_INT
);
1547 ast_settimeout(chan
, 0, NULL
, NULL
);
1549 ast_channel_unlock(chan
);
1552 static int generator_force(const void *data
)
1554 /* Called if generator doesn't have data */
1557 int (*generate
)(struct ast_channel
*chan
, void *tmp
, int datalen
, int samples
);
1558 struct ast_channel
*chan
= (struct ast_channel
*)data
;
1560 ast_channel_lock(chan
);
1561 tmp
= chan
->generatordata
;
1562 chan
->generatordata
= NULL
;
1563 generate
= chan
->generator
->generate
;
1564 ast_channel_unlock(chan
);
1566 res
= generate(chan
, tmp
, 0, 160);
1568 chan
->generatordata
= tmp
;
1572 ast_log(LOG_DEBUG
, "Auto-deactivating generator\n");
1573 ast_deactivate_generator(chan
);
1579 int ast_activate_generator(struct ast_channel
*chan
, struct ast_generator
*gen
, void *params
)
1583 ast_channel_lock(chan
);
1585 if (chan
->generatordata
) {
1586 if (chan
->generator
&& chan
->generator
->release
)
1587 chan
->generator
->release(chan
, chan
->generatordata
);
1588 chan
->generatordata
= NULL
;
1592 if (gen
->alloc
&& !(chan
->generatordata
= gen
->alloc(chan
, params
))) {
1597 ast_settimeout(chan
, 160, generator_force
, chan
);
1598 chan
->generator
= gen
;
1601 ast_channel_unlock(chan
);
1606 /*! \brief Wait for x amount of time on a file descriptor to have input. */
1607 int ast_waitfor_n_fd(int *fds
, int n
, int *ms
, int *exception
)
1610 ast_waitfor_nandfds(NULL
, 0, fds
, n
, exception
, &winner
, ms
);
1614 /*! \brief Wait for x amount of time on a file descriptor to have input. */
1615 struct ast_channel
*ast_waitfor_nandfds(struct ast_channel
**c
, int n
, int *fds
, int nfds
,
1616 int *exception
, int *outfd
, int *ms
)
1618 struct timeval start
= { 0 , 0 };
1619 struct pollfd
*pfds
;
1625 long whentohangup
= 0, diff
;
1626 struct ast_channel
*winner
= NULL
;
1632 sz
= n
* AST_MAX_FDS
+ nfds
;
1633 pfds
= alloca(sizeof(*pfds
) * sz
);
1634 fdmap
= alloca(sizeof(*fdmap
) * sz
);
1641 /* Perform any pending masquerades */
1642 for (x
=0; x
< n
; x
++) {
1643 ast_channel_lock(c
[x
]);
1645 if (ast_do_masquerade(c
[x
])) {
1646 ast_log(LOG_WARNING
, "Masquerade failed\n");
1648 ast_channel_unlock(c
[x
]);
1652 if (c
[x
]->whentohangup
) {
1655 diff
= c
[x
]->whentohangup
- now
;
1657 /* Should already be hungup */
1658 c
[x
]->_softhangup
|= AST_SOFTHANGUP_TIMEOUT
;
1659 ast_channel_unlock(c
[x
]);
1662 if (!whentohangup
|| (diff
< whentohangup
))
1663 whentohangup
= diff
;
1665 ast_channel_unlock(c
[x
]);
1667 /* Wait full interval */
1670 rms
= whentohangup
* 1000; /* timeout in milliseconds */
1671 if (*ms
>= 0 && *ms
< rms
) /* original *ms still smaller */
1675 * Build the pollfd array, putting the channels' fds first,
1676 * followed by individual fds. Order is important because
1677 * individual fd's must have priority over channel fds.
1680 for (x
=0; x
<n
; x
++) {
1681 for (y
=0; y
<AST_MAX_FDS
; y
++) {
1682 fdmap
[max
].fdno
= y
; /* fd y is linked to this pfds */
1683 fdmap
[max
].chan
= x
; /* channel x is linked to this pfds */
1684 max
+= ast_add_fd(&pfds
[max
], c
[x
]->fds
[y
]);
1686 CHECK_BLOCKING(c
[x
]);
1688 /* Add the individual fds */
1689 for (x
=0; x
<nfds
; x
++) {
1690 fdmap
[max
].chan
= -1;
1691 max
+= ast_add_fd(&pfds
[max
], fds
[x
]);
1695 start
= ast_tvnow();
1697 if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
1702 res
= poll(pfds
, max
, kbrms
);
1705 } while (!res
&& (rms
> 0));
1707 res
= poll(pfds
, max
, rms
);
1710 ast_clear_flag(c
[x
], AST_FLAG_BLOCKING
);
1711 if (res
< 0) { /* Simulate a timeout if we were interrupted */
1716 if (whentohangup
) { /* if we have a timeout, check who expired */
1718 for (x
=0; x
<n
; x
++) {
1719 if (c
[x
]->whentohangup
&& now
>= c
[x
]->whentohangup
) {
1720 c
[x
]->_softhangup
|= AST_SOFTHANGUP_TIMEOUT
;
1726 if (res
== 0) { /* no fd ready, reset timeout and done */
1727 *ms
= 0; /* XXX use 0 since we may not have an exact timeout. */
1731 * Then check if any channel or fd has a pending event.
1732 * Remember to check channels first and fds last, as they
1733 * must have priority on setting 'winner'
1735 for (x
= 0; x
< max
; x
++) {
1736 res
= pfds
[x
].revents
;
1739 if (fdmap
[x
].chan
>= 0) { /* this is a channel */
1740 winner
= c
[fdmap
[x
].chan
]; /* override previous winners */
1742 ast_set_flag(winner
, AST_FLAG_EXCEPTION
);
1744 ast_clear_flag(winner
, AST_FLAG_EXCEPTION
);
1745 winner
->fdno
= fdmap
[x
].fdno
;
1746 } else { /* this is an fd */
1748 *outfd
= pfds
[x
].fd
;
1750 *exception
= (res
& POLLPRI
) ? -1 : 0;
1755 *ms
-= ast_tvdiff_ms(ast_tvnow(), start
);
1762 struct ast_channel
*ast_waitfor_n(struct ast_channel
**c
, int n
, int *ms
)
1764 return ast_waitfor_nandfds(c
, n
, NULL
, 0, NULL
, NULL
, ms
);
1767 int ast_waitfor(struct ast_channel
*c
, int ms
)
1769 int oldms
= ms
; /* -1 if no timeout */
1771 ast_waitfor_nandfds(&c
, 1, NULL
, 0, NULL
, NULL
, &ms
);
1772 if ((ms
< 0) && (oldms
< 0))
1777 /* XXX never to be called with ms = -1 */
1778 int ast_waitfordigit(struct ast_channel
*c
, int ms
)
1780 return ast_waitfordigit_full(c
, ms
, -1, -1);
1783 int ast_settimeout(struct ast_channel
*c
, int samples
, int (*func
)(const void *data
), void *data
)
1787 if (c
->timingfd
> -1) {
1793 ast_log(LOG_DEBUG
, "Scheduling timer at %d sample intervals\n", samples
);
1794 res
= ioctl(c
->timingfd
, ZT_TIMERCONFIG
, &samples
);
1795 c
->timingfunc
= func
;
1796 c
->timingdata
= data
;
1802 int ast_waitfordigit_full(struct ast_channel
*c
, int ms
, int audiofd
, int cmdfd
)
1804 /* Stop if we're a zombie or need a soft hangup */
1805 if (ast_test_flag(c
, AST_FLAG_ZOMBIE
) || ast_check_hangup(c
))
1808 /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
1809 ast_set_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1811 /* Wait for a digit, no more than ms milliseconds total. */
1813 struct ast_channel
*rchan
;
1817 rchan
= ast_waitfor_nandfds(&c
, 1, &cmdfd
, (cmdfd
> -1) ? 1 : 0, NULL
, &outfd
, &ms
);
1818 if (!rchan
&& outfd
< 0 && ms
) {
1819 if (errno
== 0 || errno
== EINTR
)
1821 ast_log(LOG_WARNING
, "Wait failed (%s)\n", strerror(errno
));
1822 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1824 } else if (outfd
> -1) {
1825 /* The FD we were watching has something waiting */
1826 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1830 struct ast_frame
*f
= ast_read(c
);
1834 switch(f
->frametype
) {
1835 case AST_FRAME_DTMF_BEGIN
:
1837 case AST_FRAME_DTMF_END
:
1840 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1842 case AST_FRAME_CONTROL
:
1843 switch(f
->subclass
) {
1844 case AST_CONTROL_HANGUP
:
1846 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1848 case AST_CONTROL_RINGING
:
1849 case AST_CONTROL_ANSWER
:
1853 ast_log(LOG_WARNING
, "Unexpected control subclass '%d'\n", f
->subclass
);
1857 case AST_FRAME_VOICE
:
1858 /* Write audio if appropriate */
1860 write(audiofd
, f
->data
, f
->datalen
);
1869 ast_clear_flag(c
, AST_FLAG_END_DTMF_ONLY
);
1871 return 0; /* Time is up */
1874 static void ast_read_generator_actions(struct ast_channel
*chan
, struct ast_frame
*f
)
1876 if (chan
->generatordata
&& !ast_internal_timing_enabled(chan
)) {
1877 void *tmp
= chan
->generatordata
;
1880 if (chan
->timingfunc
) {
1881 if (option_debug
> 1)
1882 ast_log(LOG_DEBUG
, "Generator got voice, switching to phase locked mode\n");
1883 ast_settimeout(chan
, 0, NULL
, NULL
);
1886 chan
->generatordata
= NULL
; /* reset, to let writes go through */
1887 res
= chan
->generator
->generate(chan
, tmp
, f
->datalen
, f
->samples
);
1888 chan
->generatordata
= tmp
;
1890 if (option_debug
> 1)
1891 ast_log(LOG_DEBUG
, "Auto-deactivating generator\n");
1892 ast_deactivate_generator(chan
);
1895 } else if (f
->frametype
== AST_FRAME_CNG
) {
1896 if (chan
->generator
&& !chan
->timingfunc
&& (chan
->timingfd
> -1)) {
1897 if (option_debug
> 1)
1898 ast_log(LOG_DEBUG
, "Generator got CNG, switching to timed mode\n");
1899 ast_settimeout(chan
, 160, generator_force
, chan
);
1904 static struct ast_frame
*__ast_read(struct ast_channel
*chan
, int dropaudio
)
1906 struct ast_frame
*f
= NULL
; /* the return value */
1911 /* this function is very long so make sure there is only one return
1912 * point at the end (there are only two exceptions to this).
1914 while(ast_channel_trylock(chan
)) {
1916 /*cannot goto done since the channel is not locked*/
1917 return &ast_null_frame
;
1922 if (ast_do_masquerade(chan
))
1923 ast_log(LOG_WARNING
, "Failed to perform masquerade\n");
1925 f
= &ast_null_frame
;
1929 /* Stop if we're a zombie or need a soft hangup */
1930 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
)) {
1931 if (chan
->generator
)
1932 ast_deactivate_generator(chan
);
1935 prestate
= chan
->_state
;
1937 if (!ast_test_flag(chan
, AST_FLAG_DEFER_DTMF
| AST_FLAG_EMULATE_DTMF
| AST_FLAG_IN_DTMF
) &&
1938 !ast_strlen_zero(chan
->dtmfq
) &&
1939 (ast_tvzero(chan
->dtmf_tv
) || ast_tvdiff_ms(ast_tvnow(), chan
->dtmf_tv
) > AST_MIN_DTMF_GAP
) ) {
1940 /* We have DTMF that has been deferred. Return it now */
1941 chan
->dtmff
.subclass
= chan
->dtmfq
[0];
1942 /* Drop first digit from the buffer */
1943 memmove(chan
->dtmfq
, chan
->dtmfq
+ 1, sizeof(chan
->dtmfq
) - 1);
1945 if (ast_test_flag(chan
, AST_FLAG_END_DTMF_ONLY
)) {
1946 ast_log(LOG_DTMF
, "DTMF end emulation of '%c' queued on %s\n", f
->subclass
, chan
->name
);
1947 chan
->dtmff
.frametype
= AST_FRAME_DTMF_END
;
1949 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
);
1950 chan
->dtmff
.frametype
= AST_FRAME_DTMF_BEGIN
;
1951 ast_set_flag(chan
, AST_FLAG_EMULATE_DTMF
);
1952 chan
->emulate_dtmf_digit
= f
->subclass
;
1953 chan
->emulate_dtmf_duration
= AST_DEFAULT_EMULATE_DTMF_DURATION
;
1955 chan
->dtmf_tv
= ast_tvnow();
1959 /* Read and ignore anything on the alertpipe, but read only
1960 one sizeof(blah) per frame that we send from it */
1961 if (chan
->alertpipe
[0] > -1)
1962 read(chan
->alertpipe
[0], &blah
, sizeof(blah
));
1965 if (chan
->timingfd
> -1 && chan
->fdno
== AST_TIMING_FD
&& ast_test_flag(chan
, AST_FLAG_EXCEPTION
)) {
1968 ast_clear_flag(chan
, AST_FLAG_EXCEPTION
);
1970 /* IF we can't get event, assume it's an expired as-per the old interface */
1971 res
= ioctl(chan
->timingfd
, ZT_GETEVENT
, &blah
);
1973 blah
= ZT_EVENT_TIMER_EXPIRED
;
1975 if (blah
== ZT_EVENT_TIMER_PING
) {
1976 if (AST_LIST_EMPTY(&chan
->readq
) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan
->readq
), frame_list
)) {
1977 /* Acknowledge PONG unless we need it again */
1978 if (ioctl(chan
->timingfd
, ZT_TIMERPONG
, &blah
)) {
1979 ast_log(LOG_WARNING
, "Failed to pong timer on '%s': %s\n", chan
->name
, strerror(errno
));
1982 } else if (blah
== ZT_EVENT_TIMER_EXPIRED
) {
1983 ioctl(chan
->timingfd
, ZT_TIMERACK
, &blah
);
1984 if (chan
->timingfunc
) {
1985 /* save a copy of func/data before unlocking the channel */
1986 int (*func
)(const void *) = chan
->timingfunc
;
1987 void *data
= chan
->timingdata
;
1988 ast_channel_unlock(chan
);
1992 ioctl(chan
->timingfd
, ZT_TIMERCONFIG
, &blah
);
1993 chan
->timingdata
= NULL
;
1994 ast_channel_unlock(chan
);
1996 /* cannot 'goto done' because the channel is already unlocked */
1997 return &ast_null_frame
;
1999 ast_log(LOG_NOTICE
, "No/unknown event '%d' on timer for '%s'?\n", blah
, chan
->name
);
2002 if (chan
->fds
[AST_GENERATOR_FD
] > -1 && chan
->fdno
== AST_GENERATOR_FD
) {
2003 /* if the AST_GENERATOR_FD is set, call the generator with args
2004 * set to -1 so it can do whatever it needs to.
2006 void *tmp
= chan
->generatordata
;
2007 chan
->generatordata
= NULL
; /* reset to let ast_write get through */
2008 chan
->generator
->generate(chan
, tmp
, -1, -1);
2009 chan
->generatordata
= tmp
;
2010 f
= &ast_null_frame
;
2014 /* Check for pending read queue */
2015 if (!AST_LIST_EMPTY(&chan
->readq
)) {
2016 f
= AST_LIST_REMOVE_HEAD(&chan
->readq
, frame_list
);
2017 /* Interpret hangup and return NULL */
2018 /* XXX why not the same for frames from the channel ? */
2019 if (f
->frametype
== AST_FRAME_CONTROL
&& f
->subclass
== AST_CONTROL_HANGUP
) {
2024 chan
->blocker
= pthread_self();
2025 if (ast_test_flag(chan
, AST_FLAG_EXCEPTION
)) {
2026 if (chan
->tech
->exception
)
2027 f
= chan
->tech
->exception(chan
);
2029 ast_log(LOG_WARNING
, "Exception flag set on '%s', but no exception handler\n", chan
->name
);
2030 f
= &ast_null_frame
;
2032 /* Clear the exception flag */
2033 ast_clear_flag(chan
, AST_FLAG_EXCEPTION
);
2034 } else if (chan
->tech
->read
)
2035 f
= chan
->tech
->read(chan
);
2037 ast_log(LOG_WARNING
, "No read routine on channel %s\n", chan
->name
);
2041 /* if the channel driver returned more than one frame, stuff the excess
2042 into the readq for the next ast_read call (note that we can safely assume
2043 that the readq is empty, because otherwise we would not have called into
2044 the channel driver and f would be only a single frame)
2046 if (AST_LIST_NEXT(f
, frame_list
)) {
2047 AST_LIST_HEAD_SET_NOLOCK(&chan
->readq
, AST_LIST_NEXT(f
, frame_list
));
2048 AST_LIST_NEXT(f
, frame_list
) = NULL
;
2051 switch (f
->frametype
) {
2052 case AST_FRAME_CONTROL
:
2053 if (f
->subclass
== AST_CONTROL_ANSWER
) {
2054 if (!ast_test_flag(chan
, AST_FLAG_OUTGOING
)) {
2056 ast_log(LOG_DEBUG
, "Ignoring answer on an inbound call!\n");
2058 f
= &ast_null_frame
;
2059 } else if (prestate
== AST_STATE_UP
) {
2061 ast_log(LOG_DEBUG
, "Dropping duplicate answer!\n");
2063 f
= &ast_null_frame
;
2065 /* Answer the CDR */
2066 ast_setstate(chan
, AST_STATE_UP
);
2067 if (!chan
->cdr
) { /* up till now, this insertion hasn't been done. Therefore,
2068 to keep from throwing off the basic order of the universe,
2069 we will try to keep this cdr from getting posted. */
2070 chan
->cdr
= ast_cdr_alloc();
2071 ast_cdr_init(chan
->cdr
, chan
);
2072 ast_cdr_start(chan
->cdr
);
2075 ast_cdr_answer(chan
->cdr
);
2079 case AST_FRAME_DTMF_END
:
2080 ast_log(LOG_DTMF
, "DTMF end '%c' received on %s, duration %ld ms\n", f
->subclass
, chan
->name
, f
->len
);
2081 /* Queue it up if DTMF is deffered, or if DTMF emulation is forced.
2082 * However, only let emulation be forced if the other end cares about BEGIN frames */
2083 if ( ast_test_flag(chan
, AST_FLAG_DEFER_DTMF
) ||
2084 (ast_test_flag(chan
, AST_FLAG_EMULATE_DTMF
) && !ast_test_flag(chan
, AST_FLAG_END_DTMF_ONLY
)) ) {
2085 if (strlen(chan
->dtmfq
) < sizeof(chan
->dtmfq
) - 2) {
2086 ast_log(LOG_DTMF
, "DTMF end '%c' put into dtmf queue on %s\n", f
->subclass
, chan
->name
);
2087 chan
->dtmfq
[strlen(chan
->dtmfq
)] = f
->subclass
;
2089 ast_log(LOG_WARNING
, "Dropping deferred DTMF digits on %s\n", chan
->name
);
2091 f
= &ast_null_frame
;
2092 } else if (!ast_test_flag(chan
, AST_FLAG_IN_DTMF
| AST_FLAG_END_DTMF_ONLY
)) {
2093 if (!ast_tvzero(chan
->dtmf_tv
) &&
2094 ast_tvdiff_ms(ast_tvnow(), chan
->dtmf_tv
) < AST_MIN_DTMF_GAP
) {
2095 /* If it hasn't been long enough, defer this digit */
2096 if (strlen(chan
->dtmfq
) < sizeof(chan
->dtmfq
) - 2) {
2097 ast_log(LOG_DTMF
, "DTMF end '%c' put into dtmf queue on %s\n", f
->subclass
, chan
->name
);
2098 chan
->dtmfq
[strlen(chan
->dtmfq
)] = f
->subclass
;
2100 ast_log(LOG_WARNING
, "Dropping deferred DTMF digits on %s\n", chan
->name
);
2102 f
= &ast_null_frame
;
2104 /* There was no begin, turn this into a begin and send the end later */
2105 f
->frametype
= AST_FRAME_DTMF_BEGIN
;
2106 ast_set_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2107 chan
->emulate_dtmf_digit
= f
->subclass
;
2108 chan
->dtmf_tv
= ast_tvnow();
2110 if (f
->len
> AST_MIN_DTMF_DURATION
)
2111 chan
->emulate_dtmf_duration
= f
->len
;
2113 chan
->emulate_dtmf_duration
= AST_MIN_DTMF_DURATION
;
2115 chan
->emulate_dtmf_duration
= AST_DEFAULT_EMULATE_DTMF_DURATION
;
2116 ast_log(LOG_DTMF
, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f
->subclass
, chan
->emulate_dtmf_duration
, chan
->name
);
2118 if (chan
->audiohooks
) {
2119 struct ast_frame
*old_frame
= f
;
2120 f
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_READ
, f
);
2122 ast_frfree(old_frame
);
2125 struct timeval now
= ast_tvnow();
2126 if (ast_test_flag(chan
, AST_FLAG_IN_DTMF
)) {
2127 ast_log(LOG_DTMF
, "DTMF end accepted with begin '%c' on %s\n", f
->subclass
, chan
->name
);
2128 ast_clear_flag(chan
, AST_FLAG_IN_DTMF
);
2130 f
->len
= ast_tvdiff_ms(now
, chan
->dtmf_tv
);
2131 } else if (!f
->len
) {
2132 ast_log(LOG_DTMF
, "DTMF end accepted without begin '%c' on %s\n", f
->subclass
, chan
->name
);
2133 f
->len
= AST_MIN_DTMF_DURATION
;
2135 if (f
->len
< AST_MIN_DTMF_DURATION
) {
2136 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
);
2137 ast_set_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2138 chan
->emulate_dtmf_digit
= f
->subclass
;
2139 chan
->emulate_dtmf_duration
= AST_MIN_DTMF_DURATION
- f
->len
;
2141 f
= &ast_null_frame
;
2143 ast_log(LOG_DTMF
, "DTMF end passthrough '%c' on %s\n", f
->subclass
, chan
->name
);
2144 chan
->dtmf_tv
= now
;
2146 if (chan
->audiohooks
) {
2147 struct ast_frame
*old_frame
= f
;
2148 f
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_READ
, f
);
2150 ast_frfree(old_frame
);
2154 case AST_FRAME_DTMF_BEGIN
:
2155 ast_log(LOG_DTMF
, "DTMF begin '%c' received on %s\n", f
->subclass
, chan
->name
);
2156 if ( ast_test_flag(chan
, AST_FLAG_DEFER_DTMF
| AST_FLAG_END_DTMF_ONLY
) ||
2157 (!ast_tvzero(chan
->dtmf_tv
) &&
2158 ast_tvdiff_ms(ast_tvnow(), chan
->dtmf_tv
) < AST_MIN_DTMF_GAP
) ) {
2159 ast_log(LOG_DTMF
, "DTMF begin ignored '%c' on %s\n", f
->subclass
, chan
->name
);
2161 f
= &ast_null_frame
;
2163 ast_set_flag(chan
, AST_FLAG_IN_DTMF
);
2164 chan
->dtmf_tv
= ast_tvnow();
2165 ast_log(LOG_DTMF
, "DTMF begin passthrough '%c' on %s\n", f
->subclass
, chan
->name
);
2168 case AST_FRAME_NULL
:
2169 if (ast_test_flag(chan
, AST_FLAG_EMULATE_DTMF
)) {
2170 struct timeval now
= ast_tvnow();
2171 if (ast_tvdiff_ms(now
, chan
->dtmf_tv
) >= chan
->emulate_dtmf_duration
) {
2172 chan
->emulate_dtmf_duration
= 0;
2175 f
->frametype
= AST_FRAME_DTMF_END
;
2176 f
->subclass
= chan
->emulate_dtmf_digit
;
2177 f
->len
= ast_tvdiff_ms(now
, chan
->dtmf_tv
);
2178 chan
->dtmf_tv
= now
;
2179 ast_clear_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2180 chan
->emulate_dtmf_digit
= 0;
2181 ast_log(LOG_DTMF
, "DTMF end emulation of '%c' queued on %s\n", f
->subclass
, chan
->name
);
2185 case AST_FRAME_VOICE
:
2186 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
2187 * is reached , because we want to make sure we pass at least one
2188 * voice frame through before starting the next digit, to ensure a gap
2189 * between DTMF digits. */
2190 if (ast_test_flag(chan
, AST_FLAG_EMULATE_DTMF
) && !chan
->emulate_dtmf_duration
) {
2191 ast_clear_flag(chan
, AST_FLAG_EMULATE_DTMF
);
2192 chan
->emulate_dtmf_digit
= 0;
2195 if (dropaudio
|| ast_test_flag(chan
, AST_FLAG_IN_DTMF
)) {
2197 ast_read_generator_actions(chan
, f
);
2199 f
= &ast_null_frame
;
2202 if (ast_test_flag(chan
, AST_FLAG_EMULATE_DTMF
) && !ast_test_flag(chan
, AST_FLAG_IN_DTMF
)) {
2203 struct timeval now
= ast_tvnow();
2204 if (ast_tvdiff_ms(now
, chan
->dtmf_tv
) >= chan
->emulate_dtmf_duration
) {
2205 chan
->emulate_dtmf_duration
= 0;
2208 f
->frametype
= AST_FRAME_DTMF_END
;
2209 f
->subclass
= chan
->emulate_dtmf_digit
;
2210 f
->len
= ast_tvdiff_ms(now
, chan
->dtmf_tv
);
2211 chan
->dtmf_tv
= now
;
2212 if (chan
->audiohooks
) {
2213 struct ast_frame
*old_frame
= f
;
2214 f
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_READ
, f
);
2216 ast_frfree(old_frame
);
2218 ast_log(LOG_DTMF
, "DTMF end emulation of '%c' queued on %s\n", f
->subclass
, chan
->name
);
2220 /* Drop voice frames while we're still in the middle of the digit */
2222 f
= &ast_null_frame
;
2224 } else if ((f
->frametype
== AST_FRAME_VOICE
) && !(f
->subclass
& chan
->nativeformats
)) {
2225 /* This frame can't be from the current native formats -- drop it on the
2227 ast_log(LOG_NOTICE
, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n",
2228 chan
->name
, ast_getformatname(f
->subclass
), ast_getformatname(chan
->nativeformats
));
2230 f
= &ast_null_frame
;
2231 } else if ((f
->frametype
== AST_FRAME_VOICE
)) {
2232 if (chan
->audiohooks
) {
2233 struct ast_frame
*old_frame
= f
;
2234 f
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_READ
, f
);
2236 ast_frfree(old_frame
);
2238 if (chan
->monitor
&& chan
->monitor
->read_stream
) {
2239 /* XXX what does this do ? */
2240 #ifndef MONITOR_CONSTANT_DELAY
2241 int jump
= chan
->outsmpl
- chan
->insmpl
- 4 * f
->samples
;
2243 jump
= chan
->outsmpl
- chan
->insmpl
;
2244 if (ast_seekstream(chan
->monitor
->read_stream
, jump
, SEEK_FORCECUR
) == -1)
2245 ast_log(LOG_WARNING
, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2246 chan
->insmpl
+= jump
+ f
->samples
;
2248 chan
->insmpl
+= f
->samples
;
2250 int jump
= chan
->outsmpl
- chan
->insmpl
;
2251 if (jump
- MONITOR_DELAY
>= 0) {
2252 if (ast_seekstream(chan
->monitor
->read_stream
, jump
- f
->samples
, SEEK_FORCECUR
) == -1)
2253 ast_log(LOG_WARNING
, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
2254 chan
->insmpl
+= jump
;
2256 chan
->insmpl
+= f
->samples
;
2258 if (chan
->monitor
->state
== AST_MONITOR_RUNNING
) {
2259 if (ast_writestream(chan
->monitor
->read_stream
, f
) < 0)
2260 ast_log(LOG_WARNING
, "Failed to write data to channel monitor read stream\n");
2264 if (chan
->readtrans
&& (f
= ast_translate(chan
->readtrans
, f
, 1)) == NULL
)
2265 f
= &ast_null_frame
;
2267 /* Run generator sitting on the line if timing device not available
2268 * and synchronous generation of outgoing frames is necessary */
2269 ast_read_generator_actions(chan
, f
);
2272 /* Just pass it on! */
2276 /* Make sure we always return NULL in the future */
2277 chan
->_softhangup
|= AST_SOFTHANGUP_DEV
;
2278 if (chan
->generator
)
2279 ast_deactivate_generator(chan
);
2280 /* End the CDR if appropriate */
2282 ast_cdr_end(chan
->cdr
);
2285 /* High bit prints debugging */
2286 if (chan
->fin
& DEBUGCHAN_FLAG
)
2287 ast_frame_dump(chan
->name
, f
, "<<");
2288 chan
->fin
= FRAMECOUNT_INC(chan
->fin
);
2291 ast_channel_unlock(chan
);
2295 int ast_internal_timing_enabled(struct ast_channel
*chan
)
2297 int ret
= ast_opt_internal_timing
&& chan
->timingfd
> -1;
2298 if (option_debug
> 4)
2299 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
);
2303 struct ast_frame
*ast_read(struct ast_channel
*chan
)
2305 return __ast_read(chan
, 0);
2308 struct ast_frame
*ast_read_noaudio(struct ast_channel
*chan
)
2310 return __ast_read(chan
, 1);
2313 int ast_indicate(struct ast_channel
*chan
, int condition
)
2315 return ast_indicate_data(chan
, condition
, NULL
, 0);
2318 int ast_indicate_data(struct ast_channel
*chan
, int condition
, const void *data
, size_t datalen
)
2322 ast_channel_lock(chan
);
2323 /* Stop if we're a zombie or need a soft hangup */
2324 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
)) {
2325 ast_channel_unlock(chan
);
2328 if (chan
->tech
->indicate
)
2329 res
= chan
->tech
->indicate(chan
, condition
, data
, datalen
);
2330 ast_channel_unlock(chan
);
2331 if (!chan
->tech
->indicate
|| res
) {
2333 * Device does not support (that) indication, lets fake
2334 * it by doing our own tone generation. (PM2002)
2337 ast_playtones_stop(chan
);
2339 const struct tone_zone_sound
*ts
= NULL
;
2340 switch (condition
) {
2341 case AST_CONTROL_RINGING
:
2342 ts
= ast_get_indication_tone(chan
->zone
, "ring");
2344 case AST_CONTROL_BUSY
:
2345 ts
= ast_get_indication_tone(chan
->zone
, "busy");
2347 case AST_CONTROL_CONGESTION
:
2348 ts
= ast_get_indication_tone(chan
->zone
, "congestion");
2351 if (ts
&& ts
->data
[0]) {
2353 ast_log(LOG_DEBUG
, "Driver for channel '%s' does not support indication %d, emulating it\n", chan
->name
, condition
);
2354 ast_playtones_start(chan
,0,ts
->data
, 1);
2356 chan
->visible_indication
= condition
;
2357 } else if (condition
== AST_CONTROL_PROGRESS
) {
2358 /* ast_playtones_stop(chan); */
2359 } else if (condition
== AST_CONTROL_PROCEEDING
) {
2360 /* Do nothing, really */
2361 } else if (condition
== AST_CONTROL_HOLD
) {
2362 /* Do nothing.... */
2363 } else if (condition
== AST_CONTROL_UNHOLD
) {
2364 /* Do nothing.... */
2365 } else if (condition
== AST_CONTROL_VIDUPDATE
) {
2366 /* Do nothing.... */
2369 ast_log(LOG_WARNING
, "Unable to handle indication %d for '%s'\n", condition
, chan
->name
);
2374 chan
->visible_indication
= condition
;
2379 int ast_recvchar(struct ast_channel
*chan
, int timeout
)
2382 char *buf
= ast_recvtext(chan
, timeout
);
2384 return -1; /* error or timeout */
2385 c
= *(unsigned char *)buf
;
2390 char *ast_recvtext(struct ast_channel
*chan
, int timeout
)
2396 struct ast_frame
*f
;
2397 if (ast_check_hangup(chan
))
2399 res
= ast_waitfor(chan
, timeout
);
2400 if (res
<= 0) /* timeout or error */
2402 timeout
= res
; /* update timeout */
2405 break; /* no frame */
2406 if (f
->frametype
== AST_FRAME_CONTROL
&& f
->subclass
== AST_CONTROL_HANGUP
)
2407 done
= 1; /* force a break */
2408 else if (f
->frametype
== AST_FRAME_TEXT
) { /* what we want */
2409 buf
= ast_strndup((char *) f
->data
, f
->datalen
); /* dup and break */
2417 int ast_sendtext(struct ast_channel
*chan
, const char *text
)
2420 /* Stop if we're a zombie or need a soft hangup */
2421 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
))
2423 CHECK_BLOCKING(chan
);
2424 if (chan
->tech
->send_text
)
2425 res
= chan
->tech
->send_text(chan
, text
);
2426 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2430 int ast_senddigit_begin(struct ast_channel
*chan
, char digit
)
2432 /* Device does not support DTMF tones, lets fake
2433 * it by doing our own generation. */
2434 static const char* dtmf_tones
[] = {
2453 if (!chan
->tech
->send_digit_begin
)
2456 if (!chan
->tech
->send_digit_begin(chan
, digit
))
2459 if (digit
>= '0' && digit
<='9')
2460 ast_playtones_start(chan
, 0, dtmf_tones
[digit
-'0'], 0);
2461 else if (digit
>= 'A' && digit
<= 'D')
2462 ast_playtones_start(chan
, 0, dtmf_tones
[digit
-'A'+10], 0);
2463 else if (digit
== '*')
2464 ast_playtones_start(chan
, 0, dtmf_tones
[14], 0);
2465 else if (digit
== '#')
2466 ast_playtones_start(chan
, 0, dtmf_tones
[15], 0);
2470 ast_log(LOG_DEBUG
, "Unable to generate DTMF tone '%c' for '%s'\n", digit
, chan
->name
);
2476 int ast_senddigit_end(struct ast_channel
*chan
, char digit
, unsigned int duration
)
2480 if (chan
->tech
->send_digit_end
)
2481 res
= chan
->tech
->send_digit_end(chan
, digit
, duration
);
2483 if (res
&& chan
->generator
)
2484 ast_playtones_stop(chan
);
2489 int ast_senddigit(struct ast_channel
*chan
, char digit
)
2491 if (chan
->tech
->send_digit_begin
) {
2492 ast_senddigit_begin(chan
, digit
);
2493 ast_safe_sleep(chan
, AST_DEFAULT_EMULATE_DTMF_DURATION
);
2496 return ast_senddigit_end(chan
, digit
, AST_DEFAULT_EMULATE_DTMF_DURATION
);
2499 int ast_prod(struct ast_channel
*chan
)
2501 struct ast_frame a
= { AST_FRAME_VOICE
};
2504 /* Send an empty audio frame to get things moving */
2505 if (chan
->_state
!= AST_STATE_UP
) {
2507 ast_log(LOG_DEBUG
, "Prodding channel '%s'\n", chan
->name
);
2508 a
.subclass
= chan
->rawwriteformat
;
2509 a
.data
= nothing
+ AST_FRIENDLY_OFFSET
;
2511 if (ast_write(chan
, &a
))
2512 ast_log(LOG_WARNING
, "Prodding channel '%s' failed\n", chan
->name
);
2517 int ast_write_video(struct ast_channel
*chan
, struct ast_frame
*fr
)
2520 if (!chan
->tech
->write_video
)
2522 res
= ast_write(chan
, fr
);
2528 int ast_write(struct ast_channel
*chan
, struct ast_frame
*fr
)
2532 struct ast_frame
*f
= NULL
, *f2
= NULL
;
2534 /*Deadlock avoidance*/
2535 while(ast_channel_trylock(chan
)) {
2536 /*cannot goto done since the channel is not locked*/
2539 ast_log(LOG_DEBUG
, "Deadlock avoided for write to channel '%s'\n", chan
->name
);
2544 /* Stop if we're a zombie or need a soft hangup */
2545 if (ast_test_flag(chan
, AST_FLAG_ZOMBIE
) || ast_check_hangup(chan
))
2548 /* Handle any pending masquerades */
2549 if (chan
->masq
&& ast_do_masquerade(chan
)) {
2550 ast_log(LOG_WARNING
, "Failed to perform masquerade\n");
2554 res
= 0; /* XXX explain, why 0 ? */
2557 if (chan
->generatordata
) {
2558 if (ast_test_flag(chan
, AST_FLAG_WRITE_INT
))
2559 ast_deactivate_generator(chan
);
2561 if (fr
->frametype
== AST_FRAME_DTMF_END
) {
2562 /* There is a generator running while we're in the middle of a digit.
2563 * It's probably inband DTMF, so go ahead and pass it so it can
2564 * stop the generator */
2565 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2566 ast_channel_unlock(chan
);
2567 res
= ast_senddigit_end(chan
, fr
->subclass
, fr
->len
);
2568 ast_channel_lock(chan
);
2569 CHECK_BLOCKING(chan
);
2570 } else if (fr
->frametype
== AST_FRAME_CONTROL
&& fr
->subclass
== AST_CONTROL_UNHOLD
) {
2571 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
2572 res
= (chan
->tech
->indicate
== NULL
) ? 0 :
2573 chan
->tech
->indicate(chan
, fr
->subclass
, fr
->data
, fr
->datalen
);
2575 res
= 0; /* XXX explain, why 0 ? */
2579 /* High bit prints debugging */
2580 if (chan
->fout
& DEBUGCHAN_FLAG
)
2581 ast_frame_dump(chan
->name
, fr
, ">>");
2582 CHECK_BLOCKING(chan
);
2583 switch(fr
->frametype
) {
2584 case AST_FRAME_CONTROL
:
2585 res
= (chan
->tech
->indicate
== NULL
) ? 0 :
2586 chan
->tech
->indicate(chan
, fr
->subclass
, fr
->data
, fr
->datalen
);
2588 case AST_FRAME_DTMF_BEGIN
:
2589 if (chan
->audiohooks
) {
2590 struct ast_frame
*old_frame
= fr
;
2591 fr
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_WRITE
, fr
);
2592 if (old_frame
!= fr
)
2595 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2596 ast_channel_unlock(chan
);
2597 res
= ast_senddigit_begin(chan
, fr
->subclass
);
2598 ast_channel_lock(chan
);
2599 CHECK_BLOCKING(chan
);
2601 case AST_FRAME_DTMF_END
:
2602 if (chan
->audiohooks
) {
2603 struct ast_frame
*old_frame
= fr
;
2604 fr
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_WRITE
, fr
);
2605 if (old_frame
!= fr
)
2608 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2609 ast_channel_unlock(chan
);
2610 res
= ast_senddigit_end(chan
, fr
->subclass
, fr
->len
);
2611 ast_channel_lock(chan
);
2612 CHECK_BLOCKING(chan
);
2614 case AST_FRAME_TEXT
:
2615 res
= (chan
->tech
->send_text
== NULL
) ? 0 :
2616 chan
->tech
->send_text(chan
, (char *) fr
->data
);
2618 case AST_FRAME_HTML
:
2619 res
= (chan
->tech
->send_html
== NULL
) ? 0 :
2620 chan
->tech
->send_html(chan
, fr
->subclass
, (char *) fr
->data
, fr
->datalen
);
2622 case AST_FRAME_VIDEO
:
2623 /* XXX Handle translation of video codecs one day XXX */
2624 res
= (chan
->tech
->write_video
== NULL
) ? 0 :
2625 chan
->tech
->write_video(chan
, fr
);
2627 case AST_FRAME_MODEM
:
2628 res
= (chan
->tech
->write
== NULL
) ? 0 :
2629 chan
->tech
->write(chan
, fr
);
2631 case AST_FRAME_VOICE
:
2632 if (chan
->tech
->write
== NULL
)
2633 break; /*! \todo XXX should return 0 maybe ? */
2635 if (chan
->audiohooks
) {
2636 struct ast_frame
*old_frame
= fr
;
2637 fr
= ast_audiohook_write_list(chan
, chan
->audiohooks
, AST_AUDIOHOOK_DIRECTION_WRITE
, fr
);
2638 if (old_frame
!= fr
)
2642 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
2643 if (fr
->subclass
== chan
->rawwriteformat
)
2646 f
= (chan
->writetrans
) ? ast_translate(chan
->writetrans
, fr
, 0) : fr
;
2648 /* If we have no frame of audio, then we have to bail out */
2654 /* If Monitor is running on this channel, then we have to write frames out there too */
2655 if (chan
->monitor
&& chan
->monitor
->write_stream
) {
2656 /* XXX must explain this code */
2657 #ifndef MONITOR_CONSTANT_DELAY
2658 int jump
= chan
->insmpl
- chan
->outsmpl
- 4 * f
->samples
;
2660 jump
= chan
->insmpl
- chan
->outsmpl
;
2661 if (ast_seekstream(chan
->monitor
->write_stream
, jump
, SEEK_FORCECUR
) == -1)
2662 ast_log(LOG_WARNING
, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2663 chan
->outsmpl
+= jump
+ f
->samples
;
2665 chan
->outsmpl
+= f
->samples
;
2667 int jump
= chan
->insmpl
- chan
->outsmpl
;
2668 if (jump
- MONITOR_DELAY
>= 0) {
2669 if (ast_seekstream(chan
->monitor
->write_stream
, jump
- f
->samples
, SEEK_FORCECUR
) == -1)
2670 ast_log(LOG_WARNING
, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
2671 chan
->outsmpl
+= jump
;
2673 chan
->outsmpl
+= f
->samples
;
2675 if (chan
->monitor
->state
== AST_MONITOR_RUNNING
) {
2676 if (ast_writestream(chan
->monitor
->write_stream
, f
) < 0)
2677 ast_log(LOG_WARNING
, "Failed to write data to channel monitor write stream\n");
2682 res
= chan
->tech
->write(chan
,f
);
2686 case AST_FRAME_NULL
:
2692 /* At this point, fr is the incoming frame and f is NULL. Channels do
2693 * not expect to get NULL as a frame pointer and will segfault. Hence,
2694 * we output the original frame passed in. */
2695 res
= chan
->tech
->write(chan
, fr
);
2703 ast_clear_flag(chan
, AST_FLAG_BLOCKING
);
2704 /* Consider a write failure to force a soft hangup */
2706 chan
->_softhangup
|= AST_SOFTHANGUP_DEV
;
2708 chan
->fout
= FRAMECOUNT_INC(chan
->fout
);
2711 ast_channel_unlock(chan
);
2715 static int set_format(struct ast_channel
*chan
, int fmt
, int *rawformat
, int *format
,
2716 struct ast_trans_pvt
**trans
, const int direction
)
2721 /* Make sure we only consider audio */
2722 fmt
&= AST_FORMAT_AUDIO_MASK
;
2724 native
= chan
->nativeformats
;
2725 /* Find a translation path from the native format to one of the desired formats */
2728 res
= ast_translator_best_choice(&fmt
, &native
);
2731 res
= ast_translator_best_choice(&native
, &fmt
);
2734 ast_log(LOG_WARNING
, "Unable to find a codec translation path from %s to %s\n",
2735 ast_getformatname(native
), ast_getformatname(fmt
));
2739 /* Now we have a good choice for both. */
2740 ast_channel_lock(chan
);
2742 if ((*rawformat
== native
) && (*format
== fmt
) && ((*rawformat
== *format
) || (*trans
))) {
2743 /* the channel is already in these formats, so nothing to do */
2744 ast_channel_unlock(chan
);
2748 *rawformat
= native
;
2749 /* User perspective is fmt */
2751 /* Free any read translation we have right now */
2753 ast_translator_free_path(*trans
);
2754 /* Build a translation path from the raw format to the desired format */
2757 *trans
= ast_translator_build_path(*format
, *rawformat
);
2760 *trans
= ast_translator_build_path(*rawformat
, *format
);
2761 ast_channel_unlock(chan
);
2763 ast_log(LOG_DEBUG
, "Set channel %s to %s format %s\n", chan
->name
,
2764 direction
? "write" : "read", ast_getformatname(fmt
));
2768 int ast_set_read_format(struct ast_channel
*chan
, int fmt
)
2770 return set_format(chan
, fmt
, &chan
->rawreadformat
, &chan
->readformat
,
2771 &chan
->readtrans
, 0);
2774 int ast_set_write_format(struct ast_channel
*chan
, int fmt
)
2776 return set_format(chan
, fmt
, &chan
->rawwriteformat
, &chan
->writeformat
,
2777 &chan
->writetrans
, 1);
2780 char *ast_channel_reason2str(int reason
)
2782 switch (reason
) /* the following appear to be the only ones actually returned by request_and_dial */
2785 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
2786 case AST_CONTROL_HANGUP
:
2788 case AST_CONTROL_RING
:
2789 return "Local Ring";
2790 case AST_CONTROL_RINGING
:
2791 return "Remote end Ringing";
2792 case AST_CONTROL_ANSWER
:
2793 return "Remote end has Answered";
2794 case AST_CONTROL_BUSY
:
2795 return "Remote end is Busy";
2796 case AST_CONTROL_CONGESTION
:
2797 return "Congestion (circuits busy)";
2799 return "Unknown Reason!!";
2803 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
)
2807 struct ast_channel
*chan
;
2809 int last_subclass
= 0;
2814 outstate
= &dummy_outstate
; /* make outstate always a valid pointer */
2816 chan
= ast_request(type
, format
, data
, &cause
);
2818 ast_log(LOG_NOTICE
, "Unable to request channel %s/%s\n", type
, (char *)data
);
2819 /* compute error and return */
2820 if (cause
== AST_CAUSE_BUSY
)
2821 *outstate
= AST_CONTROL_BUSY
;
2822 else if (cause
== AST_CAUSE_CONGESTION
)
2823 *outstate
= AST_CONTROL_CONGESTION
;
2829 ast_set_variables(chan
, oh
->vars
);
2830 /* XXX why is this necessary, for the parent_channel perhaps ? */
2831 if (!ast_strlen_zero(oh
->cid_num
) && !ast_strlen_zero(oh
->cid_name
))
2832 ast_set_callerid(chan
, oh
->cid_num
, oh
->cid_name
, oh
->cid_num
);
2833 if (oh
->parent_channel
)
2834 ast_channel_inherit_variables(oh
->parent_channel
, chan
);
2836 ast_cdr_setaccount(chan
, oh
->account
);
2838 ast_set_callerid(chan
, cid_num
, cid_name
, cid_num
);
2842 if (!chan
->cdr
) { /* up till now, this insertion hasn't been done. Therefore,
2843 to keep from throwing off the basic order of the universe,
2844 we will try to keep this cdr from getting posted. */
2845 chan
->cdr
= ast_cdr_alloc();
2846 ast_cdr_init(chan
->cdr
, chan
);
2847 ast_cdr_start(chan
->cdr
);
2849 if (ast_call(chan
, data
, 0)) { /* ast_call failed... */
2850 ast_log(LOG_NOTICE
, "Unable to call channel %s/%s\n", type
, (char *)data
);
2852 res
= 1; /* mark success in case chan->_state is already AST_STATE_UP */
2853 while (timeout
&& chan
->_state
!= AST_STATE_UP
) {
2854 struct ast_frame
*f
;
2855 res
= ast_waitfor(chan
, timeout
);
2856 if (res
<= 0) /* error, timeout, or done */
2862 *outstate
= AST_CONTROL_HANGUP
;
2866 if (f
->frametype
== AST_FRAME_CONTROL
) {
2867 switch (f
->subclass
) {
2868 case AST_CONTROL_RINGING
: /* record but keep going */
2869 *outstate
= f
->subclass
;
2872 case AST_CONTROL_BUSY
:
2873 case AST_CONTROL_CONGESTION
:
2874 case AST_CONTROL_ANSWER
:
2875 *outstate
= f
->subclass
;
2876 timeout
= 0; /* trick to force exit from the while() */
2880 case AST_CONTROL_PROGRESS
:
2881 case AST_CONTROL_PROCEEDING
:
2882 case AST_CONTROL_HOLD
:
2883 case AST_CONTROL_UNHOLD
:
2884 case AST_CONTROL_VIDUPDATE
:
2885 case -1: /* Ignore -- just stopping indications */
2889 ast_log(LOG_NOTICE
, "Don't know what to do with control frame %d\n", f
->subclass
);
2891 last_subclass
= f
->subclass
;
2899 if (!ast_strlen_zero(oh
->context
))
2900 ast_copy_string(chan
->context
, oh
->context
, sizeof(chan
->context
));
2901 if (!ast_strlen_zero(oh
->exten
))
2902 ast_copy_string(chan
->exten
, oh
->exten
, sizeof(chan
->exten
));
2904 chan
->priority
= oh
->priority
;
2906 if (chan
->_state
== AST_STATE_UP
)
2907 *outstate
= AST_CONTROL_ANSWER
;
2910 if ( AST_CONTROL_RINGING
== last_subclass
)
2911 chan
->hangupcause
= AST_CAUSE_NO_ANSWER
;
2912 if (!chan
->cdr
&& (chan
->cdr
= ast_cdr_alloc()))
2913 ast_cdr_init(chan
->cdr
, chan
);
2916 snprintf(tmp
, sizeof(tmp
), "%s/%s", type
, (char *)data
);
2917 ast_cdr_setapp(chan
->cdr
,"Dial",tmp
);
2918 ast_cdr_update(chan
);
2919 ast_cdr_start(chan
->cdr
);
2920 ast_cdr_end(chan
->cdr
);
2921 /* If the cause wasn't handled properly */
2922 if (ast_cdr_disposition(chan
->cdr
,chan
->hangupcause
))
2923 ast_cdr_failed(chan
->cdr
);
2931 struct ast_channel
*ast_request_and_dial(const char *type
, int format
, void *data
, int timeout
, int *outstate
, const char *cidnum
, const char *cidname
)
2933 return __ast_request_and_dial(type
, format
, data
, timeout
, outstate
, cidnum
, cidname
, NULL
);
2936 struct ast_channel
*ast_request(const char *type
, int format
, void *data
, int *cause
)
2938 struct chanlist
*chan
;
2939 struct ast_channel
*c
;
2944 int videoformat
= format
& AST_FORMAT_VIDEO_MASK
;
2948 *cause
= AST_CAUSE_NOTDEFINED
;
2950 if (AST_LIST_LOCK(&channels
)) {
2951 ast_log(LOG_WARNING
, "Unable to lock channel list\n");
2955 AST_LIST_TRAVERSE(&backends
, chan
, list
) {
2956 if (strcasecmp(type
, chan
->tech
->type
))
2959 capabilities
= chan
->tech
->capabilities
;
2960 fmt
= format
& AST_FORMAT_AUDIO_MASK
;
2961 res
= ast_translator_best_choice(&fmt
, &capabilities
);
2963 ast_log(LOG_WARNING
, "No translator path exists for channel type %s (native %d) to %d\n", type
, chan
->tech
->capabilities
, format
);
2964 *cause
= AST_CAUSE_BEARERCAPABILITY_NOTAVAIL
;
2965 AST_LIST_UNLOCK(&channels
);
2968 AST_LIST_UNLOCK(&channels
);
2969 if (!chan
->tech
->requester
)
2972 if (!(c
= chan
->tech
->requester(type
, capabilities
| videoformat
, data
, cause
)))
2975 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
2979 ast_log(LOG_WARNING
, "No channel type registered for '%s'\n", type
);
2980 *cause
= AST_CAUSE_NOSUCHDRIVER
;
2981 AST_LIST_UNLOCK(&channels
);
2986 int ast_call(struct ast_channel
*chan
, char *addr
, int timeout
)
2988 /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
2989 If the remote end does not answer within the timeout, then do NOT hang up, but
2992 /* Stop if we're a zombie or need a soft hangup */
2993 ast_channel_lock(chan
);
2994 if (!ast_test_flag(chan
, AST_FLAG_ZOMBIE
) && !ast_check_hangup(chan
)) {
2995 if (chan
->tech
->call
)
2996 res
= chan
->tech
->call(chan
, addr
, timeout
);
2997 ast_set_flag(chan
, AST_FLAG_OUTGOING
);
2999 ast_channel_unlock(chan
);
3004 \brief Transfer a call to dest, if the channel supports transfer
3008 \arg the manager interface
3010 int ast_transfer(struct ast_channel
*chan
, char *dest
)
3014 /* Stop if we're a zombie or need a soft hangup */
3015 ast_channel_lock(chan
);
3016 if (!ast_test_flag(chan
, AST_FLAG_ZOMBIE
) && !ast_check_hangup(chan
)) {
3017 if (chan
->tech
->transfer
) {
3018 res
= chan
->tech
->transfer(chan
, dest
);
3024 ast_channel_unlock(chan
);
3028 int ast_readstring(struct ast_channel
*c
, char *s
, int len
, int timeout
, int ftimeout
, char *enders
)
3030 return ast_readstring_full(c
, s
, len
, timeout
, ftimeout
, enders
, -1, -1);
3033 int ast_readstring_full(struct ast_channel
*c
, char *s
, int len
, int timeout
, int ftimeout
, char *enders
, int audiofd
, int ctrlfd
)
3035 int pos
= 0; /* index in the buffer where we accumulate digits */
3038 /* Stop if we're a zombie or need a soft hangup */
3039 if (ast_test_flag(c
, AST_FLAG_ZOMBIE
) || ast_check_hangup(c
))
3046 d
= ast_waitstream_full(c
, AST_DIGIT_ANY
, audiofd
, ctrlfd
);
3050 d
= ast_waitfordigit_full(c
, to
, audiofd
, ctrlfd
);
3052 d
= ast_waitfordigit_full(c
, to
, audiofd
, ctrlfd
);
3064 if (!strchr(enders
, d
))
3066 if (strchr(enders
, d
) || (pos
>= len
)) {
3076 int ast_channel_supports_html(struct ast_channel
*chan
)
3078 return (chan
->tech
->send_html
) ? 1 : 0;
3081 int ast_channel_sendhtml(struct ast_channel
*chan
, int subclass
, const char *data
, int datalen
)
3083 if (chan
->tech
->send_html
)
3084 return chan
->tech
->send_html(chan
, subclass
, data
, datalen
);
3088 int ast_channel_sendurl(struct ast_channel
*chan
, const char *url
)
3090 return ast_channel_sendhtml(chan
, AST_HTML_URL
, url
, strlen(url
) + 1);
3093 int ast_channel_make_compatible(struct ast_channel
*chan
, struct ast_channel
*peer
)
3098 if (chan
->readformat
== peer
->writeformat
&& chan
->writeformat
== peer
->readformat
) {
3099 /* Already compatible! Moving on ... */
3103 /* Set up translation from the chan to the peer */
3104 src
= chan
->nativeformats
;
3105 dst
= peer
->nativeformats
;
3106 if (ast_translator_best_choice(&dst
, &src
) < 0) {
3107 ast_log(LOG_WARNING
, "No path to translate from %s(%d) to %s(%d)\n", chan
->name
, src
, peer
->name
, dst
);
3111 /* if the best path is not 'pass through', then
3112 transcoding is needed; if desired, force transcode path
3113 to use SLINEAR between channels, but only if there is
3114 no direct conversion available */
3115 if ((src
!= dst
) && ast_opt_transcode_via_slin
&&
3116 (ast_translate_path_steps(dst
, src
) != 1))
3117 dst
= AST_FORMAT_SLINEAR
;
3118 if (ast_set_read_format(chan
, dst
) < 0) {
3119 ast_log(LOG_WARNING
, "Unable to set read format on channel %s to %d\n", chan
->name
, dst
);
3122 if (ast_set_write_format(peer
, dst
) < 0) {
3123 ast_log(LOG_WARNING
, "Unable to set write format on channel %s to %d\n", peer
->name
, dst
);
3127 /* Set up translation from the peer to the chan */
3128 src
= peer
->nativeformats
;
3129 dst
= chan
->nativeformats
;
3130 if (ast_translator_best_choice(&dst
, &src
) < 0) {
3131 ast_log(LOG_WARNING
, "No path to translate from %s(%d) to %s(%d)\n", peer
->name
, src
, chan
->name
, dst
);
3135 /* if the best path is not 'pass through', then
3136 transcoding is needed; if desired, force transcode path
3137 to use SLINEAR between channels, but only if there is
3138 no direct conversion available */
3139 if ((src
!= dst
) && ast_opt_transcode_via_slin
&&
3140 (ast_translate_path_steps(dst
, src
) != 1))
3141 dst
= AST_FORMAT_SLINEAR
;
3142 if (ast_set_read_format(peer
, dst
) < 0) {
3143 ast_log(LOG_WARNING
, "Unable to set read format on channel %s to %d\n", peer
->name
, dst
);
3146 if (ast_set_write_format(chan
, dst
) < 0) {
3147 ast_log(LOG_WARNING
, "Unable to set write format on channel %s to %d\n", chan
->name
, dst
);
3153 int ast_channel_masquerade(struct ast_channel
*original
, struct ast_channel
*clone
)
3156 struct ast_channel
*final_orig
, *final_clone
, *base
;
3159 final_orig
= original
;
3160 final_clone
= clone
;
3162 ast_channel_lock(original
);
3163 while (ast_channel_trylock(clone
)) {
3164 ast_channel_unlock(original
);
3166 ast_channel_lock(original
);
3169 /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent)
3170 and if so, we don't really want to masquerade it, but its proxy */
3171 if (original
->_bridge
&& (original
->_bridge
!= ast_bridged_channel(original
)) && (original
->_bridge
->_bridge
!= original
))
3172 final_orig
= original
->_bridge
;
3174 if (clone
->_bridge
&& (clone
->_bridge
!= ast_bridged_channel(clone
)) && (clone
->_bridge
->_bridge
!= clone
))
3175 final_clone
= clone
->_bridge
;
3177 if (final_clone
->tech
->get_base_channel
&& (base
= final_clone
->tech
->get_base_channel(final_clone
))) {
3181 if ((final_orig
!= original
) || (final_clone
!= clone
)) {
3182 /* Lots and lots of deadlock avoidance. The main one we're competing with
3183 * is ast_write(), which locks channels recursively, when working with a
3185 if (ast_channel_trylock(final_orig
)) {
3186 ast_channel_unlock(clone
);
3187 ast_channel_unlock(original
);
3190 if (ast_channel_trylock(final_clone
)) {
3191 ast_channel_unlock(final_orig
);
3192 ast_channel_unlock(clone
);
3193 ast_channel_unlock(original
);
3196 ast_channel_unlock(clone
);
3197 ast_channel_unlock(original
);
3198 original
= final_orig
;
3199 clone
= final_clone
;
3202 if (original
== clone
) {
3203 ast_log(LOG_WARNING
, "Can't masquerade channel '%s' into itself!\n", original
->name
);
3204 ast_channel_unlock(clone
);
3205 ast_channel_unlock(original
);
3210 ast_log(LOG_DEBUG
, "Planning to masquerade channel %s into the structure of %s\n",
3211 clone
->name
, original
->name
);
3212 if (original
->masq
) {
3213 ast_log(LOG_WARNING
, "%s is already going to masquerade as %s\n",
3214 original
->masq
->name
, original
->name
);
3215 } else if (clone
->masqr
) {
3216 ast_log(LOG_WARNING
, "%s is already going to masquerade as %s\n",
3217 clone
->name
, clone
->masqr
->name
);
3219 original
->masq
= clone
;
3220 clone
->masqr
= original
;
3221 ast_queue_frame(original
, &ast_null_frame
);
3222 ast_queue_frame(clone
, &ast_null_frame
);
3224 ast_log(LOG_DEBUG
, "Done planning to masquerade channel %s into the structure of %s\n", clone
->name
, original
->name
);
3228 ast_channel_unlock(clone
);
3229 ast_channel_unlock(original
);
3234 void ast_change_name(struct ast_channel
*chan
, char *newname
)
3236 manager_event(EVENT_FLAG_CALL
, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan
->name
, newname
, chan
->uniqueid
);
3237 ast_string_field_set(chan
, name
, newname
);
3240 void ast_channel_inherit_variables(const struct ast_channel
*parent
, struct ast_channel
*child
)
3242 struct ast_var_t
*current
, *newvar
;
3243 const char *varname
;
3245 AST_LIST_TRAVERSE(&parent
->varshead
, current
, entries
) {
3248 varname
= ast_var_full_name(current
);
3252 if (varname
[0] == '_') {
3254 if (varname
[1] == '_')
3260 newvar
= ast_var_assign(&varname
[1], ast_var_value(current
));
3262 AST_LIST_INSERT_TAIL(&child
->varshead
, newvar
, entries
);
3264 ast_log(LOG_DEBUG
, "Copying soft-transferable variable %s.\n", ast_var_name(newvar
));
3268 newvar
= ast_var_assign(ast_var_full_name(current
), ast_var_value(current
));
3270 AST_LIST_INSERT_TAIL(&child
->varshead
, newvar
, entries
);
3272 ast_log(LOG_DEBUG
, "Copying hard-transferable variable %s.\n", ast_var_name(newvar
));
3277 ast_log(LOG_DEBUG
, "Not copying variable %s.\n", ast_var_name(current
));
3284 \brief Clone channel variables from 'clone' channel into 'original' channel
3286 All variables except those related to app_groupcount are cloned.
3287 Variables are actually _removed_ from 'clone' channel, presumably
3288 because it will subsequently be destroyed.
3290 \note Assumes locks will be in place on both channels when called.
3292 static void clone_variables(struct ast_channel
*original
, struct ast_channel
*clone
)
3294 struct ast_var_t
*current
, *newvar
;
3295 /* Append variables from clone channel into original channel */
3296 /* XXX Is this always correct? We have to in order to keep MACROS working XXX */
3297 if (AST_LIST_FIRST(&clone
->varshead
))
3298 AST_LIST_APPEND_LIST(&original
->varshead
, &clone
->varshead
, entries
);
3300 /* then, dup the varshead list into the clone */
3302 AST_LIST_TRAVERSE(&original
->varshead
, current
, entries
) {
3303 newvar
= ast_var_assign(current
->name
, current
->value
);
3305 AST_LIST_INSERT_TAIL(&clone
->varshead
, newvar
, entries
);
3310 \brief Masquerade a channel
3312 \note Assumes channel will be locked when called
3314 int ast_do_masquerade(struct ast_channel
*original
)
3319 struct ast_frame
*cur
;
3320 const struct ast_channel_tech
*t
;
3322 struct ast_callerid tmpcid
;
3323 struct ast_channel
*clone
= original
->masq
;
3324 struct ast_cdr
*cdr
;
3325 int rformat
= original
->readformat
;
3326 int wformat
= original
->writeformat
;
3332 if (option_debug
> 3)
3333 ast_log(LOG_DEBUG
, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
3334 clone
->name
, clone
->_state
, original
->name
, original
->_state
);
3336 /* XXX This is a seriously wacked out operation. We're essentially putting the guts of
3337 the clone channel into the original channel. Start by killing off the original
3338 channel's backend. I'm not sure we're going to keep this function, because
3339 while the features are nice, the cost is very high in terms of pure nastiness. XXX */
3341 /* We need the clone's lock, too */
3342 ast_channel_lock(clone
);
3344 if (option_debug
> 1)
3345 ast_log(LOG_DEBUG
, "Got clone lock for masquerade on '%s' at %p\n", clone
->name
, &clone
->lock
);
3347 /* Having remembered the original read/write formats, we turn off any translation on either
3349 free_translation(clone
);
3350 free_translation(original
);
3353 /* Unlink the masquerade */
3354 original
->masq
= NULL
;
3355 clone
->masqr
= NULL
;
3357 /* Save the original name */
3358 ast_copy_string(orig
, original
->name
, sizeof(orig
));
3359 /* Save the new name */
3360 ast_copy_string(newn
, clone
->name
, sizeof(newn
));
3361 /* Create the masq name */
3362 snprintf(masqn
, sizeof(masqn
), "%s<MASQ>", newn
);
3364 /* Copy the name from the clone channel */
3365 ast_string_field_set(original
, name
, newn
);
3367 /* Mangle the name of the clone channel */
3368 ast_string_field_set(clone
, name
, masqn
);
3370 /* Notify any managers of the change, first the masq then the other */
3371 manager_event(EVENT_FLAG_CALL
, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", newn
, masqn
, clone
->uniqueid
);
3372 manager_event(EVENT_FLAG_CALL
, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", orig
, newn
, original
->uniqueid
);
3374 /* Swap the technologies */
3376 original
->tech
= clone
->tech
;
3380 cdr
= original
->cdr
;
3381 original
->cdr
= clone
->cdr
;
3384 t_pvt
= original
->tech_pvt
;
3385 original
->tech_pvt
= clone
->tech_pvt
;
3386 clone
->tech_pvt
= t_pvt
;
3388 /* Swap the alertpipes */
3389 for (i
= 0; i
< 2; i
++) {
3390 x
= original
->alertpipe
[i
];
3391 original
->alertpipe
[i
] = clone
->alertpipe
[i
];
3392 clone
->alertpipe
[i
] = x
;
3396 * Swap the readq's. The end result should be this:
3398 * 1) All frames should be on the new (original) channel.
3399 * 2) Any frames that were already on the new channel before this
3400 * masquerade need to be at the end of the readq, after all of the
3401 * frames on the old (clone) channel.
3402 * 3) The alertpipe needs to get poked for every frame that was already
3403 * on the new channel, since we are now using the alert pipe from the
3404 * old (clone) channel.
3407 AST_LIST_HEAD_NOLOCK(, ast_frame
) tmp_readq
;
3408 AST_LIST_HEAD_SET_NOLOCK(&tmp_readq
, NULL
);
3410 AST_LIST_APPEND_LIST(&tmp_readq
, &original
->readq
, frame_list
);
3411 AST_LIST_APPEND_LIST(&original
->readq
, &clone
->readq
, frame_list
);
3413 while ((cur
= AST_LIST_REMOVE_HEAD(&tmp_readq
, frame_list
))) {
3414 AST_LIST_INSERT_TAIL(&original
->readq
, cur
, frame_list
);
3415 if (original
->alertpipe
[1] > -1) {
3417 write(original
->alertpipe
[1], &poke
, sizeof(poke
));
3422 /* Swap the raw formats */
3423 x
= original
->rawreadformat
;
3424 original
->rawreadformat
= clone
->rawreadformat
;
3425 clone
->rawreadformat
= x
;
3426 x
= original
->rawwriteformat
;
3427 original
->rawwriteformat
= clone
->rawwriteformat
;
3428 clone
->rawwriteformat
= x
;
3430 clone
->_softhangup
= AST_SOFTHANGUP_DEV
;
3432 /* And of course, so does our current state. Note we need not
3433 call ast_setstate since the event manager doesn't really consider
3434 these separate. We do this early so that the clone has the proper
3435 state of the original channel. */
3436 origstate
= original
->_state
;
3437 original
->_state
= clone
->_state
;
3438 clone
->_state
= origstate
;
3440 if (clone
->tech
->fixup
){
3441 res
= clone
->tech
->fixup(original
, clone
);
3443 ast_log(LOG_WARNING
, "Fixup failed on channel %s, strange things may happen.\n", clone
->name
);
3446 /* Start by disconnecting the original's physical side */
3447 if (clone
->tech
->hangup
)
3448 res
= clone
->tech
->hangup(clone
);
3450 ast_log(LOG_WARNING
, "Hangup failed! Strange things may happen!\n");
3451 ast_channel_unlock(clone
);
3455 snprintf(zombn
, sizeof(zombn
), "%s<ZOMBIE>", orig
);
3456 /* Mangle the name of the clone channel */
3457 ast_string_field_set(clone
, name
, zombn
);
3458 manager_event(EVENT_FLAG_CALL
, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", masqn
, zombn
, clone
->uniqueid
);
3460 /* Update the type. */
3461 t_pvt
= original
->monitor
;
3462 original
->monitor
= clone
->monitor
;
3463 clone
->monitor
= t_pvt
;
3465 /* Keep the same language. */
3466 ast_string_field_set(original
, language
, clone
->language
);
3467 /* Copy the FD's other than the generator fd */
3468 for (x
= 0; x
< AST_MAX_FDS
; x
++) {
3469 if (x
!= AST_GENERATOR_FD
)
3470 original
->fds
[x
] = clone
->fds
[x
];
3473 ast_app_group_update(clone
, original
);
3474 /* Move data stores over */
3475 if (AST_LIST_FIRST(&clone
->datastores
))
3476 AST_LIST_APPEND_LIST(&original
->datastores
, &clone
->datastores
, entry
);
3478 clone_variables(original
, clone
);
3479 /* Presense of ADSI capable CPE follows clone */
3480 original
->adsicpe
= clone
->adsicpe
;
3481 /* Bridge remains the same */
3482 /* CDR fields remain the same */
3483 /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */
3484 /* Application and data remain the same */
3485 /* Clone exception becomes real one, as with fdno */
3486 ast_copy_flags(original
, clone
, AST_FLAG_EXCEPTION
);
3487 original
->fdno
= clone
->fdno
;
3488 /* Schedule context remains the same */
3489 /* Stream stuff stays the same */
3490 /* Keep the original state. The fixup code will need to work with it most likely */
3492 /* Just swap the whole structures, nevermind the allocations, they'll work themselves
3494 tmpcid
= original
->cid
;
3495 original
->cid
= clone
->cid
;
3496 clone
->cid
= tmpcid
;
3498 /* Restore original timing file descriptor */
3499 original
->fds
[AST_TIMING_FD
] = original
->timingfd
;
3501 /* Our native formats are different now */
3502 original
->nativeformats
= clone
->nativeformats
;
3504 /* Context, extension, priority, app data, jump table, remain the same */
3505 /* pvt switches. pbx stays the same, as does next */
3507 /* Set the write format */
3508 ast_set_write_format(original
, wformat
);
3510 /* Set the read format */
3511 ast_set_read_format(original
, rformat
);
3513 /* Copy the music class */
3514 ast_string_field_set(original
, musicclass
, clone
->musicclass
);
3517 ast_log(LOG_DEBUG
, "Putting channel %s in %d/%d formats\n", original
->name
, wformat
, rformat
);
3519 /* Okay. Last thing is to let the channel driver know about all this mess, so he
3520 can fix up everything as best as possible */
3521 if (original
->tech
->fixup
) {
3522 res
= original
->tech
->fixup(clone
, original
);
3524 ast_log(LOG_WARNING
, "Channel for type '%s' could not fixup channel %s\n",
3525 original
->tech
->type
, original
->name
);
3526 ast_channel_unlock(clone
);
3530 ast_log(LOG_WARNING
, "Channel type '%s' does not have a fixup routine (for %s)! Bad things may happen.\n",
3531 original
->tech
->type
, original
->name
);
3533 /* If an indication is currently playing maintain it on the channel that is taking the place of original */
3534 if (original
->visible_indication
)
3535 ast_indicate(original
, original
->visible_indication
);
3537 /* Now, at this point, the "clone" channel is totally F'd up. We mark it as
3538 a zombie so nothing tries to touch it. If it's already been marked as a
3539 zombie, then free it now (since it already is considered invalid). */
3540 if (ast_test_flag(clone
, AST_FLAG_ZOMBIE
)) {
3542 ast_log(LOG_DEBUG
, "Destroying channel clone '%s'\n", clone
->name
);
3543 ast_channel_unlock(clone
);
3544 manager_event(EVENT_FLAG_CALL
, "Hangup",
3548 "Cause-txt: %s\r\n",
3552 ast_cause2str(clone
->hangupcause
)
3554 ast_channel_free(clone
);
3557 ast_log(LOG_DEBUG
, "Released clone lock on '%s'\n", clone
->name
);
3558 ast_set_flag(clone
, AST_FLAG_ZOMBIE
);
3559 ast_queue_frame(clone
, &ast_null_frame
);
3560 ast_channel_unlock(clone
);
3563 /* Signal any blocker */
3564 if (ast_test_flag(original
, AST_FLAG_BLOCKING
))
3565 pthread_kill(original
->blocker
, SIGURG
);
3567 ast_log(LOG_DEBUG
, "Done Masquerading %s (%d)\n", original
->name
, original
->_state
);
3571 void ast_set_callerid(struct ast_channel
*chan
, const char *callerid
, const char *calleridname
, const char *ani
)
3573 ast_channel_lock(chan
);
3576 if (chan
->cid
.cid_num
)
3577 free(chan
->cid
.cid_num
);
3578 chan
->cid
.cid_num
= ast_strdup(callerid
);
3581 if (chan
->cid
.cid_name
)
3582 free(chan
->cid
.cid_name
);
3583 chan
->cid
.cid_name
= ast_strdup(calleridname
);
3586 if (chan
->cid
.cid_ani
)
3587 free(chan
->cid
.cid_ani
);
3588 chan
->cid
.cid_ani
= ast_strdup(ani
);
3591 ast_cdr_setcid(chan
->cdr
, chan
);
3592 manager_event(EVENT_FLAG_CALL
, "Newcallerid",
3595 "CallerIDName: %s\r\n"
3597 "CID-CallingPres: %d (%s)\r\n",
3599 S_OR(chan
->cid
.cid_num
, "<Unknown>"),
3600 S_OR(chan
->cid
.cid_name
, "<Unknown>"),
3603 ast_describe_caller_presentation(chan
->cid
.cid_pres
)
3606 ast_channel_unlock(chan
);
3609 int ast_setstate(struct ast_channel
*chan
, enum ast_channel_state state
)
3611 int oldstate
= chan
->_state
;
3613 if (oldstate
== state
)
3616 chan
->_state
= state
;
3617 ast_device_state_changed_literal(chan
->name
);
3618 /* setstate used to conditionally report Newchannel; this is no more */
3619 manager_event(EVENT_FLAG_CALL
,
3624 "CallerIDName: %s\r\n"
3626 chan
->name
, ast_state2str(chan
->_state
),
3627 S_OR(chan
->cid
.cid_num
, "<unknown>"),
3628 S_OR(chan
->cid
.cid_name
, "<unknown>"),
3634 /*! \brief Find bridged channel */
3635 struct ast_channel
*ast_bridged_channel(struct ast_channel
*chan
)
3637 struct ast_channel
*bridged
;
3638 bridged
= chan
->_bridge
;
3639 if (bridged
&& bridged
->tech
->bridged_channel
)
3640 bridged
= bridged
->tech
->bridged_channel(chan
, bridged
);
3644 static void bridge_playfile(struct ast_channel
*chan
, struct ast_channel
*peer
, const char *sound
, int remain
)
3646 int min
= 0, sec
= 0, check
;
3648 check
= ast_autoservice_start(peer
);
3653 if (remain
/ 60 > 1) {
3661 if (!strcmp(sound
,"timeleft")) { /* Queue support */
3662 ast_stream_and_wait(chan
, "vm-youhave", chan
->language
, "");
3664 ast_say_number(chan
, min
, AST_DIGIT_ANY
, chan
->language
, NULL
);
3665 ast_stream_and_wait(chan
, "queue-minutes", chan
->language
, "");
3668 ast_say_number(chan
, sec
, AST_DIGIT_ANY
, chan
->language
, NULL
);
3669 ast_stream_and_wait(chan
, "queue-seconds", chan
->language
, "");
3672 ast_stream_and_wait(chan
, sound
, chan
->language
, "");
3675 ast_autoservice_stop(peer
);
3678 static enum ast_bridge_result
ast_generic_bridge(struct ast_channel
*c0
, struct ast_channel
*c1
,
3679 struct ast_bridge_config
*config
, struct ast_frame
**fo
,
3680 struct ast_channel
**rc
, struct timeval bridge_end
)
3682 /* Copy voice back and forth between the two channels. */
3683 struct ast_channel
*cs
[3];
3684 struct ast_frame
*f
;
3685 enum ast_bridge_result res
= AST_BRIDGE_COMPLETE
;
3686 int o0nativeformats
;
3687 int o1nativeformats
;
3691 /* Indicates whether a frame was queued into a jitterbuffer */
3692 int frame_put_in_jb
= 0;
3698 pvt0
= c0
->tech_pvt
;
3699 pvt1
= c1
->tech_pvt
;
3700 o0nativeformats
= c0
->nativeformats
;
3701 o1nativeformats
= c1
->nativeformats
;
3702 watch_c0_dtmf
= config
->flags
& AST_BRIDGE_DTMF_CHANNEL_0
;
3703 watch_c1_dtmf
= config
->flags
& AST_BRIDGE_DTMF_CHANNEL_1
;
3705 /* Check the need of a jitterbuffer for each channel */
3706 jb_in_use
= ast_jb_do_usecheck(c0
, c1
);
3709 struct ast_channel
*who
, *other
;
3711 if ((c0
->tech_pvt
!= pvt0
) || (c1
->tech_pvt
!= pvt1
) ||
3712 (o0nativeformats
!= c0
->nativeformats
) ||
3713 (o1nativeformats
!= c1
->nativeformats
)) {
3714 /* Check for Masquerade, codec changes, etc */
3715 res
= AST_BRIDGE_RETRY
;
3718 if (bridge_end
.tv_sec
) {
3719 to
= ast_tvdiff_ms(bridge_end
, ast_tvnow());
3721 if (config
->timelimit
)
3722 res
= AST_BRIDGE_RETRY
;
3724 res
= AST_BRIDGE_COMPLETE
;
3729 /* Calculate the appropriate max sleep interval - in general, this is the time,
3730 left to the closest jb delivery moment */
3732 to
= ast_jb_get_when_to_wakeup(c0
, c1
, to
);
3733 who
= ast_waitfor_n(cs
, 2, &to
);
3735 /* No frame received within the specified timeout - check if we have to deliver now */
3737 ast_jb_get_and_deliver(c0
, c1
);
3738 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
|| c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
) {
3739 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
3740 c0
->_softhangup
= 0;
3741 if (c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
3742 c1
->_softhangup
= 0;
3753 ast_log(LOG_DEBUG
, "Didn't get a frame from channel: %s\n",who
->name
);
3757 other
= (who
== c0
) ? c1
: c0
; /* the 'other' channel */
3758 /* Try add the frame info the who's bridged channel jitterbuff */
3760 frame_put_in_jb
= !ast_jb_put(other
, f
);
3762 if ((f
->frametype
== AST_FRAME_CONTROL
) && !(config
->flags
& AST_BRIDGE_IGNORE_SIGS
)) {
3763 int bridge_exit
= 0;
3765 switch (f
->subclass
) {
3766 case AST_CONTROL_HOLD
:
3767 case AST_CONTROL_UNHOLD
:
3768 case AST_CONTROL_VIDUPDATE
:
3769 ast_indicate_data(other
, f
->subclass
, f
->data
, f
->datalen
);
3776 ast_log(LOG_DEBUG
, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f
->subclass
, who
->name
);
3782 if ((f
->frametype
== AST_FRAME_VOICE
) ||
3783 (f
->frametype
== AST_FRAME_DTMF_BEGIN
) ||
3784 (f
->frametype
== AST_FRAME_DTMF
) ||
3785 (f
->frametype
== AST_FRAME_VIDEO
) ||
3786 (f
->frametype
== AST_FRAME_IMAGE
) ||
3787 (f
->frametype
== AST_FRAME_HTML
) ||
3788 (f
->frametype
== AST_FRAME_MODEM
) ||
3789 (f
->frametype
== AST_FRAME_TEXT
)) {
3790 /* monitored dtmf causes exit from bridge */
3791 int monitored_source
= (who
== c0
) ? watch_c0_dtmf
: watch_c1_dtmf
;
3793 if (monitored_source
&&
3794 (f
->frametype
== AST_FRAME_DTMF_END
||
3795 f
->frametype
== AST_FRAME_DTMF_BEGIN
)) {
3799 ast_log(LOG_DEBUG
, "Got DTMF %s on channel (%s)\n",
3800 f
->frametype
== AST_FRAME_DTMF_END
? "end" : "begin",
3804 /* Write immediately frames, not passed through jb */
3805 if (!frame_put_in_jb
)
3806 ast_write(other
, f
);
3808 /* Check if we have to deliver now */
3810 ast_jb_get_and_deliver(c0
, c1
);
3812 /* XXX do we want to pass on also frames not matched above ? */
3815 /* Swap who gets priority */
3823 /*! \brief Bridge two channels together */
3824 enum ast_bridge_result
ast_channel_bridge(struct ast_channel
*c0
, struct ast_channel
*c1
,
3825 struct ast_bridge_config
*config
, struct ast_frame
**fo
, struct ast_channel
**rc
)
3827 struct ast_channel
*who
= NULL
;
3828 enum ast_bridge_result res
= AST_BRIDGE_COMPLETE
;
3831 int o0nativeformats
;
3832 int o1nativeformats
;
3833 long time_left_ms
=0;
3834 struct timeval nexteventts
= { 0, };
3835 char caller_warning
= 0;
3836 char callee_warning
= 0;
3839 ast_log(LOG_WARNING
, "%s is already in a bridge with %s\n",
3840 c0
->name
, c0
->_bridge
->name
);
3844 ast_log(LOG_WARNING
, "%s is already in a bridge with %s\n",
3845 c1
->name
, c1
->_bridge
->name
);
3849 /* Stop if we're a zombie or need a soft hangup */
3850 if (ast_test_flag(c0
, AST_FLAG_ZOMBIE
) || ast_check_hangup_locked(c0
) ||
3851 ast_test_flag(c1
, AST_FLAG_ZOMBIE
) || ast_check_hangup_locked(c1
))
3855 firstpass
= config
->firstpass
;
3856 config
->firstpass
= 0;
3858 if (ast_tvzero(config
->start_time
))
3859 config
->start_time
= ast_tvnow();
3860 time_left_ms
= config
->timelimit
;
3862 caller_warning
= ast_test_flag(&config
->features_caller
, AST_FEATURE_PLAY_WARNING
);
3863 callee_warning
= ast_test_flag(&config
->features_callee
, AST_FEATURE_PLAY_WARNING
);
3865 if (config
->start_sound
&& firstpass
) {
3867 bridge_playfile(c0
, c1
, config
->start_sound
, time_left_ms
/ 1000);
3869 bridge_playfile(c1
, c0
, config
->start_sound
, time_left_ms
/ 1000);
3872 /* Keep track of bridge */
3876 /* \todo XXX here should check that cid_num is not NULL */
3877 manager_event(EVENT_FLAG_CALL
, "Link",
3883 "CallerID2: %s\r\n",
3884 c0
->name
, c1
->name
, c0
->uniqueid
, c1
->uniqueid
, c0
->cid
.cid_num
, c1
->cid
.cid_num
);
3886 o0nativeformats
= c0
->nativeformats
;
3887 o1nativeformats
= c1
->nativeformats
;
3889 if (config
->feature_timer
) {
3890 nexteventts
= ast_tvadd(config
->start_time
, ast_samp2tv(config
->feature_timer
, 1000));
3891 } else if (config
->timelimit
) {
3892 nexteventts
= ast_tvadd(config
->start_time
, ast_samp2tv(config
->timelimit
, 1000));
3893 if (caller_warning
|| callee_warning
)
3894 nexteventts
= ast_tvsub(nexteventts
, ast_samp2tv(config
->play_warning
, 1000));
3897 if (!c0
->tech
->send_digit_begin
)
3898 ast_set_flag(c1
, AST_FLAG_END_DTMF_ONLY
);
3899 if (!c1
->tech
->send_digit_begin
)
3900 ast_set_flag(c0
, AST_FLAG_END_DTMF_ONLY
);
3902 for (/* ever */;;) {
3903 struct timeval now
= { 0, };
3908 if (!ast_tvzero(nexteventts
)) {
3910 to
= ast_tvdiff_ms(nexteventts
, now
);
3912 if (!config
->timelimit
) {
3913 res
= AST_BRIDGE_COMPLETE
;
3920 if (config
->timelimit
) {
3921 time_left_ms
= config
->timelimit
- ast_tvdiff_ms(now
, config
->start_time
);
3922 if (time_left_ms
< to
)
3925 if (time_left_ms
<= 0) {
3926 if (caller_warning
&& config
->end_sound
)
3927 bridge_playfile(c0
, c1
, config
->end_sound
, 0);
3928 if (callee_warning
&& config
->end_sound
)
3929 bridge_playfile(c1
, c0
, config
->end_sound
, 0);
3938 if (time_left_ms
>= 5000 && config
->warning_sound
&& config
->play_warning
) {
3939 int t
= (time_left_ms
+ 500) / 1000; /* round to nearest second */
3941 bridge_playfile(c0
, c1
, config
->warning_sound
, t
);
3943 bridge_playfile(c1
, c0
, config
->warning_sound
, t
);
3945 if (config
->warning_freq
&& (time_left_ms
> (config
->warning_freq
+ 5000)))
3946 nexteventts
= ast_tvadd(nexteventts
, ast_samp2tv(config
->warning_freq
, 1000));
3948 nexteventts
= ast_tvadd(config
->start_time
, ast_samp2tv(config
->timelimit
, 1000));
3952 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
|| c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
) {
3953 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
3954 c0
->_softhangup
= 0;
3955 if (c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
3956 c1
->_softhangup
= 0;
3960 ast_log(LOG_DEBUG
, "Unbridge signal received. Ending native bridge.\n");
3964 /* Stop if we're a zombie or need a soft hangup */
3965 if (ast_test_flag(c0
, AST_FLAG_ZOMBIE
) || ast_check_hangup_locked(c0
) ||
3966 ast_test_flag(c1
, AST_FLAG_ZOMBIE
) || ast_check_hangup_locked(c1
)) {
3972 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",
3974 ast_test_flag(c0
, AST_FLAG_ZOMBIE
) ? "Yes" : "No",
3975 ast_check_hangup(c0
) ? "Yes" : "No",
3976 ast_test_flag(c1
, AST_FLAG_ZOMBIE
) ? "Yes" : "No",
3977 ast_check_hangup(c1
) ? "Yes" : "No");
3981 /* See if the BRIDGEPEER variable needs to be updated */
3982 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c0
, "BRIDGEPEER")))
3983 pbx_builtin_setvar_helper(c0
, "BRIDGEPEER", c1
->name
);
3984 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c1
, "BRIDGEPEER")))
3985 pbx_builtin_setvar_helper(c1
, "BRIDGEPEER", c0
->name
);
3987 if (c0
->tech
->bridge
&&
3988 (config
->timelimit
== 0) &&
3989 (c0
->tech
->bridge
== c1
->tech
->bridge
) &&
3990 !nativefailed
&& !c0
->monitor
&& !c1
->monitor
&&
3991 !c0
->audiohooks
&& !c1
->audiohooks
&& !ast_test_flag(&(config
->features_callee
),AST_FEATURE_REDIRECT
) &&
3992 !ast_test_flag(&(config
->features_caller
),AST_FEATURE_REDIRECT
) &&
3993 !c0
->masq
&& !c0
->masqr
&& !c1
->masq
&& !c1
->masqr
) {
3994 /* Looks like they share a bridge method and nothing else is in the way */
3995 ast_set_flag(c0
, AST_FLAG_NBRIDGE
);
3996 ast_set_flag(c1
, AST_FLAG_NBRIDGE
);
3997 if ((res
= c0
->tech
->bridge(c0
, c1
, config
->flags
, fo
, rc
, to
)) == AST_BRIDGE_COMPLETE
) {
3998 /* \todo XXX here should check that cid_num is not NULL */
3999 manager_event(EVENT_FLAG_CALL
, "Unlink",
4005 "CallerID2: %s\r\n",
4006 c0
->name
, c1
->name
, c0
->uniqueid
, c1
->uniqueid
, c0
->cid
.cid_num
, c1
->cid
.cid_num
);
4008 ast_log(LOG_DEBUG
, "Returning from native bridge, channels: %s, %s\n", c0
->name
, c1
->name
);
4010 ast_clear_flag(c0
, AST_FLAG_NBRIDGE
);
4011 ast_clear_flag(c1
, AST_FLAG_NBRIDGE
);
4013 if (c0
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
|| c1
->_softhangup
== AST_SOFTHANGUP_UNBRIDGE
)
4021 ast_clear_flag(c0
, AST_FLAG_NBRIDGE
);
4022 ast_clear_flag(c1
, AST_FLAG_NBRIDGE
);
4025 case AST_BRIDGE_RETRY
:
4028 if (option_verbose
> 2)
4029 ast_verbose(VERBOSE_PREFIX_3
"Native bridging %s and %s ended\n",
4030 c0
->name
, c1
->name
);
4032 case AST_BRIDGE_FAILED_NOWARN
:
4038 if (((c0
->writeformat
!= c1
->readformat
) || (c0
->readformat
!= c1
->writeformat
) ||
4039 (c0
->nativeformats
!= o0nativeformats
) || (c1
->nativeformats
!= o1nativeformats
)) &&
4040 !(c0
->generator
|| c1
->generator
)) {
4041 if (ast_channel_make_compatible(c0
, c1
)) {
4042 ast_log(LOG_WARNING
, "Can't make %s and %s compatible\n", c0
->name
, c1
->name
);
4043 /* \todo XXX here should check that cid_num is not NULL */
4044 manager_event(EVENT_FLAG_CALL
, "Unlink",
4050 "CallerID2: %s\r\n",
4051 c0
->name
, c1
->name
, c0
->uniqueid
, c1
->uniqueid
, c0
->cid
.cid_num
, c1
->cid
.cid_num
);
4052 return AST_BRIDGE_FAILED
;
4054 o0nativeformats
= c0
->nativeformats
;
4055 o1nativeformats
= c1
->nativeformats
;
4057 res
= ast_generic_bridge(c0
, c1
, config
, fo
, rc
, nexteventts
);
4058 if (res
!= AST_BRIDGE_RETRY
)
4062 ast_clear_flag(c0
, AST_FLAG_END_DTMF_ONLY
);
4063 ast_clear_flag(c1
, AST_FLAG_END_DTMF_ONLY
);
4068 /* \todo XXX here should check that cid_num is not NULL */
4069 manager_event(EVENT_FLAG_CALL
, "Unlink",
4075 "CallerID2: %s\r\n",
4076 c0
->name
, c1
->name
, c0
->uniqueid
, c1
->uniqueid
, c0
->cid
.cid_num
, c1
->cid
.cid_num
);
4078 ast_log(LOG_DEBUG
, "Bridge stops bridging channels %s and %s\n", c0
->name
, c1
->name
);
4083 /*! \brief Sets an option on a channel */
4084 int ast_channel_setoption(struct ast_channel
*chan
, int option
, void *data
, int datalen
, int block
)
4088 if (chan
->tech
->setoption
) {
4089 res
= chan
->tech
->setoption(chan
, option
, data
, datalen
);
4097 /* XXX Implement blocking -- just wait for our option frame reply, discarding
4098 intermediate packets. XXX */
4099 ast_log(LOG_ERROR
, "XXX Blocking not implemented yet XXX\n");
4105 struct tonepair_def
{
4112 struct tonepair_state
{
4126 unsigned char offset
[AST_FRIENDLY_OFFSET
];
4130 static void tonepair_release(struct ast_channel
*chan
, void *params
)
4132 struct tonepair_state
*ts
= params
;
4135 ast_set_write_format(chan
, ts
->origwfmt
);
4139 static void *tonepair_alloc(struct ast_channel
*chan
, void *params
)
4141 struct tonepair_state
*ts
;
4142 struct tonepair_def
*td
= params
;
4144 if (!(ts
= ast_calloc(1, sizeof(*ts
))))
4146 ts
->origwfmt
= chan
->writeformat
;
4147 if (ast_set_write_format(chan
, AST_FORMAT_SLINEAR
)) {
4148 ast_log(LOG_WARNING
, "Unable to set '%s' to signed linear format (write)\n", chan
->name
);
4149 tonepair_release(NULL
, ts
);
4152 ts
->fac1
= 2.0 * cos(2.0 * M_PI
* (td
->freq1
/ 8000.0)) * 32768.0;
4154 ts
->v2_1
= sin(-4.0 * M_PI
* (td
->freq1
/ 8000.0)) * td
->vol
;
4155 ts
->v3_1
= sin(-2.0 * M_PI
* (td
->freq1
/ 8000.0)) * td
->vol
;
4157 ts
->fac2
= 2.0 * cos(2.0 * M_PI
* (td
->freq2
/ 8000.0)) * 32768.0;
4158 ts
->v2_2
= sin(-4.0 * M_PI
* (td
->freq2
/ 8000.0)) * td
->vol
;
4159 ts
->v3_2
= sin(-2.0 * M_PI
* (td
->freq2
/ 8000.0)) * td
->vol
;
4160 ts
->duration
= td
->duration
;
4163 /* Let interrupts interrupt :) */
4164 ast_set_flag(chan
, AST_FLAG_WRITE_INT
);
4168 static int tonepair_generator(struct ast_channel
*chan
, void *data
, int len
, int samples
)
4170 struct tonepair_state
*ts
= data
;
4173 /* we need to prepare a frame with 16 * timelen samples as we're
4174 * generating SLIN audio
4178 if (len
> sizeof(ts
->data
) / 2 - 1) {
4179 ast_log(LOG_WARNING
, "Can't generate that much data!\n");
4182 memset(&ts
->f
, 0, sizeof(ts
->f
));
4183 for (x
=0;x
<len
/2;x
++) {
4184 ts
->v1_1
= ts
->v2_1
;
4185 ts
->v2_1
= ts
->v3_1
;
4186 ts
->v3_1
= (ts
->fac1
* ts
->v2_1
>> 15) - ts
->v1_1
;
4188 ts
->v1_2
= ts
->v2_2
;
4189 ts
->v2_2
= ts
->v3_2
;
4190 ts
->v3_2
= (ts
->fac2
* ts
->v2_2
>> 15) - ts
->v1_2
;
4193 p
= ts
->v3_2
- 32768;
4195 p
= ((p
* 9) / 10) + 1;
4196 ts
->data
[x
] = (ts
->v3_1
* p
) >> 15;
4198 ts
->data
[x
] = ts
->v3_1
+ ts
->v3_2
;
4200 ts
->f
.frametype
= AST_FRAME_VOICE
;
4201 ts
->f
.subclass
= AST_FORMAT_SLINEAR
;
4202 ts
->f
.datalen
= len
;
4203 ts
->f
.samples
= samples
;
4204 ts
->f
.offset
= AST_FRIENDLY_OFFSET
;
4205 ts
->f
.data
= ts
->data
;
4206 ast_write(chan
, &ts
->f
);
4208 if (ts
->duration
> 0) {
4209 if (ts
->pos
>= ts
->duration
* 8)
4215 static struct ast_generator tonepair
= {
4216 alloc
: tonepair_alloc
,
4217 release
: tonepair_release
,
4218 generate
: tonepair_generator
,
4221 int ast_tonepair_start(struct ast_channel
*chan
, int freq1
, int freq2
, int duration
, int vol
)
4223 struct tonepair_def d
= { 0, };
4227 d
.duration
= duration
;
4228 d
.vol
= (vol
< 1) ? 8192 : vol
; /* force invalid to 8192 */
4229 if (ast_activate_generator(chan
, &tonepair
, &d
))
4234 void ast_tonepair_stop(struct ast_channel
*chan
)
4236 ast_deactivate_generator(chan
);
4239 int ast_tonepair(struct ast_channel
*chan
, int freq1
, int freq2
, int duration
, int vol
)
4243 if ((res
= ast_tonepair_start(chan
, freq1
, freq2
, duration
, vol
)))
4246 /* Give us some wiggle room */
4247 while (chan
->generatordata
&& ast_waitfor(chan
, 100) >= 0) {
4248 struct ast_frame
*f
= ast_read(chan
);
4257 ast_group_t
ast_get_group(const char *s
)
4261 int start
=0, finish
=0, x
;
4262 ast_group_t group
= 0;
4264 if (ast_strlen_zero(s
))
4269 while ((piece
= strsep(&c
, ","))) {
4270 if (sscanf(piece
, "%d-%d", &start
, &finish
) == 2) {
4272 } else if (sscanf(piece
, "%d", &start
)) {
4276 ast_log(LOG_ERROR
, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s
, piece
);
4279 for (x
= start
; x
<= finish
; x
++) {
4280 if ((x
> 63) || (x
< 0)) {
4281 ast_log(LOG_WARNING
, "Ignoring invalid group %d (maximum group is 63)\n", x
);
4283 group
|= ((ast_group_t
) 1 << x
);
4289 static int (*ast_moh_start_ptr
)(struct ast_channel
*, const char *, const char *) = NULL
;
4290 static void (*ast_moh_stop_ptr
)(struct ast_channel
*) = NULL
;
4291 static void (*ast_moh_cleanup_ptr
)(struct ast_channel
*) = NULL
;
4293 void ast_install_music_functions(int (*start_ptr
)(struct ast_channel
*, const char *, const char *),
4294 void (*stop_ptr
)(struct ast_channel
*),
4295 void (*cleanup_ptr
)(struct ast_channel
*))
4297 ast_moh_start_ptr
= start_ptr
;
4298 ast_moh_stop_ptr
= stop_ptr
;
4299 ast_moh_cleanup_ptr
= cleanup_ptr
;
4302 void ast_uninstall_music_functions(void)
4304 ast_moh_start_ptr
= NULL
;
4305 ast_moh_stop_ptr
= NULL
;
4306 ast_moh_cleanup_ptr
= NULL
;
4309 /*! \brief Turn on music on hold on a given channel */
4310 int ast_moh_start(struct ast_channel
*chan
, const char *mclass
, const char *interpclass
)
4312 if (ast_moh_start_ptr
)
4313 return ast_moh_start_ptr(chan
, mclass
, interpclass
);
4315 if (option_verbose
> 2) {
4316 ast_verbose(VERBOSE_PREFIX_3
"Music class %s requested but no musiconhold loaded.\n",
4317 mclass
? mclass
: (interpclass
? interpclass
: "default"));
4323 /*! \brief Turn off music on hold on a given channel */
4324 void ast_moh_stop(struct ast_channel
*chan
)
4326 if (ast_moh_stop_ptr
)
4327 ast_moh_stop_ptr(chan
);
4330 void ast_moh_cleanup(struct ast_channel
*chan
)
4332 if (ast_moh_cleanup_ptr
)
4333 ast_moh_cleanup_ptr(chan
);
4336 void ast_channels_init(void)
4338 ast_cli_register_multiple(cli_channel
, sizeof(cli_channel
) / sizeof(struct ast_cli_entry
));
4341 /*! \brief Print call group and pickup group ---*/
4342 char *ast_print_group(char *buf
, int buflen
, ast_group_t group
)
4350 if (!group
) /* Return empty string if no group */
4353 for (i
= 0; i
<= 63; i
++) { /* Max group is 63 */
4354 if (group
& ((ast_group_t
) 1 << i
)) {
4356 strncat(buf
, ", ", buflen
);
4360 snprintf(num
, sizeof(num
), "%u", i
);
4361 strncat(buf
, num
, buflen
);
4367 void ast_set_variables(struct ast_channel
*chan
, struct ast_variable
*vars
)
4369 struct ast_variable
*cur
;
4371 for (cur
= vars
; cur
; cur
= cur
->next
)
4372 pbx_builtin_setvar_helper(chan
, cur
->name
, cur
->value
);
4375 static void *silence_generator_alloc(struct ast_channel
*chan
, void *data
)
4377 /* just store the data pointer in the channel structure */
4381 static void silence_generator_release(struct ast_channel
*chan
, void *data
)
4386 static int silence_generator_generate(struct ast_channel
*chan
, void *data
, int len
, int samples
)
4389 struct ast_frame frame
= {
4390 .frametype
= AST_FRAME_VOICE
,
4391 .subclass
= AST_FORMAT_SLINEAR
,
4394 .datalen
= sizeof(buf
),
4396 memset(buf
, 0, sizeof(buf
));
4397 if (ast_write(chan
, &frame
))
4402 static struct ast_generator silence_generator
= {
4403 .alloc
= silence_generator_alloc
,
4404 .release
= silence_generator_release
,
4405 .generate
= silence_generator_generate
,
4408 struct ast_silence_generator
{
4409 int old_write_format
;
4412 struct ast_silence_generator
*ast_channel_start_silence_generator(struct ast_channel
*chan
)
4414 struct ast_silence_generator
*state
;
4416 if (!(state
= ast_calloc(1, sizeof(*state
)))) {
4420 state
->old_write_format
= chan
->writeformat
;
4422 if (ast_set_write_format(chan
, AST_FORMAT_SLINEAR
) < 0) {
4423 ast_log(LOG_ERROR
, "Could not set write format to SLINEAR\n");
4428 ast_activate_generator(chan
, &silence_generator
, state
);
4431 ast_log(LOG_DEBUG
, "Started silence generator on '%s'\n", chan
->name
);
4436 void ast_channel_stop_silence_generator(struct ast_channel
*chan
, struct ast_silence_generator
*state
)
4441 ast_deactivate_generator(chan
);
4444 ast_log(LOG_DEBUG
, "Stopped silence generator on '%s'\n", chan
->name
);
4446 if (ast_set_write_format(chan
, state
->old_write_format
) < 0)
4447 ast_log(LOG_ERROR
, "Could not return write format to its original state\n");
4453 /*! \ brief Convert channel reloadreason (ENUM) to text string for manager event */
4454 const char *channelreloadreason2txt(enum channelreloadreason reason
)
4457 case CHANNEL_MODULE_LOAD
:
4458 return "LOAD (Channel module load)";
4460 case CHANNEL_MODULE_RELOAD
:
4461 return "RELOAD (Channel module reload)";
4463 case CHANNEL_CLI_RELOAD
:
4464 return "CLIRELOAD (Channel module reload by CLI command)";
4467 return "MANAGERRELOAD (Channel module reload by manager)";
4471 #ifdef DEBUG_CHANNEL_LOCKS
4473 /*! \brief Unlock AST channel (and print debugging output)
4474 \note You need to enable DEBUG_CHANNEL_LOCKS for this function
4476 int ast_channel_unlock(struct ast_channel
*chan
)
4479 if (option_debug
> 2)
4480 ast_log(LOG_DEBUG
, "::::==== Unlocking AST channel %s\n", chan
->name
);
4484 ast_log(LOG_DEBUG
, "::::==== Unlocking non-existing channel \n");
4488 res
= ast_mutex_unlock(&chan
->lock
);
4490 if (option_debug
> 2) {
4491 #ifdef DEBUG_THREADS
4493 if ((count
= chan
->lock
.reentrancy
))
4494 ast_log(LOG_DEBUG
, ":::=== Still have %d locks (recursive)\n", count
);
4498 ast_log(LOG_DEBUG
, "::::==== Channel %s was unlocked\n", chan
->name
);
4499 if (res
== EINVAL
) {
4501 ast_log(LOG_DEBUG
, "::::==== Channel %s had no lock by this thread. Failed unlocking\n", chan
->name
);
4505 /* We had no lock, so okay any way*/
4506 if (option_debug
> 3)
4507 ast_log(LOG_DEBUG
, "::::==== Channel %s was not locked at all \n", chan
->name
);
4513 /*! \brief Lock AST channel (and print debugging output)
4514 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
4515 int ast_channel_lock(struct ast_channel
*chan
)
4519 if (option_debug
> 3)
4520 ast_log(LOG_DEBUG
, "====:::: Locking AST channel %s\n", chan
->name
);
4522 res
= ast_mutex_lock(&chan
->lock
);
4524 if (option_debug
> 3) {
4525 #ifdef DEBUG_THREADS
4527 if ((count
= chan
->lock
.reentrancy
))
4528 ast_log(LOG_DEBUG
, ":::=== Now have %d locks (recursive)\n", count
);
4531 ast_log(LOG_DEBUG
, "::::==== Channel %s was locked\n", chan
->name
);
4532 if (res
== EDEADLK
) {
4533 /* We had no lock, so okey any way */
4534 if (option_debug
> 3)
4535 ast_log(LOG_DEBUG
, "::::==== Channel %s was not locked by us. Lock would cause deadlock.\n", chan
->name
);
4537 if (res
== EINVAL
) {
4538 if (option_debug
> 3)
4539 ast_log(LOG_DEBUG
, "::::==== Channel %s lock failed. No mutex.\n", chan
->name
);
4545 /*! \brief Lock AST channel (and print debugging output)
4546 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
4547 int ast_channel_trylock(struct ast_channel
*chan
)
4551 if (option_debug
> 2)
4552 ast_log(LOG_DEBUG
, "====:::: Trying to lock AST channel %s\n", chan
->name
);
4554 res
= ast_mutex_trylock(&chan
->lock
);
4556 if (option_debug
> 2) {
4557 #ifdef DEBUG_THREADS
4559 if ((count
= chan
->lock
.reentrancy
))
4560 ast_log(LOG_DEBUG
, ":::=== Now have %d locks (recursive)\n", count
);
4563 ast_log(LOG_DEBUG
, "::::==== Channel %s was locked\n", chan
->name
);
4565 /* We failed to lock */
4566 if (option_debug
> 2)
4567 ast_log(LOG_DEBUG
, "::::==== Channel %s failed to lock. Not waiting around...\n", chan
->name
);
4569 if (res
== EDEADLK
) {
4570 /* We had no lock, so okey any way*/
4571 if (option_debug
> 2)
4572 ast_log(LOG_DEBUG
, "::::==== Channel %s was not locked. Lock would cause deadlock.\n", chan
->name
);
4574 if (res
== EINVAL
&& option_debug
> 2)
4575 ast_log(LOG_DEBUG
, "::::==== Channel %s lock failed. No mutex.\n", chan
->name
);
4583 * Wrappers for various ast_say_*() functions that call the full version
4584 * of the same functions.
4585 * The proper place would be say.c, but that file is optional and one
4586 * must be able to build asterisk even without it (using a loadable 'say'
4587 * implementation that only supplies the 'full' version of the functions.
4590 int ast_say_number(struct ast_channel
*chan
, int num
,
4591 const char *ints
, const char *language
, const char *options
)
4593 return ast_say_number_full(chan
, num
, ints
, language
, options
, -1, -1);
4596 int ast_say_enumeration(struct ast_channel
*chan
, int num
,
4597 const char *ints
, const char *language
, const char *options
)
4599 return ast_say_enumeration_full(chan
, num
, ints
, language
, options
, -1, -1);
4602 int ast_say_digits(struct ast_channel
*chan
, int num
,
4603 const char *ints
, const char *lang
)
4605 return ast_say_digits_full(chan
, num
, ints
, lang
, -1, -1);
4608 int ast_say_digit_str(struct ast_channel
*chan
, const char *str
,
4609 const char *ints
, const char *lang
)
4611 return ast_say_digit_str_full(chan
, str
, ints
, lang
, -1, -1);
4614 int ast_say_character_str(struct ast_channel
*chan
, const char *str
,
4615 const char *ints
, const char *lang
)
4617 return ast_say_character_str_full(chan
, str
, ints
, lang
, -1, -1);
4620 int ast_say_phonetic_str(struct ast_channel
*chan
, const char *str
,
4621 const char *ints
, const char *lang
)
4623 return ast_say_phonetic_str_full(chan
, str
, ints
, lang
, -1, -1);
4626 int ast_say_digits_full(struct ast_channel
*chan
, int num
,
4627 const char *ints
, const char *lang
, int audiofd
, int ctrlfd
)
4631 snprintf(buf
, sizeof(buf
), "%d", num
);
4632 return ast_say_digit_str_full(chan
, buf
, ints
, lang
, audiofd
, ctrlfd
);