Asterisk - The Open Source Telephony Project GIT-master-67613d1
channel.c
Go to the documentation of this file.
1/*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * Copyright (C) 1999 - 2006, Digium, Inc.
5 *
6 * Mark Spencer <markster@digium.com>
7 *
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
13 *
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
17 */
18
19/*! \file
20 *
21 * \brief Channel Management
22 *
23 * \author Mark Spencer <markster@digium.com>
24 */
25
26/*** MODULEINFO
27 <support_level>core</support_level>
28 ***/
29
30#include "asterisk.h"
31
32#include "asterisk/_private.h"
33
34#include <sys/time.h>
35#include <signal.h>
36#include <math.h>
37
38#include "asterisk/paths.h" /* use ast_config_AST_SYSTEM_NAME */
39
40#include "asterisk/pbx.h"
41#include "asterisk/frame.h"
42#include "asterisk/mod_format.h"
43#include "asterisk/sched.h"
44#include "asterisk/channel.h"
46#include "asterisk/say.h"
47#include "asterisk/file.h"
48#include "asterisk/cli.h"
49#include "asterisk/translate.h"
50#include "asterisk/manager.h"
51#include "asterisk/chanvars.h"
54#include "asterisk/causes.h"
55#include "asterisk/callerid.h"
56#include "asterisk/utils.h"
57#include "asterisk/lock.h"
58#include "asterisk/app.h"
59#include "asterisk/transcap.h"
63#include "asterisk/audiohook.h"
64#include "asterisk/framehook.h"
65#include "asterisk/timing.h"
66#include "asterisk/autochan.h"
70#include "asterisk/features.h"
71#include "asterisk/bridge.h"
72#include "asterisk/test.h"
75#include "asterisk/stream.h"
76#include "asterisk/message.h"
77
78/*** DOCUMENTATION
79 ***/
80
81#if defined(KEEP_TILL_CHANNEL_PARTY_NUMBER_INFO_NEEDED)
82#if defined(HAVE_PRI)
83#include "libpri.h"
84#endif /* defined(HAVE_PRI) */
85#endif /* defined(KEEP_TILL_CHANNEL_PARTY_NUMBER_INFO_NEEDED) */
86
87/* uncomment if you have problems with 'monitoring' synchronized files */
88#if 0
89#define MONITOR_CONSTANT_DELAY
90#define MONITOR_DELAY 150 * 8 /*!< 150 ms of MONITORING DELAY */
91#endif
92
93static int chancount;
94
95unsigned long global_fin, global_fout;
96
98#define STATE2STR_BUFSIZE 32
99
100/*! Default amount of time to use when emulating a DTMF digit as a begin and end
101 * 100ms */
102#define AST_DEFAULT_EMULATE_DTMF_DURATION 100
103
104/*! Default amount of time to use when emulating an MF digit as a begin and end
105 * 55ms */
106#define DEFAULT_EMULATE_MF_DURATION 55
107
108#define DEFAULT_AMA_FLAGS AST_AMA_DOCUMENTATION
109
110/*! Minimum amount of time between the end of the last digit and the beginning
111 * of a new one - 45ms */
112#define AST_MIN_DTMF_GAP 45
113
114/*! \brief List of channel drivers */
115struct chanlist {
116 const struct ast_channel_tech *tech;
118};
119
120/*! \brief the list of registered channel types */
122
123/*! \brief All active channels on the system */
124static struct ao2_container *channels;
125
126/*! \brief map AST_CAUSE's to readable string representations
127 *
128 * \ref causes.h
129*/
131 int cause;
132 const char *name;
133 const char *desc;
134};
135
136static const struct causes_map causes[] = {
137 { AST_CAUSE_UNALLOCATED, "UNALLOCATED", "Unallocated (unassigned) number" },
138 { AST_CAUSE_NO_ROUTE_TRANSIT_NET, "NO_ROUTE_TRANSIT_NET", "No route to specified transmit network" },
139 { AST_CAUSE_NO_ROUTE_DESTINATION, "NO_ROUTE_DESTINATION", "No route to destination" },
140 { AST_CAUSE_MISDIALLED_TRUNK_PREFIX, "MISDIALLED_TRUNK_PREFIX", "Misdialed trunk prefix" },
141 { AST_CAUSE_CHANNEL_UNACCEPTABLE, "CHANNEL_UNACCEPTABLE", "Channel unacceptable" },
142 { AST_CAUSE_CALL_AWARDED_DELIVERED, "CALL_AWARDED_DELIVERED", "Call awarded and being delivered in an established channel" },
143 { AST_CAUSE_PRE_EMPTED, "PRE_EMPTED", "Pre-empted" },
144 { AST_CAUSE_NUMBER_PORTED_NOT_HERE, "NUMBER_PORTED_NOT_HERE", "Number ported elsewhere" },
145 { AST_CAUSE_NORMAL_CLEARING, "NORMAL_CLEARING", "Normal Clearing" },
146 { AST_CAUSE_USER_BUSY, "USER_BUSY", "User busy" },
147 { AST_CAUSE_NO_USER_RESPONSE, "NO_USER_RESPONSE", "No user responding" },
148 { AST_CAUSE_NO_ANSWER, "NO_ANSWER", "User alerting, no answer" },
149 { AST_CAUSE_SUBSCRIBER_ABSENT, "SUBSCRIBER_ABSENT", "Subscriber absent" },
150 { AST_CAUSE_CALL_REJECTED, "CALL_REJECTED", "Call Rejected" },
151 { AST_CAUSE_NUMBER_CHANGED, "NUMBER_CHANGED", "Number changed" },
152 { AST_CAUSE_REDIRECTED_TO_NEW_DESTINATION, "REDIRECTED_TO_NEW_DESTINATION", "Redirected to new destination" },
153 { AST_CAUSE_ANSWERED_ELSEWHERE, "ANSWERED_ELSEWHERE", "Answered elsewhere" },
154 { AST_CAUSE_DESTINATION_OUT_OF_ORDER, "DESTINATION_OUT_OF_ORDER", "Destination out of order" },
155 { AST_CAUSE_INVALID_NUMBER_FORMAT, "INVALID_NUMBER_FORMAT", "Invalid number format" },
156 { AST_CAUSE_FACILITY_REJECTED, "FACILITY_REJECTED", "Facility rejected" },
157 { AST_CAUSE_RESPONSE_TO_STATUS_ENQUIRY, "RESPONSE_TO_STATUS_ENQUIRY", "Response to STATus ENQuiry" },
158 { AST_CAUSE_NORMAL_UNSPECIFIED, "NORMAL_UNSPECIFIED", "Normal, unspecified" },
159 { AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, "NORMAL_CIRCUIT_CONGESTION", "Circuit/channel congestion" },
160 { AST_CAUSE_NETWORK_OUT_OF_ORDER, "NETWORK_OUT_OF_ORDER", "Network out of order" },
161 { AST_CAUSE_NORMAL_TEMPORARY_FAILURE, "NORMAL_TEMPORARY_FAILURE", "Temporary failure" },
162 { AST_CAUSE_SWITCH_CONGESTION, "SWITCH_CONGESTION", "Switching equipment congestion" },
163 { AST_CAUSE_ACCESS_INFO_DISCARDED, "ACCESS_INFO_DISCARDED", "Access information discarded" },
164 { AST_CAUSE_REQUESTED_CHAN_UNAVAIL, "REQUESTED_CHAN_UNAVAIL", "Requested channel not available" },
165 { AST_CAUSE_FACILITY_NOT_SUBSCRIBED, "FACILITY_NOT_SUBSCRIBED", "Facility not subscribed" },
166 { AST_CAUSE_OUTGOING_CALL_BARRED, "OUTGOING_CALL_BARRED", "Outgoing call barred" },
167 { AST_CAUSE_INCOMING_CALL_BARRED, "INCOMING_CALL_BARRED", "Incoming call barred" },
168 { AST_CAUSE_BEARERCAPABILITY_NOTAUTH, "BEARERCAPABILITY_NOTAUTH", "Bearer capability not authorized" },
169 { AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, "BEARERCAPABILITY_NOTAVAIL", "Bearer capability not available" },
170 { AST_CAUSE_BEARERCAPABILITY_NOTIMPL, "BEARERCAPABILITY_NOTIMPL", "Bearer capability not implemented" },
171 { AST_CAUSE_CHAN_NOT_IMPLEMENTED, "CHAN_NOT_IMPLEMENTED", "Channel not implemented" },
172 { AST_CAUSE_FACILITY_NOT_IMPLEMENTED, "FACILITY_NOT_IMPLEMENTED", "Facility not implemented" },
173 { AST_CAUSE_INVALID_CALL_REFERENCE, "INVALID_CALL_REFERENCE", "Invalid call reference value" },
174 { AST_CAUSE_INCOMPATIBLE_DESTINATION, "INCOMPATIBLE_DESTINATION", "Incompatible destination" },
175 { AST_CAUSE_INVALID_MSG_UNSPECIFIED, "INVALID_MSG_UNSPECIFIED", "Invalid message unspecified" },
176 { AST_CAUSE_MANDATORY_IE_MISSING, "MANDATORY_IE_MISSING", "Mandatory information element is missing" },
177 { AST_CAUSE_MESSAGE_TYPE_NONEXIST, "MESSAGE_TYPE_NONEXIST", "Message type nonexist." },
178 { AST_CAUSE_WRONG_MESSAGE, "WRONG_MESSAGE", "Wrong message" },
179 { AST_CAUSE_IE_NONEXIST, "IE_NONEXIST", "Info. element nonexist or not implemented" },
180 { AST_CAUSE_INVALID_IE_CONTENTS, "INVALID_IE_CONTENTS", "Invalid information element contents" },
181 { AST_CAUSE_WRONG_CALL_STATE, "WRONG_CALL_STATE", "Message not compatible with call state" },
182 { AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, "RECOVERY_ON_TIMER_EXPIRE", "Recover on timer expiry" },
183 { AST_CAUSE_MANDATORY_IE_LENGTH_ERROR, "MANDATORY_IE_LENGTH_ERROR", "Mandatory IE length error" },
184 { AST_CAUSE_PROTOCOL_ERROR, "PROTOCOL_ERROR", "Protocol error, unspecified" },
185 { AST_CAUSE_INTERWORKING, "INTERWORKING", "Interworking, unspecified" },
186};
187
189{
190 struct chanlist *cl;
191 struct ast_variable *var = NULL, *prev = NULL;
192
194 AST_RWLIST_TRAVERSE(&backends, cl, list) {
195 if (prev) {
196 if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description, "")))
197 prev = prev->next;
198 } else {
199 var = ast_variable_new(cl->tech->type, cl->tech->description, "");
200 prev = var;
201 }
202 }
204
205 return var;
206}
207
208#if defined(KEEP_TILL_CHANNEL_PARTY_NUMBER_INFO_NEEDED)
209static const char *party_number_ton2str(int ton)
210{
211#if defined(HAVE_PRI)
212 switch ((ton >> 4) & 0x07) {
213 case PRI_TON_INTERNATIONAL:
214 return "International";
215 case PRI_TON_NATIONAL:
216 return "National";
217 case PRI_TON_NET_SPECIFIC:
218 return "Network Specific";
219 case PRI_TON_SUBSCRIBER:
220 return "Subscriber";
221 case PRI_TON_ABBREVIATED:
222 return "Abbreviated";
223 case PRI_TON_RESERVED:
224 return "Reserved";
225 case PRI_TON_UNKNOWN:
226 default:
227 break;
228 }
229#endif /* defined(HAVE_PRI) */
230 return "Unknown";
231}
232#endif /* defined(KEEP_TILL_CHANNEL_PARTY_NUMBER_INFO_NEEDED) */
233
234#if defined(KEEP_TILL_CHANNEL_PARTY_NUMBER_INFO_NEEDED)
235static const char *party_number_plan2str(int plan)
236{
237#if defined(HAVE_PRI)
238 switch (plan & 0x0F) {
239 default:
240 case PRI_NPI_UNKNOWN:
241 break;
242 case PRI_NPI_E163_E164:
243 return "Public (E.163/E.164)";
244 case PRI_NPI_X121:
245 return "Data (X.121)";
246 case PRI_NPI_F69:
247 return "Telex (F.69)";
248 case PRI_NPI_NATIONAL:
249 return "National Standard";
250 case PRI_NPI_PRIVATE:
251 return "Private";
252 case PRI_NPI_RESERVED:
253 return "Reserved";
254 }
255#endif /* defined(HAVE_PRI) */
256 return "Unknown";
257}
258#endif /* defined(KEEP_TILL_CHANNEL_PARTY_NUMBER_INFO_NEEDED) */
259
260/*! \brief Show channel types - CLI command */
261static char *handle_cli_core_show_channeltypes(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
262{
263#define FORMAT "%-15.15s %-40.40s %-13.13s %-13.13s %-13.13s %-13.13s\n"
264 struct chanlist *cl;
265 int count_chan = 0;
266
267 switch (cmd) {
268 case CLI_INIT:
269 e->command = "core show channeltypes";
270 e->usage =
271 "Usage: core show channeltypes\n"
272 " Lists available channel types registered in your\n"
273 " Asterisk server.\n";
274 return NULL;
275 case CLI_GENERATE:
276 return NULL;
277 }
278
279 if (a->argc != 3)
280 return CLI_SHOWUSAGE;
281
282 ast_cli(a->fd, FORMAT, "Type", "Description", "Devicestate", "Presencestate", "Indications", "Transfer");
283 ast_cli(a->fd, FORMAT, "-------------", "-------------", "-------------", "-------------", "-------------", "-------------");
284
287 ast_cli(a->fd, FORMAT, cl->tech->type, cl->tech->description,
288 (cl->tech->devicestate) ? "yes" : "no",
289 (cl->tech->presencestate) ? "yes" : "no",
290 (cl->tech->indicate) ? "yes" : "no",
291 (cl->tech->transfer) ? "yes" : "no");
292 count_chan++;
293 }
295
296 ast_cli(a->fd, "----------\n%d channel drivers registered.\n", count_chan);
297
298 return CLI_SUCCESS;
299
300#undef FORMAT
301}
302
304{
305 struct chanlist *cl;
306 int wordlen;
307
308 if (a->pos != 3) {
309 return NULL;
310 }
311
312 wordlen = strlen(a->word);
313
316 if (!strncasecmp(a->word, cl->tech->type, wordlen)) {
318 }
319 }
321
322 return NULL;
323}
324
325/*! \brief Show details about a channel driver - CLI command */
326static char *handle_cli_core_show_channeltype(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
327{
328 struct chanlist *cl = NULL;
330
331 switch (cmd) {
332 case CLI_INIT:
333 e->command = "core show channeltype";
334 e->usage =
335 "Usage: core show channeltype <name>\n"
336 " Show details about the specified channel type, <name>.\n";
337 return NULL;
338 case CLI_GENERATE:
339 return complete_channeltypes(a);
340 }
341
342 if (a->argc != 4)
343 return CLI_SHOWUSAGE;
344
346
347 AST_RWLIST_TRAVERSE(&backends, cl, list) {
348 if (!strncasecmp(cl->tech->type, a->argv[3], strlen(cl->tech->type)))
349 break;
350 }
351
352
353 if (!cl) {
354 ast_cli(a->fd, "\n%s is not a registered channel driver.\n", a->argv[3]);
356 return CLI_FAILURE;
357 }
358
359 ast_cli(a->fd,
360 "-- Info about channel driver: %s --\n"
361 " Device State: %s\n"
362 "Presence State: %s\n"
363 " Indication: %s\n"
364 " Transfer : %s\n"
365 " Capabilities: %s\n"
366 " Digit Begin: %s\n"
367 " Digit End: %s\n"
368 " Send HTML : %s\n"
369 " Image Support: %s\n"
370 " Text Support: %s\n",
371 cl->tech->type,
372 (cl->tech->devicestate) ? "yes" : "no",
373 (cl->tech->presencestate) ? "yes" : "no",
374 (cl->tech->indicate) ? "yes" : "no",
375 (cl->tech->transfer) ? "yes" : "no",
376 ast_format_cap_get_names(cl->tech->capabilities, &codec_buf),
377 (cl->tech->send_digit_begin) ? "yes" : "no",
378 (cl->tech->send_digit_end) ? "yes" : "no",
379 (cl->tech->send_html) ? "yes" : "no",
380 (cl->tech->send_image) ? "yes" : "no",
381 (cl->tech->send_text) ? "yes" : "no"
382
383 );
384
386
387 return CLI_SUCCESS;
388}
389
390static struct ast_cli_entry cli_channel[] = {
391 AST_CLI_DEFINE(handle_cli_core_show_channeltypes, "List available channel types"),
392 AST_CLI_DEFINE(handle_cli_core_show_channeltype, "Give more details on that channel type")
393};
394
395static struct ast_frame *kill_read(struct ast_channel *chan)
396{
397 /* Hangup channel. */
398 return NULL;
399}
400
401static struct ast_frame *kill_exception(struct ast_channel *chan)
402{
403 /* Hangup channel. */
404 return NULL;
405}
406
407static int kill_write(struct ast_channel *chan, struct ast_frame *frame)
408{
409 /* Hangup channel. */
410 return -1;
411}
412
413static int kill_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
414{
415 /* No problem fixing up the channel. */
416 return 0;
417}
418
419static int kill_hangup(struct ast_channel *chan)
420{
422 return 0;
423}
424
425/*!
426 * \brief Kill the channel channel driver technology descriptor.
427 *
428 * \details
429 * The purpose of this channel technology is to encourage the
430 * channel to hangup as quickly as possible.
431 *
432 * \note Used by DTMF atxfer and zombie channels.
433 */
435 .type = "Kill",
436 .description = "Kill channel (should not see this)",
437 .read = kill_read,
438 .exception = kill_exception,
439 .write = kill_write,
440 .fixup = kill_fixup,
441 .hangup = kill_hangup,
442};
443
444/*! \brief Checks to see if a channel is needing hang up */
446{
447 if (ast_channel_softhangup_internal_flag(chan)) /* yes if soft hangup flag set */
448 return 1;
449 if (ast_tvzero(*ast_channel_whentohangup(chan))) /* no if no hangup scheduled */
450 return 0;
451 if (ast_tvdiff_ms(*ast_channel_whentohangup(chan), ast_tvnow()) > 0) /* no if hangup time has not come yet. */
452 return 0;
453 ast_debug(4, "Hangup time has come: %" PRIi64 "\n", ast_tvdiff_ms(*ast_channel_whentohangup(chan), ast_tvnow()));
454 ast_test_suite_event_notify("HANGUP_TIME", "Channel: %s", ast_channel_name(chan));
456 return 1;
457}
458
460{
461 int res;
462 ast_channel_lock(chan);
463 res = ast_check_hangup(chan);
464 ast_channel_unlock(chan);
465 return res;
466}
467
469{
470 ast_channel_lock(chan);
471
472 if (causecode > 0) {
473 ast_debug(1, "Setting hangupcause of channel %s to %d (is %d now)\n",
474 ast_channel_name(chan), causecode, ast_channel_hangupcause(chan));
475
476 ast_channel_hangupcause_set(chan, causecode);
477 }
478
480
481 ast_channel_unlock(chan);
482}
483
484static int ast_channel_softhangup_cb(void *obj, void *arg, int flags)
485{
486 struct ast_channel *chan = obj;
487
489
490 return 0;
491}
492
494{
496}
497
498/*! \brief returns number of active/allocated channels */
500{
502}
503
505{
507}
508
509/*! \brief Set when to hangup channel */
510void ast_channel_setwhentohangup_tv(struct ast_channel *chan, struct timeval offset)
511{
512 if (ast_tvzero(offset)) {
513 ast_channel_whentohangup_set(chan, &offset);
514 } else {
515 struct timeval tv = ast_tvadd(offset, ast_tvnow());
517 }
519 return;
520}
521
522/*! \brief Compare a offset with when to hangup channel */
523int ast_channel_cmpwhentohangup_tv(struct ast_channel *chan, struct timeval offset)
524{
525 struct timeval whentohangup;
526
528 return ast_tvzero(offset) ? 0 : -1;
529
530 if (ast_tvzero(offset))
531 return 1;
532
533 whentohangup = ast_tvadd(offset, ast_tvnow());
534
535 return ast_tvdiff_ms(whentohangup, *ast_channel_whentohangup(chan));
536}
537
538/*! \brief Register a new telephony channel in Asterisk */
540{
541 struct chanlist *chan;
542
544
546 if (!strcasecmp(tech->type, chan->tech->type)) {
547 ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
549 return -1;
550 }
551 }
552
553 if (!(chan = ast_calloc(1, sizeof(*chan)))) {
555 return -1;
556 }
557 chan->tech = tech;
559
560 ast_debug(5, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);
561
562 ast_verb(5, "Registered channel type '%s' (%s)\n", chan->tech->type, chan->tech->description);
563
565
566 return 0;
567}
568
569/*! \brief Unregister channel driver */
571{
572 struct chanlist *chan;
573
574 ast_debug(5, "Unregistering channel type '%s'\n", tech->type);
575
577
579 if (chan->tech == tech) {
581 ast_free(chan);
582 ast_verb(5, "Unregistered channel type '%s'\n", tech->type);
583 break;
584 }
585 }
587
589}
590
591/*! \brief Get handle to channel driver based on name */
593{
594 struct chanlist *chanls;
595 const struct ast_channel_tech *ret = NULL;
596
598
599 AST_RWLIST_TRAVERSE(&backends, chanls, list) {
600 if (!strcasecmp(name, chanls->tech->type)) {
601 ret = chanls->tech;
602 break;
603 }
604 }
605
607
608 return ret;
609}
610
611/*! \brief Gives the string form of a given hangup cause */
612const char *ast_cause2str(int cause)
613{
614 int x;
615
616 for (x = 0; x < ARRAY_LEN(causes); x++) {
617 if (causes[x].cause == cause)
618 return causes[x].desc;
619 }
620
621 return "Unknown";
622}
623
624/*! \brief Convert a symbolic hangup cause to number */
625int ast_str2cause(const char *name)
626{
627 int x;
628
629 for (x = 0; x < ARRAY_LEN(causes); x++)
630 if (!strncasecmp(causes[x].name, name, strlen(causes[x].name)))
631 return causes[x].cause;
632
633 return -1;
634}
635
637{
638 char *buf;
639
640 switch (state) {
641 case AST_STATE_DOWN:
642 return "Down";
644 return "Rsrvd";
646 return "OffHook";
648 return "Dialing";
649 case AST_STATE_RING:
650 return "Ring";
652 return "Ringing";
653 case AST_STATE_UP:
654 return "Up";
655 case AST_STATE_BUSY:
656 return "Busy";
658 return "Dialing Offhook";
660 return "Pre-ring";
661 case AST_STATE_MUTE:
662 return "Mute";
663 default:
665 return "Unknown";
666 snprintf(buf, STATE2STR_BUFSIZE, "Unknown (%u)", state);
667 return buf;
668 }
669}
670
671/*! \brief Gives the string form of a given transfer capability */
672char *ast_transfercapability2str(int transfercapability)
673{
674 switch (transfercapability) {
676 return "SPEECH";
678 return "DIGITAL";
680 return "RESTRICTED_DIGITAL";
682 return "3K1AUDIO";
684 return "DIGITAL_W_TONES";
686 return "VIDEO";
687 default:
688 return "UNKNOWN";
689 }
690}
691
692/*! \brief Channel technology used to extract a channel from a running application. The
693 * channel created with this technology will be immediately hung up - most external
694 * applications won't ever want to see this.
695 */
696static const struct ast_channel_tech surrogate_tech = {
697 .type = "Surrogate",
698 .description = "Surrogate channel used to pull channel from an application",
699 .properties = AST_CHAN_TP_INTERNAL,
700};
701
702static const struct ast_channel_tech null_tech = {
703 .type = "NULL",
704 .description = "Null channel (should not see this)",
705};
706
707static void ast_channel_destructor(void *obj);
708static void ast_dummy_channel_destructor(void *obj);
709static int ast_channel_by_uniqueid_cb(void *obj, void *arg, void *data, int flags);
710
711static int does_id_conflict(const char *uniqueid)
712{
713 struct ast_channel *conflict;
714 size_t length = 0;
715
717 return 0;
718 }
719
721 if (conflict) {
722 ast_log(LOG_ERROR, "Channel Unique ID '%s' already in use by channel %s(%p)\n",
723 uniqueid, ast_channel_name(conflict), conflict);
724 ast_channel_unref(conflict);
725 return 1;
726 }
727
728 return 0;
729}
730
731/*! \brief Create a new channel structure */
732static struct ast_channel *__attribute__((format(printf, 15, 0)))
733__ast_channel_alloc_ap(int needqueue, int state, const char *cid_num, const char *cid_name,
734 const char *acctcode, const char *exten, const char *context, const struct ast_assigned_ids *assignedids,
735 const struct ast_channel *requestor, enum ama_flags amaflag, struct ast_endpoint *endpoint,
736 const char *file, int line,
737 const char *function, const char *name_fmt, va_list ap)
738{
739 struct ast_channel *tmp;
740 struct varshead *headp;
741 char *tech = "", *tech2 = NULL;
742 struct ast_format_cap *nativeformats;
743 struct ast_sched_context *schedctx;
744 struct ast_timer *timer;
745 struct timeval now;
746 const struct ast_channel_tech *channel_tech;
747 struct ast_stream_topology *topology;
748
749 /* If shutting down, don't allocate any new channels */
750 if (ast_shutting_down()) {
751 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
752 return NULL;
753 }
754
756 file, line, function);
757 if (!tmp) {
758 /* Channel structure allocation failure. */
759 return NULL;
760 }
761
763
764 /*
765 * Init file descriptors to unopened state so
766 * the destructor can know not to close them.
767 */
771
773 if (!nativeformats) {
774 /*
775 * Aborting the channel creation. We do not need to complete staging
776 * the channel snapshot because the channel has not been finalized or
777 * linked into the channels container yet. Nobody else knows about
778 * this channel nor will anybody ever know about it.
779 */
780 return ast_channel_unref(tmp);
781 }
782 ast_format_cap_append(nativeformats, ast_format_none, 0);
783 ast_channel_nativeformats_set(tmp, nativeformats);
784 ao2_ref(nativeformats, -1);
785
790
791 if (!(schedctx = ast_sched_context_create())) {
792 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
793 /* See earlier channel creation abort comment above. */
794 return ast_channel_unref(tmp);
795 }
796 ast_channel_sched_set(tmp, schedctx);
797
803
804 if (cid_name) {
807 if (!ast_channel_caller(tmp)->id.name.str) {
808 /* See earlier channel creation abort comment above. */
809 return ast_channel_unref(tmp);
810 }
811 }
812 if (cid_num) {
815 if (!ast_channel_caller(tmp)->id.number.str) {
816 /* See earlier channel creation abort comment above. */
817 return ast_channel_unref(tmp);
818 }
819 }
820
821 if ((timer = ast_timer_open())) {
823 if (strcmp(ast_timer_get_name(ast_channel_timer(tmp)), "timerfd")) {
824 needqueue = 0;
825 }
827 }
828
829 if (needqueue && ast_channel_internal_alertpipe_init(tmp)) {
830 /* See earlier channel creation abort comment above. */
831 return ast_channel_unref(tmp);
832 }
833
834 if (!(topology = ast_stream_topology_alloc())) {
835 return ast_channel_unref(tmp);
836 }
838
839 /* Always watch the alertpipe */
841 /* And timing pipe */
843
844 /* Initial state */
847
850
853
854 now = ast_tvnow();
856
858
859 if (!ast_strlen_zero(name_fmt)) {
860 char *slash, *slash2;
861 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call.
862 * And they all use slightly different formats for their name string.
863 * This means, to set the name here, we have to accept variable args, and call the string_field_build from here.
864 * This means, that the stringfields must have a routine that takes the va_lists directly, and
865 * uses them to build the string, instead of forming the va_lists internally from the vararg ... list.
866 * This new function was written so this can be accomplished.
867 */
868 ast_channel_name_build_va(tmp, name_fmt, ap);
870 if ((slash = strchr(tech, '/'))) {
871 if ((slash2 = strchr(slash + 1, '/'))) {
872 tech2 = slash + 1;
873 *slash2 = '\0';
874 }
875 *slash = '\0';
876 }
877 } else {
878 /*
879 * Start the string with '-' so it becomes an empty string
880 * in the destructor.
881 */
882 ast_channel_name_set(tmp, "-**Unknown**");
883 }
884
885 if (amaflag != AST_AMA_NONE) {
887 } else {
889 }
890
891 if (!ast_strlen_zero(acctcode)) {
892 ast_channel_accountcode_set(tmp, acctcode);
893 }
894 ast_channel_language_set(tmp, ast_defaultlanguage);
895
897 ast_channel_exten_set(tmp, S_OR(exten, "s"));
899
900 headp = ast_channel_varshead(tmp);
902
906
907 channel_tech = ast_get_channel_tech(tech);
908 if (!channel_tech && !ast_strlen_zero(tech2)) {
909 channel_tech = ast_get_channel_tech(tech2);
910 }
911 if (channel_tech) {
912 ast_channel_tech_set(tmp, channel_tech);
913 } else {
915 }
916
917 /* You might scream "locking inversion" at seeing this but it is actually perfectly fine.
918 * Since the channel was just created nothing can know about it yet or even acquire it.
919 */
921
923
924 if (assignedids && (does_id_conflict(assignedids->uniqueid) || does_id_conflict(assignedids->uniqueid2))) {
928 /* See earlier channel creation abort comment above. */
929 return ast_channel_unref(tmp);
930 }
931
932 /* Finalize and link into the channels container. */
936
938
939 if (endpoint) {
940 ast_endpoint_add_channel(endpoint, tmp);
941 }
942
943 /*
944 * And now, since the channel structure is built, and has its name, let
945 * the world know of its existance
946 */
948
949 ast_debug(1, "Channel %p '%s' allocated\n", tmp, ast_channel_name(tmp));
950
951 return tmp;
952}
953
954struct ast_channel *__ast_channel_alloc(int needqueue, int state, const char *cid_num,
955 const char *cid_name, const char *acctcode,
956 const char *exten, const char *context, const struct ast_assigned_ids *assignedids,
957 const struct ast_channel *requestor, enum ama_flags amaflag,
958 struct ast_endpoint *endpoint,
959 const char *file, int line, const char *function,
960 const char *name_fmt, ...)
961{
962 va_list ap;
963 struct ast_channel *result;
964
965 va_start(ap, name_fmt);
966 result = __ast_channel_alloc_ap(needqueue, state, cid_num, cid_name, acctcode, exten, context,
967 assignedids, requestor, amaflag, endpoint, file, line, function, name_fmt, ap);
968 va_end(ap);
969
970 return result;
971}
972
973/* only do the minimum amount of work needed here to make a channel
974 * structure that can be used to expand channel vars */
975struct ast_channel *__ast_dummy_channel_alloc(const char *file, int line, const char *function)
976{
977 struct ast_channel *tmp;
978 struct varshead *headp;
979
981 file, line, function);
982 if (!tmp) {
983 /* Dummy channel structure allocation failure. */
984 return NULL;
985 }
986
989
990 /*
991 * Init file descriptors to unopened state just in case
992 * autoservice is called on the channel or something tries to
993 * read a frame from it.
994 */
998
1000
1002
1003 headp = ast_channel_varshead(tmp);
1005
1006 return tmp;
1007}
1008
1009static int __ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin, int head, struct ast_frame *after)
1010{
1011 struct ast_frame *f;
1012 struct ast_frame *cur;
1013 unsigned int new_frames = 0;
1014 unsigned int new_voice_frames = 0;
1015 unsigned int queued_frames = 0;
1016 unsigned int queued_voice_frames = 0;
1018
1019 ast_channel_lock(chan);
1020
1021 /*
1022 * Check the last frame on the queue if we are queuing the new
1023 * frames after it.
1024 */
1025 cur = AST_LIST_LAST(ast_channel_readq(chan));
1026 if (cur && cur->frametype == AST_FRAME_CONTROL && !head && (!after || after == cur)) {
1027 switch (cur->subclass.integer) {
1029 if (fin->frametype == AST_FRAME_CONTROL
1030 && fin->subclass.integer == AST_CONTROL_HANGUP) {
1031 /*
1032 * Destroy the end-of-Q marker frame so we can queue the hangup
1033 * frame in its place.
1034 */
1036 ast_frfree(cur);
1037
1038 /*
1039 * This has degenerated to a normal queue append anyway. Since
1040 * we just destroyed the last frame in the queue we must make
1041 * sure that "after" is NULL or bad things will happen.
1042 */
1043 after = NULL;
1044 break;
1045 }
1046 /* Fall through */
1047 case AST_CONTROL_HANGUP:
1048 /* Don't queue anything. */
1049 ast_channel_unlock(chan);
1050 return 0;
1051 default:
1052 break;
1053 }
1054 }
1055
1056 /* Build copies of all the new frames and count them */
1058 for (cur = fin; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
1059 if (!(f = ast_frdup(cur))) {
1060 if (AST_LIST_FIRST(&frames)) {
1062 }
1063 ast_channel_unlock(chan);
1064 return -1;
1065 }
1066
1068 new_frames++;
1069 if (f->frametype == AST_FRAME_VOICE) {
1070 new_voice_frames++;
1071 }
1072 }
1073
1074 /* Count how many frames exist on the queue */
1076 queued_frames++;
1077 if (cur->frametype == AST_FRAME_VOICE) {
1078 queued_voice_frames++;
1079 }
1080 }
1081
1082 if ((queued_frames + new_frames > 128 || queued_voice_frames + new_voice_frames > 96)) {
1083 int total_queued = queued_frames + new_frames;
1084 int total_voice = queued_voice_frames + new_voice_frames;
1085 int count = 0;
1086 ast_log(LOG_WARNING, "Exceptionally long %squeue length (%d voice / %d total) queuing to %s\n",
1087 queued_frames + new_frames > 128 ? "" : "voice ", total_voice, total_queued, ast_channel_name(chan));
1089 /* Save the most recent frame */
1090 if (!AST_LIST_NEXT(cur, frame_list)) {
1091 break;
1092 } else if (cur->frametype == AST_FRAME_VOICE || cur->frametype == AST_FRAME_VIDEO || cur->frametype == AST_FRAME_NULL) {
1093 if (++count > 64) {
1094 break;
1095 }
1097 ast_frfree(cur);
1098
1099 /* Read from the alert pipe for each flushed frame. */
1101 }
1102 }
1104 if (count) {
1105 ast_debug(4, "Discarded %d frame%s due to queue overload on %s\n", count, ESS(count), ast_channel_name(chan));
1106 }
1107 }
1108
1109 if (after) {
1111 } else {
1112 if (head) {
1115 }
1117 }
1118
1119 if (ast_channel_alert_writable(chan)) {
1120 /* Write to the alert pipe for each added frame */
1121 while (new_frames--) {
1122 if (ast_channel_alert_write(chan)) {
1123 ast_log(LOG_WARNING, "Unable to write to alert pipe on %s (qlen = %u): %s!\n",
1124 ast_channel_name(chan), queued_frames, strerror(errno));
1125 break;
1126 }
1127 }
1128 } else if (ast_channel_timingfd(chan) > -1) {
1131 pthread_kill(ast_channel_blocker(chan), SIGURG);
1132 }
1133
1134 ast_channel_unlock(chan);
1135
1136 return 0;
1137}
1138
1139int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
1140{
1141 return __ast_queue_frame(chan, fin, 0, NULL);
1142}
1143
1144int ast_queue_frame_head(struct ast_channel *chan, struct ast_frame *fin)
1145{
1146 return __ast_queue_frame(chan, fin, 1, NULL);
1147}
1148
1149/*! \brief Queue a hangup frame for channel */
1151{
1152 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_HANGUP };
1153 int res;
1154
1155 /* Yeah, let's not change a lock-critical value without locking */
1156 ast_channel_lock(chan);
1159
1160 res = ast_queue_frame(chan, &f);
1161 ast_channel_unlock(chan);
1162 return res;
1163}
1164
1165/*! \brief Queue a hangup frame for channel */
1166int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
1167{
1168 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
1169 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_HANGUP };
1170 int res;
1171
1172 if (cause >= 0) {
1173 f.data.uint32 = cause;
1174 }
1175
1176 /* Yeah, let's not change a lock-critical value without locking */
1177 ast_channel_lock(chan);
1179 if (cause < 0) {
1181 }
1182 blob = ast_json_pack("{s: i}",
1183 "cause", cause);
1185
1186 res = ast_queue_frame(chan, &f);
1187 ast_channel_unlock(chan);
1188 return res;
1189}
1190
1191int ast_queue_hold(struct ast_channel *chan, const char *musicclass)
1192{
1193 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_HOLD };
1194 struct ast_json *blob = NULL;
1195 int res;
1196
1197 if (!ast_strlen_zero(musicclass)) {
1198 f.data.ptr = (void *) musicclass;
1199 f.datalen = strlen(musicclass) + 1;
1200
1201 blob = ast_json_pack("{s: s}",
1202 "musicclass", musicclass);
1203 }
1204
1205 ast_channel_lock(chan);
1207 ast_channel_unlock(chan);
1208
1209 res = ast_queue_frame(chan, &f);
1210
1211 ast_json_unref(blob);
1212
1213 return res;
1214}
1215
1217{
1218 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_UNHOLD };
1219 int res;
1220
1221 ast_channel_lock(chan);
1223 ast_channel_unlock(chan);
1224
1225 res = ast_queue_frame(chan, &f);
1226
1227 return res;
1228}
1229
1230/*! \brief Queue a control frame */
1232{
1233 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = control };
1234 return ast_queue_frame(chan, &f);
1235}
1236
1237/*! \brief Queue a control frame with payload */
1239 const void *data, size_t datalen)
1240{
1241 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = control, .data.ptr = (void *) data, .datalen = datalen };
1242 return ast_queue_frame(chan, &f);
1243}
1244
1245/*! \brief Queue an ANSWER control frame with topology */
1246int ast_queue_answer(struct ast_channel *chan, const struct ast_stream_topology *topology)
1247{
1248 struct ast_frame f = {
1250 .subclass.integer = AST_CONTROL_ANSWER,
1251 .subclass.topology = (struct ast_stream_topology *)topology,
1252 };
1253 return ast_queue_frame(chan, &f);
1254}
1255
1256/*! \brief Set defer DTMF flag on channel */
1258{
1259 int pre = 0;
1260
1261 if (chan) {
1262 ast_channel_lock(chan);
1265 ast_channel_unlock(chan);
1266 }
1267 return pre;
1268}
1269
1270/*! \brief Unset defer DTMF flag on channel */
1272{
1273 if (chan) {
1275 }
1276}
1277
1279 void *data, int ao2_flags)
1280{
1281 return ao2_callback_data(channels, ao2_flags, cb_fn, arg, data);
1282}
1283
1284static int ast_channel_by_name_cb(void *obj, void *arg, void *data, int flags)
1285{
1286 struct ast_channel *chan = obj;
1287 const char *name = arg;
1288 size_t name_len = *(size_t *) data;
1289 int ret = CMP_MATCH;
1290
1291 if (ast_strlen_zero(name)) {
1292 ast_log(LOG_ERROR, "BUG! Must supply a channel name or partial name to match!\n");
1293 return CMP_STOP;
1294 }
1295
1296 ast_channel_lock(chan);
1297 if ((!name_len && strcasecmp(ast_channel_name(chan), name))
1298 || (name_len && strncasecmp(ast_channel_name(chan), name, name_len))) {
1299 ret = 0; /* name match failed, keep looking */
1300 }
1301 ast_channel_unlock(chan);
1302
1303 return ret;
1304}
1305
1306static int ast_channel_by_exten_cb(void *obj, void *arg, void *data, int flags)
1307{
1308 struct ast_channel *chan = obj;
1309 char *context = arg;
1310 char *exten = data;
1311 int ret = CMP_MATCH;
1312
1314 ast_log(LOG_ERROR, "BUG! Must have a context and extension to match!\n");
1315 return CMP_STOP;
1316 }
1317
1318 ast_channel_lock(chan);
1319 if (strcasecmp(ast_channel_context(chan), context)) {
1320 ret = 0; /* Context match failed, continue */
1321 } else if (strcasecmp(ast_channel_exten(chan), exten)) {
1322 ret = 0; /* Extension match failed, continue */
1323 }
1324 ast_channel_unlock(chan);
1325
1326 return ret;
1327}
1328
1329static int ast_channel_by_uniqueid_cb(void *obj, void *arg, void *data, int flags)
1330{
1331 struct ast_channel *chan = obj;
1332 char *uniqueid = arg;
1333 size_t id_len = *(size_t *) data;
1334 int ret = CMP_MATCH;
1335
1337 ast_log(LOG_ERROR, "BUG! Must supply a uniqueid or partial uniqueid to match!\n");
1338 return CMP_STOP;
1339 }
1340
1341 ast_channel_lock(chan);
1342 if ((!id_len && strcasecmp(ast_channel_uniqueid(chan), uniqueid))
1343 || (id_len && strncasecmp(ast_channel_uniqueid(chan), uniqueid, id_len))) {
1344 ret = 0; /* uniqueid match failed, keep looking */
1345 }
1346 ast_channel_unlock(chan);
1347
1348 return ret;
1349}
1350
1352 /* storage for non-dynamically allocated iterator */
1354 /* pointer to the actual iterator (simple_iterator or a dynamically
1355 * allocated iterator)
1356 */
1358};
1359
1361{
1363 ast_free(i);
1364
1365 return NULL;
1366}
1367
1369{
1370 struct ast_channel_iterator *i;
1371 char *l_exten = (char *) exten;
1372 char *l_context = (char *) context;
1373
1374 if (!(i = ast_calloc(1, sizeof(*i)))) {
1375 return NULL;
1376 }
1377
1379 l_context, l_exten, OBJ_MULTIPLE);
1380 if (!i->active_iterator) {
1381 ast_free(i);
1382 return NULL;
1383 }
1384
1385 return i;
1386}
1387
1389{
1390 struct ast_channel_iterator *i;
1391 char *l_name = (char *) name;
1392
1393 if (!(i = ast_calloc(1, sizeof(*i)))) {
1394 return NULL;
1395 }
1396
1398 l_name, &name_len,
1399 OBJ_MULTIPLE | (name_len == 0 /* match the whole word, so optimize */ ? OBJ_KEY : 0));
1400 if (!i->active_iterator) {
1401 ast_free(i);
1402 return NULL;
1403 }
1404
1405 return i;
1406}
1407
1409{
1410 struct ast_channel_iterator *i;
1411
1412 if (!(i = ast_calloc(1, sizeof(*i)))) {
1413 return NULL;
1414 }
1415
1418
1419 return i;
1420}
1421
1423{
1425}
1426
1427/* Legacy function, not currently used for lookups, but we need a cmp_fn */
1428static int ast_channel_cmp_cb(void *obj, void *arg, int flags)
1429{
1430 ast_log(LOG_ERROR, "BUG! Should never be called!\n");
1431 return CMP_STOP;
1432}
1433
1434struct ast_channel *ast_channel_get_by_name_prefix(const char *name, size_t name_len)
1435{
1436 struct ast_channel *chan;
1437 char *l_name = (char *) name;
1438
1439 if (ast_strlen_zero(l_name)) {
1440 /* We didn't have a name to search for so quit. */
1441 return NULL;
1442 }
1443
1444 chan = ast_channel_callback(ast_channel_by_name_cb, l_name, &name_len,
1445 (name_len == 0) /* optimize if it is a complete name match */ ? OBJ_KEY : 0);
1446 if (chan) {
1447 return chan;
1448 }
1449
1450 /* Now try a search for uniqueid. */
1451 return ast_channel_callback(ast_channel_by_uniqueid_cb, l_name, &name_len, 0);
1452}
1453
1455{
1457}
1458
1459struct ast_channel *ast_channel_get_by_exten(const char *exten, const char *context)
1460{
1461 char *l_exten = (char *) exten;
1462 char *l_context = (char *) context;
1463
1464 return ast_channel_callback(ast_channel_by_exten_cb, l_context, l_exten, 0);
1465}
1466
1467int ast_is_deferrable_frame(const struct ast_frame *frame)
1468{
1469 /* Do not add a default entry in this switch statement. Each new
1470 * frame type should be addressed directly as to whether it should
1471 * be queued up or not.
1472 */
1473 switch (frame->frametype) {
1476 case AST_FRAME_CONTROL:
1477 case AST_FRAME_TEXT:
1479 case AST_FRAME_IMAGE:
1480 case AST_FRAME_HTML:
1481 return 1;
1482
1483 case AST_FRAME_DTMF_END:
1485 case AST_FRAME_VOICE:
1486 case AST_FRAME_VIDEO:
1487 case AST_FRAME_NULL:
1488 case AST_FRAME_IAX:
1489 case AST_FRAME_CNG:
1490 case AST_FRAME_MODEM:
1491 case AST_FRAME_RTCP:
1492 return 0;
1493 }
1494 return 0;
1495}
1496
1497/*! \brief Wait, look for hangups and condition arg */
1498static int safe_sleep_conditional(struct ast_channel *chan, int timeout_ms, int (*cond)(void*), void *data, unsigned int generate_silence)
1499{
1500 struct ast_frame *f;
1501 struct ast_silence_generator *silgen = NULL;
1502 int res = 0;
1503 struct timeval start;
1504 int ms;
1505 AST_LIST_HEAD_NOLOCK(, ast_frame) deferred_frames;
1506
1507 AST_LIST_HEAD_INIT_NOLOCK(&deferred_frames);
1508
1509 /* If no other generator is present, start silencegen while waiting */
1510 if (generate_silence && ast_opt_transmit_silence && !ast_channel_generatordata(chan)) {
1512 }
1513
1514 start = ast_tvnow();
1515 while ((ms = ast_remaining_ms(start, timeout_ms))) {
1516 struct ast_frame *dup_f = NULL;
1517
1518 if (cond && ((*cond)(data) == 0)) {
1519 break;
1520 }
1521 ms = ast_waitfor(chan, ms);
1522 if (ms < 0) {
1523 res = -1;
1524 break;
1525 }
1526 if (ms > 0) {
1527 f = ast_read(chan);
1528 if (!f) {
1529 res = -1;
1530 break;
1531 }
1532
1533 if (!ast_is_deferrable_frame(f)) {
1534 ast_frfree(f);
1535 continue;
1536 }
1537
1538 if ((dup_f = ast_frisolate(f))) {
1539 if (dup_f != f) {
1540 ast_frfree(f);
1541 }
1542 AST_LIST_INSERT_HEAD(&deferred_frames, dup_f, frame_list);
1543 }
1544 }
1545 }
1546
1547 /* stop silgen if present */
1548 if (silgen) {
1550 }
1551
1552 /* We need to free all the deferred frames, but we only need to
1553 * queue the deferred frames if there was no error and no
1554 * hangup was received
1555 */
1556 ast_channel_lock(chan);
1557 while ((f = AST_LIST_REMOVE_HEAD(&deferred_frames, frame_list))) {
1558 if (!res) {
1559 ast_queue_frame_head(chan, f);
1560 }
1561 ast_frfree(f);
1562 }
1563 ast_channel_unlock(chan);
1564
1565 return res;
1566}
1567
1568int ast_safe_sleep_conditional(struct ast_channel *chan, int timeout_ms, int (*cond)(void*), void *data)
1569{
1570 return safe_sleep_conditional(chan, timeout_ms, cond, data, 1);
1571}
1572
1573/*! \brief Wait, look for hangups */
1574int ast_safe_sleep(struct ast_channel *chan, int ms)
1575{
1576 return safe_sleep_conditional(chan, ms, NULL, NULL, 1);
1577}
1578
1580{
1581 return safe_sleep_conditional(chan, ms, NULL, NULL, 0);
1582}
1583
1585{
1586 /* Safe, even if already unlinked. */
1587 ao2_unlink(channels, chan);
1588 return ast_channel_unref(chan);
1589}
1590
1592{
1593 init->str = NULL;
1596 init->valid = 0;
1597}
1598
1599void ast_party_name_copy(struct ast_party_name *dest, const struct ast_party_name *src)
1600{
1601 if (dest == src) {
1602 /* Don't copy to self */
1603 return;
1604 }
1605
1606 ast_free(dest->str);
1607 dest->str = ast_strdup(src->str);
1608 dest->char_set = src->char_set;
1609 dest->presentation = src->presentation;
1610 dest->valid = src->valid;
1611}
1612
1613void ast_party_name_set_init(struct ast_party_name *init, const struct ast_party_name *guide)
1614{
1615 init->str = NULL;
1616 init->char_set = guide->char_set;
1617 init->presentation = guide->presentation;
1618 init->valid = guide->valid;
1619}
1620
1621void ast_party_name_set(struct ast_party_name *dest, const struct ast_party_name *src)
1622{
1623 if (dest == src) {
1624 /* Don't set to self */
1625 return;
1626 }
1627
1628 if (src->str && src->str != dest->str) {
1629 ast_free(dest->str);
1630 dest->str = ast_strdup(src->str);
1631 }
1632
1633 dest->char_set = src->char_set;
1634 dest->presentation = src->presentation;
1635 dest->valid = src->valid;
1636}
1637
1639{
1640 ast_free(doomed->str);
1641 doomed->str = NULL;
1642}
1643
1645{
1646 init->str = NULL;
1647 init->plan = 0;/* Unknown */
1649 init->valid = 0;
1650}
1651
1652void ast_party_number_copy(struct ast_party_number *dest, const struct ast_party_number *src)
1653{
1654 if (dest == src) {
1655 /* Don't copy to self */
1656 return;
1657 }
1658
1659 ast_free(dest->str);
1660 dest->str = ast_strdup(src->str);
1661 dest->plan = src->plan;
1662 dest->presentation = src->presentation;
1663 dest->valid = src->valid;
1664}
1665
1666void ast_party_number_set_init(struct ast_party_number *init, const struct ast_party_number *guide)
1667{
1668 init->str = NULL;
1669 init->plan = guide->plan;
1670 init->presentation = guide->presentation;
1671 init->valid = guide->valid;
1672}
1673
1674void ast_party_number_set(struct ast_party_number *dest, const struct ast_party_number *src)
1675{
1676 if (dest == src) {
1677 /* Don't set to self */
1678 return;
1679 }
1680
1681 if (src->str && src->str != dest->str) {
1682 ast_free(dest->str);
1683 dest->str = ast_strdup(src->str);
1684 }
1685
1686 dest->plan = src->plan;
1687 dest->presentation = src->presentation;
1688 dest->valid = src->valid;
1689}
1690
1692{
1693 ast_free(doomed->str);
1694 doomed->str = NULL;
1695}
1696
1698{
1699 init->str = NULL;
1700 init->type = 0;
1701 init->odd_even_indicator = 0;
1702 init->valid = 0;
1703}
1704
1706{
1707 if (dest == src) {
1708 /* Don't copy to self */
1709 return;
1710 }
1711
1712 ast_free(dest->str);
1713 dest->str = ast_strdup(src->str);
1714 dest->type = src->type;
1716 dest->valid = src->valid;
1717}
1718
1720{
1721 init->str = NULL;
1722 init->type = guide->type;
1724 init->valid = guide->valid;
1725}
1726
1728{
1729 if (dest == src) {
1730 /* Don't set to self */
1731 return;
1732 }
1733
1734 if (src->str && src->str != dest->str) {
1735 ast_free(dest->str);
1736 dest->str = ast_strdup(src->str);
1737 }
1738
1739 dest->type = src->type;
1741 dest->valid = src->valid;
1742}
1743
1745{
1746 ast_free(doomed->str);
1747 doomed->str = NULL;
1748}
1749
1751{
1752 update_id->name = 1;
1753 update_id->number = 1;
1754 update_id->subaddress = 1;
1755}
1756
1758{
1759 ast_party_name_init(&init->name);
1762 init->tag = NULL;
1763}
1764
1765void ast_party_id_copy(struct ast_party_id *dest, const struct ast_party_id *src)
1766{
1767 if (dest == src) {
1768 /* Don't copy to self */
1769 return;
1770 }
1771
1772 ast_party_name_copy(&dest->name, &src->name);
1773 ast_party_number_copy(&dest->number, &src->number);
1775
1776 ast_free(dest->tag);
1777 dest->tag = ast_strdup(src->tag);
1778}
1779
1780void ast_party_id_set_init(struct ast_party_id *init, const struct ast_party_id *guide)
1781{
1782 ast_party_name_set_init(&init->name, &guide->name);
1783 ast_party_number_set_init(&init->number, &guide->number);
1785 init->tag = NULL;
1786}
1787
1788void ast_party_id_set(struct ast_party_id *dest, const struct ast_party_id *src, const struct ast_set_party_id *update)
1789{
1790 if (dest == src) {
1791 /* Don't set to self */
1792 return;
1793 }
1794
1795 if (!update || update->name) {
1796 ast_party_name_set(&dest->name, &src->name);
1797 }
1798 if (!update || update->number) {
1799 ast_party_number_set(&dest->number, &src->number);
1800 }
1801 if (!update || update->subaddress) {
1803 }
1804
1805 if (src->tag && src->tag != dest->tag) {
1806 ast_free(dest->tag);
1807 dest->tag = ast_strdup(src->tag);
1808 }
1809}
1810
1812{
1813 ast_party_name_free(&doomed->name);
1814 ast_party_number_free(&doomed->number);
1816
1817 ast_free(doomed->tag);
1818 doomed->tag = NULL;
1819}
1820
1822{
1823 int number_priority;
1824 int number_value;
1825 int number_screening;
1826 int name_priority;
1827 int name_value;
1828
1829 /* Determine name presentation priority. */
1830 if (!id->name.valid) {
1831 name_value = AST_PRES_UNAVAILABLE;
1832 name_priority = 3;
1833 } else {
1834 name_value = id->name.presentation & AST_PRES_RESTRICTION;
1835 switch (name_value) {
1837 name_priority = 0;
1838 break;
1839 case AST_PRES_ALLOWED:
1840 name_priority = 1;
1841 break;
1843 name_priority = 2;
1844 break;
1845 default:
1846 name_value = AST_PRES_UNAVAILABLE;
1847 name_priority = 3;
1848 break;
1849 }
1850 }
1851
1852 /* Determine number presentation priority. */
1853 if (!id->number.valid) {
1854 number_screening = AST_PRES_USER_NUMBER_UNSCREENED;
1855 number_value = AST_PRES_UNAVAILABLE;
1856 number_priority = 3;
1857 } else {
1858 number_screening = id->number.presentation & AST_PRES_NUMBER_TYPE;
1859 number_value = id->number.presentation & AST_PRES_RESTRICTION;
1860 switch (number_value) {
1862 number_priority = 0;
1863 break;
1864 case AST_PRES_ALLOWED:
1865 number_priority = 1;
1866 break;
1868 number_priority = 2;
1869 break;
1870 default:
1871 number_screening = AST_PRES_USER_NUMBER_UNSCREENED;
1872 number_value = AST_PRES_UNAVAILABLE;
1873 number_priority = 3;
1874 break;
1875 }
1876 }
1877
1878 /* Select the wining presentation value. */
1879 if (name_priority < number_priority) {
1880 number_value = name_value;
1881 }
1882 if (number_value == AST_PRES_UNAVAILABLE) {
1884 }
1885
1886 return number_value | number_screening;
1887}
1888
1890{
1891 id->name.valid = 0;
1892 id->number.valid = 0;
1893 id->subaddress.valid = 0;
1894}
1895
1897{
1900}
1901
1902struct ast_party_id ast_party_id_merge(struct ast_party_id *base, struct ast_party_id *overlay)
1903{
1904 struct ast_party_id merged;
1905
1906 merged = *base;
1907 if (overlay->name.valid) {
1908 merged.name = overlay->name;
1909 }
1910 if (overlay->number.valid) {
1911 merged.number = overlay->number;
1912 }
1913 if (overlay->subaddress.valid) {
1914 merged.subaddress = overlay->subaddress;
1915 }
1916 /* Note the actual structure is returned and not a pointer to it! */
1917 return merged;
1918}
1919
1920void ast_party_id_merge_copy(struct ast_party_id *dest, struct ast_party_id *base, struct ast_party_id *overlay)
1921{
1922 struct ast_party_id merged;
1923
1924 merged = ast_party_id_merge(base, overlay);
1925 ast_party_id_copy(dest, &merged);
1926}
1927
1929{
1930 init->number.str = NULL;
1931 init->number.plan = 0;/* Unknown */
1933 init->transit_network_select = 0;
1934}
1935
1936void ast_party_dialed_copy(struct ast_party_dialed *dest, const struct ast_party_dialed *src)
1937{
1938 if (dest == src) {
1939 /* Don't copy to self */
1940 return;
1941 }
1942
1943 ast_free(dest->number.str);
1944 dest->number.str = ast_strdup(src->number.str);
1945 dest->number.plan = src->number.plan;
1948}
1949
1950void ast_party_dialed_set_init(struct ast_party_dialed *init, const struct ast_party_dialed *guide)
1951{
1952 init->number.str = NULL;
1953 init->number.plan = guide->number.plan;
1956}
1957
1958void ast_party_dialed_set(struct ast_party_dialed *dest, const struct ast_party_dialed *src)
1959{
1960 if (src->number.str && src->number.str != dest->number.str) {
1961 ast_free(dest->number.str);
1962 dest->number.str = ast_strdup(src->number.str);
1963 }
1964 dest->number.plan = src->number.plan;
1965
1967
1969}
1970
1972{
1973 ast_free(doomed->number.str);
1974 doomed->number.str = NULL;
1976}
1977
1979{
1980 ast_party_id_init(&init->id);
1981 ast_party_id_init(&init->ani);
1982 ast_party_id_init(&init->priv);
1983 init->ani2 = 0;
1984}
1985
1986void ast_party_caller_copy(struct ast_party_caller *dest, const struct ast_party_caller *src)
1987{
1988 if (dest == src) {
1989 /* Don't copy to self */
1990 return;
1991 }
1992
1993 ast_party_id_copy(&dest->id, &src->id);
1994 ast_party_id_copy(&dest->ani, &src->ani);
1995 ast_party_id_copy(&dest->priv, &src->priv);
1996 dest->ani2 = src->ani2;
1997}
1998
1999void ast_party_caller_set_init(struct ast_party_caller *init, const struct ast_party_caller *guide)
2000{
2001 ast_party_id_set_init(&init->id, &guide->id);
2002 ast_party_id_set_init(&init->ani, &guide->ani);
2003 ast_party_id_set_init(&init->priv, &guide->priv);
2004 init->ani2 = guide->ani2;
2005}
2006
2007void ast_party_caller_set(struct ast_party_caller *dest, const struct ast_party_caller *src, const struct ast_set_party_caller *update)
2008{
2009 ast_party_id_set(&dest->id, &src->id, update ? &update->id : NULL);
2010 ast_party_id_set(&dest->ani, &src->ani, update ? &update->ani : NULL);
2011 ast_party_id_set(&dest->priv, &src->priv, update ? &update->priv : NULL);
2012 dest->ani2 = src->ani2;
2013}
2014
2016{
2017 ast_party_id_free(&doomed->id);
2018 ast_party_id_free(&doomed->ani);
2019 ast_party_id_free(&doomed->priv);
2020}
2021
2023{
2024 ast_party_id_init(&init->id);
2025 ast_party_id_init(&init->ani);
2026 ast_party_id_init(&init->priv);
2027 init->ani2 = 0;
2029}
2030
2032{
2033 if (dest == src) {
2034 /* Don't copy to self */
2035 return;
2036 }
2037
2038 ast_party_id_copy(&dest->id, &src->id);
2039 ast_party_id_copy(&dest->ani, &src->ani);
2040 ast_party_id_copy(&dest->priv, &src->priv);
2041 dest->ani2 = src->ani2;
2042 dest->source = src->source;
2043}
2044
2046{
2047 ast_party_id_set_init(&init->id, &guide->id);
2048 ast_party_id_set_init(&init->ani, &guide->ani);
2049 ast_party_id_set_init(&init->priv, &guide->priv);
2050 init->ani2 = guide->ani2;
2051 init->source = guide->source;
2052}
2053
2055{
2056 ast_party_id_set(&dest->id, &src->id, update ? &update->id : NULL);
2057 ast_party_id_set(&dest->ani, &src->ani, update ? &update->ani : NULL);
2058 ast_party_id_set(&dest->priv, &src->priv, update ? &update->priv : NULL);
2059 dest->ani2 = src->ani2;
2060 dest->source = src->source;
2061}
2062
2064{
2065 connected->id = caller->id;
2066 connected->ani = caller->ani;
2067 connected->priv = caller->priv;
2068 connected->ani2 = caller->ani2;
2070}
2071
2073{
2074 ast_party_id_free(&doomed->id);
2075 ast_party_id_free(&doomed->ani);
2076 ast_party_id_free(&doomed->priv);
2077}
2078
2080{
2081 init->str = NULL;
2083}
2084
2086{
2087 if (dest == src) {
2088 return;
2089 }
2090
2091 ast_free(dest->str);
2092 dest->str = ast_strdup(src->str);
2093 dest->code = src->code;
2094}
2095
2097{
2098 init->str = NULL;
2099 init->code = guide->code;
2100}
2101
2103{
2104 if (dest == src) {
2105 return;
2106 }
2107
2108 if (src->str && src->str != dest->str) {
2109 ast_free(dest->str);
2110 dest->str = ast_strdup(src->str);
2111 }
2112
2113 dest->code = src->code;
2114}
2115
2117{
2118 ast_free(doomed->str);
2119}
2120
2121
2123{
2124 ast_party_id_init(&init->orig);
2125 ast_party_id_init(&init->from);
2126 ast_party_id_init(&init->to);
2129 ast_party_id_init(&init->priv_to);
2132 init->count = 0;
2133}
2134
2136{
2137 if (dest == src) {
2138 /* Don't copy to self */
2139 return;
2140 }
2141
2142 ast_party_id_copy(&dest->orig, &src->orig);
2143 ast_party_id_copy(&dest->from, &src->from);
2144 ast_party_id_copy(&dest->to, &src->to);
2145 ast_party_id_copy(&dest->priv_orig, &src->priv_orig);
2146 ast_party_id_copy(&dest->priv_from, &src->priv_from);
2147 ast_party_id_copy(&dest->priv_to, &src->priv_to);
2150 dest->count = src->count;
2151}
2152
2154{
2155 ast_party_id_set_init(&init->orig, &guide->orig);
2156 ast_party_id_set_init(&init->from, &guide->from);
2157 ast_party_id_set_init(&init->to, &guide->to);
2158 ast_party_id_set_init(&init->priv_orig, &guide->priv_orig);
2159 ast_party_id_set_init(&init->priv_from, &guide->priv_from);
2160 ast_party_id_set_init(&init->priv_to, &guide->priv_to);
2163 init->count = guide->count;
2164}
2165
2167{
2168 ast_party_id_set(&dest->orig, &src->orig, update ? &update->orig : NULL);
2169 ast_party_id_set(&dest->from, &src->from, update ? &update->from : NULL);
2170 ast_party_id_set(&dest->to, &src->to, update ? &update->to : NULL);
2171 ast_party_id_set(&dest->priv_orig, &src->priv_orig, update ? &update->priv_orig : NULL);
2172 ast_party_id_set(&dest->priv_from, &src->priv_from, update ? &update->priv_from : NULL);
2173 ast_party_id_set(&dest->priv_to, &src->priv_to, update ? &update->priv_to : NULL);
2176 dest->count = src->count;
2177}
2178
2180{
2181 ast_party_id_free(&doomed->orig);
2182 ast_party_id_free(&doomed->from);
2183 ast_party_id_free(&doomed->to);
2184 ast_party_id_free(&doomed->priv_orig);
2185 ast_party_id_free(&doomed->priv_from);
2186 ast_party_id_free(&doomed->priv_to);
2189}
2190
2191/*! \brief Free a channel structure */
2192static void ast_channel_destructor(void *obj)
2193{
2194 struct ast_channel *chan = obj;
2195 struct ast_var_t *vardata;
2196 struct ast_frame *f;
2197 struct varshead *headp;
2198 struct ast_datastore *datastore;
2199 char device_name[AST_CHANNEL_NAME];
2200 ast_callid callid;
2201
2202 ast_debug(1, "Channel %p '%s' destroying\n", chan, ast_channel_name(chan));
2203
2204 /* If there is native format music-on-hold state, free it */
2205 if (ast_channel_music_state(chan)) {
2206 ast_moh_cleanup(chan);
2207 }
2208
2210
2211 /* Things that may possibly raise Stasis messages shouldn't occur after this point */
2213
2215 /* A channel snapshot should not be in the process of being staged now. */
2217
2218 ast_channel_lock(chan);
2220 ast_channel_unlock(chan);
2221 }
2222
2223 ast_channel_lock(chan);
2224
2225 /* Get rid of each of the data stores on the channel */
2226 while ((datastore = AST_LIST_REMOVE_HEAD(ast_channel_datastores(chan), entry)))
2227 /* Free the data store */
2228 ast_datastore_free(datastore);
2229
2230 /* While the channel is locked, take the reference to its callid while we tear down the call. */
2231 callid = ast_channel_callid(chan);
2233
2234 ast_channel_unlock(chan);
2235
2236 /* Lock and unlock the channel just to be sure nobody has it locked still
2237 due to a reference that was stored in a datastore. (i.e. app_chanspy) */
2238 ast_channel_lock(chan);
2239 ast_channel_unlock(chan);
2240
2241 if (ast_channel_tech_pvt(chan)) {
2242 ast_log_callid(LOG_WARNING, callid, "Channel '%s' may not have been hung up properly\n", ast_channel_name(chan));
2244 }
2245
2246 if (ast_channel_sched(chan)) {
2248 }
2249
2251 char *dashptr;
2252
2253 ast_copy_string(device_name, ast_channel_name(chan), sizeof(device_name));
2254 if ((dashptr = strrchr(device_name, '-'))) {
2255 *dashptr = '\0';
2256 }
2257 } else {
2258 device_name[0] = '\0';
2259 }
2260
2261 /* Free translators */
2262 if (ast_channel_readtrans(chan))
2264 if (ast_channel_writetrans(chan))
2266 if (ast_channel_pbx(chan))
2267 ast_log_callid(LOG_WARNING, callid, "PBX may not have been terminated properly on '%s'\n", ast_channel_name(chan));
2268
2269 /* Free formats */
2275
2281
2282 /* Close pipes if appropriate */
2284 if (ast_channel_timer(chan)) {
2287 }
2289 ast_frfree(f);
2290
2291 /* loop over the variables list, freeing all data and deleting list items */
2292 /* no need to lock the list, as the channel is already locked */
2293 headp = ast_channel_varshead(chan);
2294 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
2295 ast_var_delete(vardata);
2296
2298
2299 /* Destroy the jitterbuffer */
2300 ast_jb_destroy(chan);
2301
2302 if (ast_channel_cdr(chan)) {
2305 }
2306
2307 if (ast_channel_zone(chan)) {
2309 }
2310
2312
2313 if (device_name[0]) {
2314 /*
2315 * We have a device name to notify of a new state.
2316 *
2317 * Queue an unknown state, because, while we know that this particular
2318 * instance is dead, we don't know the state of all other possible
2319 * instances.
2320 */
2322 }
2323
2325
2328
2330}
2331
2332/*! \brief Free a dummy channel structure */
2333static void ast_dummy_channel_destructor(void *obj)
2334{
2335 struct ast_channel *chan = obj;
2336 struct ast_datastore *datastore;
2337 struct ast_var_t *vardata;
2338 struct varshead *headp;
2339
2341
2342 /* Get rid of each of the data stores on the channel */
2343 while ((datastore = AST_LIST_REMOVE_HEAD(ast_channel_datastores(chan), entry))) {
2344 /* Free the data store */
2345 ast_datastore_free(datastore);
2346 }
2347
2353
2354 /* loop over the variables list, freeing all data and deleting list items */
2355 /* no need to lock the list, as the channel is already locked */
2356 headp = ast_channel_varshead(chan);
2357 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
2358 ast_var_delete(vardata);
2359
2360 if (ast_channel_cdr(chan)) {
2363 }
2364
2366}
2367
2369{
2370 struct ast_datastore *datastore = NULL, *datastore2;
2371
2373 if (datastore->inheritance > 0) {
2374 datastore2 = ast_datastore_alloc(datastore->info, datastore->uid);
2375 if (datastore2) {
2376 datastore2->data = datastore->info->duplicate ? datastore->info->duplicate(datastore->data) : NULL;
2377 datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
2379 }
2380 }
2381 }
2382 return 0;
2383}
2384
2385int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
2386{
2387 int res = 0;
2388
2390
2391 return res;
2392}
2393
2394int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
2395{
2396 return AST_LIST_REMOVE(ast_channel_datastores(chan), datastore, entry) ? 0 : -1;
2397}
2398
2399struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
2400{
2401 struct ast_datastore *datastore = NULL;
2402
2403 if (info == NULL)
2404 return NULL;
2405
2407 if (datastore->info != info) {
2408 continue;
2409 }
2410
2411 if (uid == NULL) {
2412 /* matched by type only */
2413 break;
2414 }
2415
2416 if ((datastore->uid != NULL) && !strcasecmp(uid, datastore->uid)) {
2417 /* Matched by type AND uid */
2418 break;
2419 }
2420 }
2421
2422 return datastore;
2423}
2424
2425/*! Set the file descriptor on the channel */
2426void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
2427{
2428 ast_channel_internal_fd_set(chan, which, fd);
2429 return;
2430}
2431
2433{
2434 ast_channel_lock(chan);
2435
2437
2439 struct ast_frame *fr;
2440
2441 /* If we have completely cleared the softhangup flag,
2442 * then we need to fully abort the hangup process. This requires
2443 * pulling the END_OF_Q frame out of the channel frame queue if it
2444 * still happens to be there. */
2445
2446 fr = AST_LIST_LAST(ast_channel_readq(chan));
2447 if (fr && fr->frametype == AST_FRAME_CONTROL &&
2450 ast_frfree(fr);
2451 }
2452 }
2453
2454 ast_channel_unlock(chan);
2455}
2456
2457/*! \brief Softly hangup a channel, don't lock */
2458int ast_softhangup_nolock(struct ast_channel *chan, int cause)
2459{
2460 ast_debug(1, "Soft-Hanging (%#04x) up channel '%s'\n", (unsigned)cause, ast_channel_name(chan));
2461 /* Inform channel driver that we need to be hung up, if it cares */
2464 /* Interrupt any poll call or such */
2466 pthread_kill(ast_channel_blocker(chan), SIGURG);
2467 return 0;
2468}
2469
2470/*! \brief Softly hangup a channel, lock */
2471int ast_softhangup(struct ast_channel *chan, int cause)
2472{
2473 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
2474 int res;
2475
2476 ast_channel_lock(chan);
2477 res = ast_softhangup_nolock(chan, cause);
2478 blob = ast_json_pack("{s: i, s: b}",
2479 "cause", cause,
2480 "soft", 1);
2482 ast_channel_unlock(chan);
2483
2484 return res;
2485}
2486
2487static void free_translation(struct ast_channel *clonechan)
2488{
2489 if (ast_channel_writetrans(clonechan)) {
2491 }
2492 if (ast_channel_readtrans(clonechan)) {
2494 }
2495 ast_channel_writetrans_set(clonechan, NULL);
2496 ast_channel_readtrans_set(clonechan, NULL);
2497}
2498
2499void ast_set_hangupsource(struct ast_channel *chan, const char *source, int force)
2500{
2502
2503 ast_channel_lock(chan);
2504 if (force || ast_strlen_zero(ast_channel_hangupsource(chan))) {
2505 ast_channel_hangupsource_set(chan, source);
2506 }
2507 ast_channel_unlock(chan);
2508
2509 if (bridge) {
2510 ast_channel_lock(bridge);
2511 if (force || ast_strlen_zero(ast_channel_hangupsource(bridge))) {
2512 ast_channel_hangupsource_set(bridge, source);
2513 }
2514 ast_channel_unlock(bridge);
2515 }
2516}
2517
2519{
2522}
2523
2525{
2528}
2529
2530static void destroy_hooks(struct ast_channel *chan)
2531{
2532 if (ast_channel_audiohooks(chan)) {
2535 }
2536
2538}
2539
2540/*! \brief Hangup a channel */
2541void ast_hangup(struct ast_channel *chan)
2542{
2543 /* Be NULL safe for RAII_VAR() usage. */
2544 if (!chan) {
2545 return;
2546 }
2547
2548 ast_debug(1, "Channel %p '%s' hanging up. Refs: %d\n", chan, ast_channel_name(chan),
2549 ao2_ref(chan, 0));
2550
2552
2553 ast_channel_lock(chan);
2554
2555 while (ast_channel_masq(chan) || ast_channel_masqr(chan)) {
2557 }
2558
2559 /* Mark as a zombie so a masquerade cannot be setup on this channel. */
2561
2562 ast_channel_unlock(chan);
2563
2564 /*
2565 * XXX if running the hangup handlers here causes problems
2566 * because the handlers take too long to execute, we could move
2567 * the meat of this function into another thread. A thread
2568 * where channels go to die.
2569 *
2570 * If this is done, ast_autoservice_chan_hangup_peer() will no
2571 * longer be needed.
2572 */
2574 ao2_unlink(channels, chan);
2575 ast_channel_lock(chan);
2576
2577 destroy_hooks(chan);
2578
2579 free_translation(chan);
2580 /* Close audio stream */
2581 if (ast_channel_stream(chan)) {
2584 }
2585 /* Close video stream */
2586 if (ast_channel_vstream(chan)) {
2589 }
2590 if (ast_channel_sched(chan)) {
2593 }
2594
2595 if (ast_channel_generatordata(chan)) { /* Clear any tone stuff remaining */
2596 if (ast_channel_generator(chan) && ast_channel_generator(chan)->release) {
2598 }
2599 }
2602
2604 ast_log(LOG_WARNING, "Hard hangup called by thread LWP %d on %s, while blocked by thread LWP %d in procedure %s! Expect a failure\n",
2606 ast_channel_blockproc(chan));
2607 ast_assert(0);
2608 }
2609
2610 if (ast_channel_tech(chan)->hangup) {
2611 ast_channel_tech(chan)->hangup(chan);
2612 }
2613
2614 ast_channel_unlock(chan);
2615
2616 ast_cc_offer(chan);
2617
2618 ast_channel_unref(chan);
2619}
2620
2621/*!
2622 * \internal
2623 * \brief Set channel answered time if not already set.
2624 * \since 13.11.0
2625 *
2626 * \param chan Channel to set answered time.
2627 */
2628static void set_channel_answer_time(struct ast_channel *chan)
2629{
2631 struct timeval answertime;
2632
2633 answertime = ast_tvnow();
2634 ast_channel_answertime_set(chan, &answertime);
2635 }
2636}
2637
2638
2640{
2641 int res = 0;
2642 SCOPE_TRACE(1, "%s\n", ast_channel_name(chan));
2643
2644 ast_channel_lock(chan);
2645
2646 /* You can't answer an outbound call */
2648 ast_channel_unlock(chan);
2649 return 0;
2650 }
2651
2652 /* Stop if we're a zombie or need a soft hangup */
2654 ast_channel_unlock(chan);
2655 return -1;
2656 }
2657
2658 /*
2659 * Mark when incoming channel answered so we can know how
2660 * long the channel has been up.
2661 */
2663
2664 ast_channel_unlock(chan);
2665
2666 switch (ast_channel_state(chan)) {
2667 case AST_STATE_RINGING:
2668 case AST_STATE_RING:
2669 ast_channel_lock(chan);
2670 if (ast_channel_tech(chan)->answer_with_stream_topology) {
2671 res = ast_channel_tech(chan)->answer_with_stream_topology(chan, topology);
2672
2673 } else if (ast_channel_tech(chan)->answer) {
2674 res = ast_channel_tech(chan)->answer(chan);
2675 }
2677 ast_channel_unlock(chan);
2678 break;
2679 case AST_STATE_UP:
2680 break;
2681 default:
2682 break;
2683 }
2684
2685 ast_indicate(chan, -1);
2686
2687 return res;
2688}
2689
2691{
2693}
2694
2695int __ast_answer(struct ast_channel *chan, unsigned int delay)
2696{
2697 int res = 0;
2698 enum ast_channel_state old_state;
2699 SCOPE_TRACE(1, "%s\n", ast_channel_name(chan));
2700
2701 old_state = ast_channel_state(chan);
2702 if ((res = ast_raw_answer(chan))) {
2703 return res;
2704 }
2705
2706 switch (old_state) {
2707 case AST_STATE_RINGING:
2708 case AST_STATE_RING:
2709 /* wait for media to start flowing, but don't wait any longer
2710 * than 'delay' or 500 milliseconds, whichever is longer
2711 */
2712 do {
2714 struct ast_frame *cur;
2715 struct ast_frame *new_frame;
2716 int timeout_ms = MAX(delay, 500);
2717 unsigned int done = 0;
2718 struct timeval start;
2719
2721
2722 start = ast_tvnow();
2723 for (;;) {
2724 int ms = ast_remaining_ms(start, timeout_ms);
2725 ms = ast_waitfor(chan, ms);
2726 if (ms < 0) {
2727 ast_log(LOG_WARNING, "Error condition occurred when polling channel %s for a voice frame: %s\n", ast_channel_name(chan), strerror(errno));
2728 res = -1;
2729 break;
2730 }
2731 if (ms == 0) {
2732 ast_debug(2, "Didn't receive a media frame from %s within %u ms of answering. Continuing anyway\n", ast_channel_name(chan), MAX(delay, 500));
2733 break;
2734 }
2735 cur = ast_read(chan);
2736 if (!cur || ((cur->frametype == AST_FRAME_CONTROL) &&
2737 (cur->subclass.integer == AST_CONTROL_HANGUP))) {
2738 if (cur) {
2739 ast_frfree(cur);
2740 }
2741 res = -1;
2742 ast_debug(2, "Hangup of channel %s detected in answer routine\n", ast_channel_name(chan));
2743 break;
2744 }
2745
2746 if ((new_frame = ast_frisolate(cur)) != cur) {
2747 ast_frfree(cur);
2748 }
2749
2751
2752 /* if a specific delay period was requested, continue
2753 * until that delay has passed. don't stop just because
2754 * incoming media has arrived.
2755 */
2756 if (delay) {
2757 continue;
2758 }
2759
2760 switch (new_frame->frametype) {
2761 /* all of these frametypes qualify as 'media' */
2762 case AST_FRAME_VOICE:
2763 case AST_FRAME_VIDEO:
2764 case AST_FRAME_TEXT:
2767 case AST_FRAME_DTMF_END:
2768 case AST_FRAME_IMAGE:
2769 case AST_FRAME_HTML:
2770 case AST_FRAME_MODEM:
2771 case AST_FRAME_RTCP:
2772 done = 1;
2773 break;
2774 case AST_FRAME_CONTROL:
2775 case AST_FRAME_IAX:
2778 case AST_FRAME_NULL:
2779 case AST_FRAME_CNG:
2780 break;
2781 }
2782
2783 if (done) {
2784 break;
2785 }
2786 }
2787
2788 ast_channel_lock(chan);
2789 while ((cur = AST_LIST_REMOVE_HEAD(&frames, frame_list))) {
2790 if (res == 0) {
2791 ast_queue_frame_head(chan, cur);
2792 }
2793 ast_frfree(cur);
2794 }
2795 ast_channel_unlock(chan);
2796 } while (0);
2797 break;
2798 default:
2799 break;
2800 }
2801
2802 return res;
2803}
2804
2805int ast_answer(struct ast_channel *chan)
2806{
2807 SCOPE_TRACE(1, "%s\n", ast_channel_name(chan));
2808 return __ast_answer(chan, 0);
2809}
2810
2811inline int ast_auto_answer(struct ast_channel *chan)
2812{
2813 if (ast_channel_state(chan) == AST_STATE_UP) {
2814 /* Already answered */
2815 return 0;
2816 }
2817 return ast_answer(chan);
2818}
2819
2821{
2822 ast_assert(NULL != chan);
2823
2825 return 0;
2826 }
2828}
2829
2831{
2832 return (ast_channel_get_duration_ms(chan) / 1000);
2833}
2834
2836{
2837 ast_assert(NULL != chan);
2838
2840 return 0;
2841 }
2843}
2844
2846{
2847 return (ast_channel_get_up_time_ms(chan) / 1000);
2848}
2849
2850/*!
2851 * \brief Determine whether or not we have to trigger dtmf emulating using 50 fps timer events
2852 * especially when no voice frames are received during dtmf processing (direct media or muted
2853 * sender case using SIP INFO)
2854 */
2855static inline int should_trigger_dtmf_emulating(struct ast_channel *chan)
2856{
2858 /* We're in the middle of emulating a digit, or DTMF has been
2859 * explicitly deferred. Trigger dtmf with periodic 50 pfs timer events, then. */
2860 return 1;
2861 }
2862
2863 if (!ast_tvzero(*ast_channel_dtmf_tv(chan)) &&
2865 /*
2866 * We're not in the middle of a digit, but it hasn't been long enough
2867 * since the last digit, so we'll have to trigger DTMF further on.
2868 * Using 2 times AST_MIN_DTMF_GAP to trigger readq reading for possible
2869 * buffered next dtmf event
2870 */
2871 return 1;
2872 }
2873
2874 return 0;
2875}
2876
2878{
2879 if (ast_channel_generatordata(chan)) {
2880 struct ast_generator *generator = ast_channel_generator(chan);
2881
2882 if (generator && generator->release) {
2883 generator->release(chan, ast_channel_generatordata(chan));
2884 }
2889 ast_settimeout(chan, 0, NULL, NULL);
2890 }
2891}
2892
2894{
2895 ast_channel_lock(chan);
2898 /* if in the middle of dtmf emulation keep 50 tick per sec timer on rolling */
2900 }
2901 ast_channel_unlock(chan);
2902}
2903
2905{
2906 struct ast_generator *generator;
2907
2908 ast_channel_lock(chan);
2909 generator = ast_channel_generator(chan);
2910 if (generator && generator->write_format_change) {
2911 generator->write_format_change(chan, ast_channel_generatordata(chan));
2912 }
2913 ast_channel_unlock(chan);
2914}
2915
2916static int generator_force(const void *data)
2917{
2918 /* Called if generator doesn't have data */
2919 void *tmp;
2920 int res;
2921 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL;
2922 struct ast_channel *chan = (struct ast_channel *)data;
2923
2924 ast_channel_lock(chan);
2927 if (ast_channel_generator(chan))
2928 generate = ast_channel_generator(chan)->generate;
2929 ast_channel_unlock(chan);
2930
2931 if (!tmp || !generate) {
2932 return 0;
2933 }
2934
2935 res = generate(chan, tmp, 0, ast_format_get_sample_rate(ast_channel_writeformat(chan)) / 50);
2936
2937 ast_channel_lock(chan);
2938 if (ast_channel_generator(chan) && generate == ast_channel_generator(chan)->generate) {
2940 }
2941 ast_channel_unlock(chan);
2942
2943 if (res) {
2944 ast_debug(1, "Auto-deactivating generator\n");
2946 }
2947
2948 return 0;
2949}
2950
2951int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
2952{
2953 int res = 0;
2954 void *generatordata = NULL;
2955
2956 ast_channel_lock(chan);
2957 if (ast_channel_generatordata(chan)) {
2958 struct ast_generator *generator_old = ast_channel_generator(chan);
2959
2960 if (generator_old && generator_old->release) {
2961 generator_old->release(chan, ast_channel_generatordata(chan));
2962 }
2963 }
2964 if (gen->alloc && !(generatordata = gen->alloc(chan, params))) {
2965 res = -1;
2966 }
2967 ast_channel_generatordata_set(chan, generatordata);
2968 if (!res) {
2969 ast_settimeout(chan, 50, generator_force, chan);
2971 }
2972 ast_channel_unlock(chan);
2973
2974 ast_prod(chan);
2975
2976 return res;
2977}
2978
2979/*! \brief Wait for x amount of time on a file descriptor to have input. */
2980int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
2981{
2982 int winner = -1;
2983 ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
2984 return winner;
2985}
2986
2987/*! \brief Wait for x amount of time on a file descriptor to have input. */
2988struct ast_channel *ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds,
2989 int *exception, int *outfd, int *ms)
2990{
2991 struct timeval start = { 0 , 0 };
2992 struct pollfd *pfds = NULL;
2993 int res;
2994 long rms;
2995 int x, y, max;
2996 int sz = nfds;
2997 struct timeval now = { 0, 0 };
2998 struct timeval whentohangup = { 0, 0 }, diff;
2999 struct ast_channel *winner = NULL;
3000 struct fdmap {
3001 int chan;
3002 int fdno;
3003 } *fdmap = NULL;
3004
3005 if (outfd) {
3006 *outfd = -99999;
3007 }
3008 if (exception) {
3009 *exception = 0;
3010 }
3011
3012 for (x = 0; x < n; x++) {
3013 ast_channel_lock(c[x]);
3015 if (ast_tvzero(whentohangup))
3016 now = ast_tvnow();
3017 diff = ast_tvsub(*ast_channel_whentohangup(c[x]), now);
3018 if (diff.tv_sec < 0 || ast_tvzero(diff)) {
3019 ast_test_suite_event_notify("HANGUP_TIME", "Channel: %s", ast_channel_name(c[x]));
3020 /* Should already be hungup */
3023 return c[x];
3024 }
3025 if (ast_tvzero(whentohangup) || ast_tvcmp(diff, whentohangup) < 0)
3026 whentohangup = diff;
3027 }
3028 sz += ast_channel_fd_count(c[x]);
3030 }
3031
3032 if (!sz) {
3033 return NULL;
3034 }
3035
3036 pfds = ast_alloca(sizeof(*pfds) * sz);
3037 fdmap = ast_alloca(sizeof(*fdmap) * sz);
3038
3039 /* Wait full interval */
3040 rms = *ms;
3041 /* INT_MAX, not LONG_MAX, because it matters on 64-bit */
3042 if (!ast_tvzero(whentohangup) && whentohangup.tv_sec < INT_MAX / 1000) {
3043 rms = whentohangup.tv_sec * 1000 + whentohangup.tv_usec / 1000; /* timeout in milliseconds */
3044 if (*ms >= 0 && *ms < rms) { /* original *ms still smaller */
3045 rms = *ms;
3046 }
3047 } else if (!ast_tvzero(whentohangup) && rms < 0) {
3048 /* Tiny corner case... call would need to last >24 days */
3049 rms = INT_MAX;
3050 }
3051 /*
3052 * Build the pollfd array, putting the channels' fds first,
3053 * followed by individual fds. Order is important because
3054 * individual fd's must have priority over channel fds.
3055 */
3056 max = 0;
3057 for (x = 0; x < n; x++) {
3058 ast_channel_lock(c[x]);
3059 for (y = 0; y < ast_channel_fd_count(c[x]); y++) {
3060 fdmap[max].fdno = y; /* fd y is linked to this pfds */
3061 fdmap[max].chan = x; /* channel x is linked to this pfds */
3062 max += ast_add_fd(&pfds[max], ast_channel_fd(c[x], y));
3063 }
3064 CHECK_BLOCKING(c[x]);
3066 }
3067 /* Add the individual fds */
3068 for (x = 0; x < nfds; x++) {
3069 fdmap[max].chan = -1;
3070 max += ast_add_fd(&pfds[max], fds[x]);
3071 }
3072
3073 if (*ms > 0) {
3074 start = ast_tvnow();
3075 }
3076
3077 if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
3078 do {
3079 int kbrms = rms;
3080 if (kbrms > 600000) {
3081 kbrms = 600000;
3082 }
3083 res = ast_poll(pfds, max, kbrms);
3084 if (!res) {
3085 rms -= kbrms;
3086 }
3087 } while (!res && (rms > 0));
3088 } else {
3089 res = ast_poll(pfds, max, rms);
3090 }
3091 for (x = 0; x < n; x++) {
3092 ast_channel_lock(c[x]);
3095 }
3096 if (res < 0) { /* Simulate a timeout if we were interrupted */
3097 if (errno != EINTR) {
3098 *ms = -1;
3099 }
3100 return NULL;
3101 }
3102 if (!ast_tvzero(whentohangup)) { /* if we have a timeout, check who expired */
3103 now = ast_tvnow();
3104 for (x = 0; x < n; x++) {
3106 ast_test_suite_event_notify("HANGUP_TIME", "Channel: %s", ast_channel_name(c[x]));
3108 if (winner == NULL) {
3109 winner = c[x];
3110 }
3111 }
3112 }
3113 }
3114 if (res == 0) { /* no fd ready, reset timeout and done */
3115 *ms = 0; /* XXX use 0 since we may not have an exact timeout. */
3116 return winner;
3117 }
3118 /*
3119 * Then check if any channel or fd has a pending event.
3120 * Remember to check channels first and fds last, as they
3121 * must have priority on setting 'winner'
3122 */
3123 for (x = 0; x < max; x++) {
3124 res = pfds[x].revents;
3125 if (res == 0) {
3126 continue;
3127 }
3128 if (fdmap[x].chan >= 0) { /* this is a channel */
3129 winner = c[fdmap[x].chan]; /* override previous winners */
3130 ast_channel_lock(winner);
3131 if (res & POLLPRI) {
3133 } else {
3135 }
3136 ast_channel_fdno_set(winner, fdmap[x].fdno);
3137 ast_channel_unlock(winner);
3138 } else { /* this is an fd */
3139 if (outfd) {
3140 *outfd = pfds[x].fd;
3141 }
3142 if (exception) {
3143 *exception = (res & POLLPRI) ? -1 : 0;
3144 }
3145 winner = NULL;
3146 }
3147 }
3148 if (*ms > 0) {
3149 *ms -= ast_tvdiff_ms(ast_tvnow(), start);
3150 if (*ms < 0) {
3151 *ms = 0;
3152 }
3153 }
3154 return winner;
3155}
3156
3157struct ast_channel *ast_waitfor_n(struct ast_channel **c, int n, int *ms)
3158{
3159 return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
3160}
3161
3162int ast_waitfor(struct ast_channel *c, int ms)
3163{
3164 if (ms < 0) {
3165 do {
3166 ms = 100000;
3167 ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
3168 } while (!ms);
3169 } else {
3170 ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
3171 }
3172 return ms;
3173}
3174
3175int ast_waitfordigit(struct ast_channel *c, int ms)
3176{
3177 return ast_waitfordigit_full(c, ms, NULL, -1, -1);
3178}
3179
3180int ast_settimeout(struct ast_channel *c, unsigned int rate, int (*func)(const void *data), void *data)
3181{
3182 return ast_settimeout_full(c, rate, func, data, 0);
3183}
3184
3185int ast_settimeout_full(struct ast_channel *c, unsigned int rate, int (*func)(const void *data), void *data, unsigned int is_ao2_obj)
3186{
3187 int res;
3188 unsigned int real_rate = rate, max_rate;
3189
3191
3192 if (ast_channel_timingfd(c) == -1) {
3194 return -1;
3195 }
3196
3197 if (!func) {
3198 rate = 0;
3199 data = NULL;
3200 }
3201
3202 if (rate && rate > (max_rate = ast_timer_get_max_rate(ast_channel_timer(c)))) {
3203 real_rate = max_rate;
3204 }
3205
3206 ast_debug(3, "Scheduling timer at (%u requested / %u actual) timer ticks per second\n", rate, real_rate);
3207
3208 res = ast_timer_set_rate(ast_channel_timer(c), real_rate);
3209
3212 }
3213
3216
3217 if (data && is_ao2_obj) {
3218 ao2_ref(data, 1);
3220 } else {
3222 }
3223
3224 if (func == NULL && rate == 0 && ast_channel_fdno(c) == AST_TIMING_FD) {
3225 /* Clearing the timing func and setting the rate to 0
3226 * means that we don't want to be reading from the timingfd
3227 * any more. Setting c->fdno to -1 means we won't have any
3228 * errant reads from the timingfd, meaning we won't potentially
3229 * miss any important frames.
3230 */
3232 }
3233
3235
3236 return res;
3237}
3238
3239int ast_waitfordigit_full(struct ast_channel *c, int timeout_ms, const char *breakon, int audiofd, int cmdfd)
3240{
3241 struct timeval start = ast_tvnow();
3242 int ms;
3243
3244 /* Stop if we're a zombie or need a soft hangup */
3246 return -1;
3247
3248 /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
3250
3251 /* Wait for a digit, no more than timeout_ms milliseconds total.
3252 * Or, wait indefinitely if timeout_ms is <0.
3253 */
3254 while ((ms = ast_remaining_ms(start, timeout_ms))) {
3255 struct ast_channel *rchan;
3256 int outfd = -1;
3257
3258 errno = 0;
3259 /* While ast_waitfor_nandfds tries to help by reducing the timeout by how much was waited,
3260 * it is unhelpful if it waited less than a millisecond.
3261 */
3262 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
3263
3264 if (!rchan && outfd < 0 && ms) {
3265 if (errno == 0 || errno == EINTR)
3266 continue;
3267 ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
3269 return -1;
3270 } else if (outfd > -1) {
3271 /* The FD we were watching has something waiting */
3272 ast_log(LOG_WARNING, "The FD we were waiting for has something waiting. Waitfordigit returning numeric 1\n");
3274 return 1;
3275 } else if (rchan) {
3276 int res;
3277 struct ast_frame *f = ast_read(c);
3278
3279 if (!f) {
3281
3282 return -1;
3283 }
3284
3285 switch (f->frametype) {
3287 break;
3288 case AST_FRAME_DTMF_END:
3289 res = f->subclass.integer;
3290 if (!breakon || strchr(breakon, res)) {
3291 ast_frfree(f);
3293 return res;
3294 }
3295 break;
3296 case AST_FRAME_CONTROL:
3297 switch (f->subclass.integer) {
3298 case AST_CONTROL_HANGUP:
3299 ast_frfree(f);
3301 return -1;
3307 /* Fall-through and treat as if it were a DTMF signal. Items
3308 * that perform stream control will handle this. */
3309 res = f->subclass.integer;
3310 ast_frfree(f);
3312 return res;
3315 case AST_CONTROL_ANSWER:
3321 case AST_CONTROL_HOLD:
3322 case AST_CONTROL_UNHOLD:
3323 case AST_CONTROL_FLASH:
3324 case -1:
3325 /* Unimportant */
3326 break;
3327 default:
3328 ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass.integer);
3329 break;
3330 }
3331 break;
3332 case AST_FRAME_VOICE:
3333 /* Write audio if appropriate */
3334 if (audiofd > -1) {
3335 if (write(audiofd, f->data.ptr, f->datalen) < 0) {
3336 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
3337 }
3338 }
3339 default:
3340 /* Ignore */
3341 break;
3342 }
3343 ast_frfree(f);
3344 }
3345 }
3346
3348
3349 return 0; /* Time is up */
3350}
3351
3354 DTMF_SENT
3356
3358{
3359 switch (direction) {
3360 case DTMF_RECEIVED:
3361 return "Received";
3362 case DTMF_SENT:
3363 return "Sent";
3364 }
3365
3366 return "?";
3367}
3368
3369static void send_dtmf_begin_event(struct ast_channel *chan,
3370 enum DtmfDirection direction, const char digit)
3371{
3372 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
3373 char digit_str[] = { digit, '\0' };
3374
3375 blob = ast_json_pack("{ s: s, s: s }",
3376 "digit", digit_str,
3377 "direction", dtmf_direction_to_string(direction));
3378 if (!blob) {
3379 return;
3380 }
3381
3383}
3384
3385static void send_dtmf_end_event(struct ast_channel *chan,
3386 enum DtmfDirection direction, const char digit, long duration_ms)
3387{
3388 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
3389 char digit_str[] = { digit, '\0' };
3390
3391 blob = ast_json_pack("{ s: s, s: s, s: I }",
3392 "digit", digit_str,
3393 "direction", dtmf_direction_to_string(direction),
3394 "duration_ms", (ast_json_int_t)duration_ms);
3395 if (!blob) {
3396 return;
3397 }
3398
3400}
3401
3402static void send_flash_event(struct ast_channel *chan)
3403{
3405}
3406
3407static void send_wink_event(struct ast_channel *chan)
3408{
3410}
3411
3412static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
3413{
3414 struct ast_generator *generator;
3415 void *gendata;
3416 int res;
3417 int samples;
3418
3419 generator = ast_channel_generator(chan);
3420 if (!generator
3421 || !generator->generate
3422 || f->frametype != AST_FRAME_VOICE
3424 || ast_channel_timingfunc(chan)) {
3425 return;
3426 }
3427
3428 /*
3429 * We must generate frames in phase locked mode since
3430 * we have no internal timer available.
3431 */
3433 float factor;
3435 samples = (int) (((float) f->samples) * factor);
3436 } else {
3437 samples = f->samples;
3438 }
3439
3440 gendata = ast_channel_generatordata(chan);
3441 ast_channel_generatordata_set(chan, NULL); /* reset, to let writes go through */
3442
3443 /*
3444 * This unlock is here based on two assumptions that hold true at
3445 * this point in the code. 1) this function is only called from
3446 * within __ast_read() and 2) all generators call ast_write() in
3447 * their generate callback.
3448 *
3449 * The reason this is added is so that when ast_write is called,
3450 * the lock that occurs there will not recursively lock the
3451 * channel. Doing this will allow deadlock avoidance to work in
3452 * deeper functions.
3453 */
3454 ast_channel_unlock(chan);
3455 res = generator->generate(chan, gendata, f->datalen, samples);
3456 ast_channel_lock(chan);
3457 if (generator == ast_channel_generator(chan)) {
3458 ast_channel_generatordata_set(chan, gendata);
3459 if (res) {
3460 ast_debug(1, "Auto-deactivating generator\n");
3462 }
3463 }
3464}
3465
3466static inline void queue_dtmf_readq(struct ast_channel *chan, struct ast_frame *f)
3467{
3468 struct ast_frame *fr = ast_channel_dtmff(chan);
3469
3472 fr->len = f->len;
3473
3474 /* The only time this function will be called is for a frame that just came
3475 * out of the channel driver. So, we want to stick it on the tail of the
3476 * readq. */
3477
3478 ast_queue_frame(chan, fr);
3479}
3480
3481/*!
3482 * \brief Determine whether or not we should ignore DTMF in the readq
3483 */
3484static inline int should_skip_dtmf(struct ast_channel *chan)
3485{
3487 /* We're in the middle of emulating a digit, or DTMF has been
3488 * explicitly deferred. Skip this digit, then. */
3489 return 1;
3490 }
3491
3492 if (!ast_tvzero(*ast_channel_dtmf_tv(chan)) &&
3494 /* We're not in the middle of a digit, but it hasn't been long enough
3495 * since the last digit, so we'll have to skip DTMF for now. */
3496 return 1;
3497 }
3498
3499 return 0;
3500}
3501
3502/*!
3503 * \brief calculates the number of samples to jump forward with in a monitor stream.
3504
3505 * \note When using ast_seekstream() with the read and write streams of a monitor,
3506 * the number of samples to seek forward must be of the same sample rate as the stream
3507 * or else the jump will not be calculated correctly.
3508 *
3509 * \retval number of samples to seek forward after rate conversion.
3510 */
3511static inline int calc_monitor_jump(int samples, int sample_rate, int seek_rate)
3512{
3513 int diff = sample_rate - seek_rate;
3514
3515 if (diff > 0) {
3516 samples = samples / (float) (sample_rate / seek_rate);
3517 } else if (diff < 0) {
3518 samples = samples * (float) (seek_rate / sample_rate);
3519 }
3520
3521 return samples;
3522}
3523
3524static struct ast_frame *__ast_read(struct ast_channel *chan, int dropaudio, int dropnondefault)
3525{
3526 struct ast_frame *f = NULL; /* the return value */
3527 int prestate;
3528 int cause = 0;
3529 struct ast_stream *stream = NULL, *default_stream = NULL;
3530
3531 /* this function is very long so make sure there is only one return
3532 * point at the end (there are only two exceptions to this).
3533 */
3534 ast_channel_lock(chan);
3535
3536 /* Stop if we're a zombie or need a soft hangup */
3538 if (ast_channel_generator(chan))
3540
3541 /*
3542 * It is possible for chan->_softhangup to be set and there
3543 * still be control frames that need to be read. Instead of
3544 * just going to 'done' in the case of ast_check_hangup(), we
3545 * need to queue the end-of-Q frame so that it can mark the end
3546 * of the read queue. If there are frames to be read,
3547 * ast_queue_control() will be called repeatedly, but will only
3548 * queue the first end-of-Q frame.
3549 */
3552 } else {
3553 goto done;
3554 }
3555 } else {
3556#ifdef AST_DEVMODE
3557 /*
3558 * The ast_waitfor() code records which of the channel's file
3559 * descriptors reported that data is available. In theory,
3560 * ast_read() should only be called after ast_waitfor() reports
3561 * that a channel has data available for reading. However,
3562 * there still may be some edge cases throughout the code where
3563 * ast_read() is called improperly. This can potentially cause
3564 * problems, so if this is a developer build, make a lot of
3565 * noise if this happens so that it can be addressed.
3566 *
3567 * One of the potential problems is blocking on a dead channel.
3568 */
3569 if (ast_channel_fdno(chan) == -1) {
3571 "ast_read() on chan '%s' called with no recorded file descriptor.\n",
3572 ast_channel_name(chan));
3573 }
3574#endif
3575 }
3576
3577 prestate = ast_channel_state(chan);
3578
3579 if (ast_channel_timingfd(chan) > -1 && ast_channel_fdno(chan) == AST_TIMING_FD) {
3580 enum ast_timer_event res;
3581 int trigger_dtmf_emulating = should_trigger_dtmf_emulating(chan);
3582
3584
3586
3587 switch (res) {
3589 if (ast_timer_ack(ast_channel_timer(chan), 1) < 0) {
3590 ast_log(LOG_ERROR, "Failed to acknowledge timer in ast_read\n");
3591 goto done;
3592 }
3593
3594 if (ast_channel_timingfunc(chan)) {
3595 /* save a copy of func/data before unlocking the channel */
3597 void *data = ast_channel_timingdata(chan);
3598 int got_ref = 0;
3600 ao2_ref(data, 1);
3601 got_ref = 1;
3602 }
3603 ast_channel_fdno_set(chan, -1);
3604 ast_channel_unlock(chan);
3605 func(data);
3606 if (got_ref) {
3607 ao2_ref(data, -1);
3608 }
3609
3610 if (trigger_dtmf_emulating) {
3611 /*
3612 * Since we're breaking out of this switch block and not
3613 * returning, we need to re-lock the channel.
3614 */
3615 ast_channel_lock(chan);
3616 /* generate null frame to trigger dtmf emulating */
3617 f = &ast_null_frame;
3618 break;
3619 }
3620 } else if (trigger_dtmf_emulating) {
3621 /* generate null frame to trigger dtmf emulating */
3622 f = &ast_null_frame;
3623 break;
3624 } else {
3626 /* generate very last null frame to trigger dtmf emulating */
3627 f = &ast_null_frame;
3628 break;
3629 }
3630
3631 /* cannot 'goto done' because the channel is already unlocked */
3632 return &ast_null_frame;
3633
3635 if (AST_LIST_EMPTY(ast_channel_readq(chan)) ||
3638 }
3639 break;
3640 }
3641
3643 /* if the AST_GENERATOR_FD is set, call the generator with args
3644 * set to -1 so it can do whatever it needs to.
3645 */
3646 void *tmp = ast_channel_generatordata(chan);
3647 ast_channel_generatordata_set(chan, NULL); /* reset to let ast_write get through */
3648 ast_channel_generator(chan)->generate(chan, tmp, -1, -1);
3650 f = &ast_null_frame;
3651 ast_channel_fdno_set(chan, -1);
3652 goto done;
3655 }
3656
3657 /* Read and ignore anything on the alertpipe, but read only
3658 one sizeof(blah) per frame that we send from it */
3660 f = &ast_null_frame;
3661 goto done;
3662 }
3663
3664 /* Check for pending read queue */
3665 if (!AST_LIST_EMPTY(ast_channel_readq(chan))) {
3666 int skipped_dtmf_frame = 0;
3667 int skip_dtmf = should_skip_dtmf(chan);
3668
3670 /* We have to be picky about which frame we pull off of the readq because
3671 * there are cases where we want to leave DTMF frames on the queue until
3672 * some later time. */
3673
3674 if ( (f->frametype == AST_FRAME_DTMF_BEGIN || f->frametype == AST_FRAME_DTMF_END) && skip_dtmf) {
3675 skipped_dtmf_frame = 1;
3676 continue;
3677 }
3678
3680 break;
3681 }
3683
3684 if (!f) {
3685 /* There were no acceptable frames on the readq. */
3686 f = &ast_null_frame;
3687 if (!skipped_dtmf_frame) {
3688 /*
3689 * Do not trigger alert pipe if only buffered dtmf begin or end frames
3690 * are left in the readq.
3691 */
3693 } else {
3694 /*
3695 * Safely disable continous timer events if only buffered dtmf begin or end
3696 * frames are left in the readq.
3697 */
3699 }
3700 }
3701
3702 /* Interpret hangup and end-of-Q frames to return NULL */
3703 /* XXX why not the same for frames from the channel ? */
3704 if (f->frametype == AST_FRAME_CONTROL) {
3705 switch (f->subclass.integer) {
3706 case AST_CONTROL_HANGUP:
3708 cause = f->data.uint32;
3709 /* Fall through */
3711 ast_frfree(f);
3712 f = NULL;
3713 break;
3714 default:
3715 break;
3716 }
3717 } else if (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO) {
3718 if (ast_channel_tech(chan) && ast_channel_tech(chan)->read_stream) {
3721 } else {
3722 /* Since this channel driver does not support multistream determine the default stream this frame
3723 * originated from and update the frame to include it.
3724 */
3725 stream = default_stream = ast_channel_get_default_stream(chan, ast_format_get_type(f->subclass.format));
3726 /* In order to allow media to be passed up the underlying media type has to have a format negotiated on
3727 * the channel itself. In cases where this hasn't happened the channel driver is incorrectly passing up
3728 * a frame for a format that has not been negotiated. If this occurs just drop the frame as we have no
3729 * stream that it came from.
3730 */
3731 if (!stream) {
3732 ast_frfree(f);
3733 f = &ast_null_frame;
3734 } else {
3736 }
3737 }
3738 }
3739 } else {
3741 if (ast_channel_tech(chan)->exception)
3742 f = ast_channel_tech(chan)->exception(chan);
3743 else {
3744 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", ast_channel_name(chan));
3745 f = &ast_null_frame;
3746 }
3747 /* Clear the exception flag */
3749 } else if (ast_channel_tech(chan) && ast_channel_tech(chan)->read_stream) {
3750 f = ast_channel_tech(chan)->read_stream(chan);
3751
3752 /* This channel driver supports multistream so the stream_num on the frame is valid, the only
3753 * thing different is that we need to find the default stream so we know whether to invoke the
3754 * default stream logic or not (such as transcoding).
3755 */
3756 if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO)) {
3759 }
3760 } else if (ast_channel_tech(chan) && ast_channel_tech(chan)->read) {
3761 f = ast_channel_tech(chan)->read(chan);
3762
3763 /* Since this channel driver does not support multistream determine the default stream this frame
3764 * originated from and update the frame to include it.
3765 */
3766 if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO)) {
3767 stream = default_stream = ast_channel_get_default_stream(chan, ast_format_get_type(f->subclass.format));
3768 if (!stream) {
3769 ast_frfree(f);
3770 f = &ast_null_frame;
3771 } else {
3773 }
3774 }
3775 }
3776 else
3777 ast_log(LOG_WARNING, "No read routine on channel %s\n", ast_channel_name(chan));
3778 }
3779
3780 if (stream == default_stream) {
3781 /* Perform the framehook read event here. After the frame enters the framehook list
3782 * there is no telling what will happen, <insert mad scientist laugh here>!!! */
3784 }
3785
3786 /*
3787 * Reset the recorded file descriptor that triggered this read so that we can
3788 * easily detect when ast_read() is called without properly using ast_waitfor().
3789 */
3790 ast_channel_fdno_set(chan, -1);
3791
3792 if (f) {
3793 struct ast_frame *readq_tail = AST_LIST_LAST(ast_channel_readq(chan));
3794 struct ast_control_read_action_payload *read_action_payload;
3796 int hooked = 0;
3797
3798 /* if the channel driver returned more than one frame, stuff the excess
3799 into the readq for the next ast_read call
3800 */
3801 if (AST_LIST_NEXT(f, frame_list)) {
3805 }
3806
3807 if (dropnondefault && stream != default_stream) {
3808 /* If the frame originates from a non-default stream and the caller can not handle other streams
3809 * absorb the frame and replace it with a null one instead.
3810 */
3811 ast_frfree(f);
3812 f = &ast_null_frame;
3813 }
3814
3815 switch (f->frametype) {
3816 case AST_FRAME_CONTROL:
3818 if (prestate == AST_STATE_UP && ast_channel_is_bridged(chan)) {
3819 ast_debug(1, "Dropping duplicate answer!\n");
3820 ast_frfree(f);
3821 f = &ast_null_frame;
3822 } else {
3823 /*
3824 * Mark when outgoing channel answered so we can know how
3825 * long the channel has been up.
3826 */
3828
3830 }
3831 } else if (f->subclass.integer == AST_CONTROL_READ_ACTION) {
3832 read_action_payload = f->data.ptr;
3833 switch (read_action_payload->action) {
3837 if (ast_connected_line_parse_data(read_action_payload->payload,
3838 read_action_payload->payload_size, &connected)) {
3840 break;
3841 }
3842 ast_channel_unlock(chan);
3845 read_action_payload->payload,
3846 read_action_payload->payload_size);
3847 }
3849 ast_channel_lock(chan);
3850 break;
3852 ast_channel_unlock(chan);
3853 ast_sendtext(chan, (const char *)read_action_payload->payload);
3854 ast_channel_lock(chan);
3855 break;
3857 ast_channel_unlock(chan);
3858 ast_sendtext_data(chan, (struct ast_msg_data *)read_action_payload->payload);
3859 ast_channel_lock(chan);
3860 break;
3861 }
3862 ast_frfree(f);
3863 f = &ast_null_frame;
3864 } else if (f->subclass.integer == AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE && dropnondefault) {
3865 /* The caller of this function is incapable of handling streams so we don't accept the change request
3866 * and stick to the streams currently on the channel.
3867 */
3869 ast_frfree(f);
3870 f = &ast_null_frame;
3871 } else if (f->subclass.integer == AST_CONTROL_STREAM_TOPOLOGY_CHANGED && dropnondefault) {
3872 /* The caller of this function is incapable of handling streams so we absorb the notification that the
3873 * stream topology has changed.
3874 */
3875 ast_frfree(f);
3876 f = &ast_null_frame;
3877 } else if (f->subclass.integer == AST_CONTROL_FLASH) {
3878 send_flash_event(chan);
3879 } else if (f->subclass.integer == AST_CONTROL_WINK) {
3880 send_wink_event(chan);
3881 }
3882 break;
3883 case AST_FRAME_DTMF_END:
3885 ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass.integer, ast_channel_name(chan), f->len);
3886 /* Queue it up if DTMF is deferred, or if DTMF emulation is forced. */
3888 queue_dtmf_readq(chan, f);
3889 ast_frfree(f);
3890 f = &ast_null_frame;
3892 if (!ast_tvzero(*ast_channel_dtmf_tv(chan)) &&
3894 /* If it hasn't been long enough, defer this digit */
3895 queue_dtmf_readq(chan, f);
3896 ast_frfree(f);
3897 f = &ast_null_frame;
3898 } else {
3899 /* There was no begin, turn this into a begin and send the end later */
3900 struct timeval tv = ast_tvnow();
3904 ast_channel_dtmf_tv_set(chan, &tv);
3905 if (f->len) {
3906 if (f->len > option_dtmfminduration)
3908 else
3910 } else
3912 ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass.integer, ast_channel_emulate_dtmf_duration(chan), ast_channel_name(chan));
3913
3914 /*
3915 * Start generating 50 fps timer events (null frames) for dtmf emulating
3916 * independently from any existing incoming voice frames.
3917 * If channel generator is already activated in regular mode use these
3918 * timer events to generate null frames.
3919 */
3920 if (!ast_channel_generator(chan)) {
3922 }
3923 }
3924 if (ast_channel_audiohooks(chan)) {
3925 struct ast_frame *old_frame = f;
3926 /*!
3927 * \todo XXX It is possible to write a digit to the audiohook twice
3928 * if the digit was originally read while the channel was in autoservice. */
3930 if (old_frame != f)
3931 ast_frfree(old_frame);
3932 }
3933 } else {
3934 struct timeval now = ast_tvnow();
3936 ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass.integer, ast_channel_name(chan));
3938 if (!f->len)
3939 f->len = ast_tvdiff_ms(now, *ast_channel_dtmf_tv(chan));
3940
3941 /* detect tones that were received on
3942 * the wire with durations shorter than
3943 * option_dtmfminduration and set f->len
3944 * to the actual duration of the DTMF
3945 * frames on the wire. This will cause
3946 * dtmf emulation to be triggered later
3947 * on.
3948 */
3950 f->len = ast_tvdiff_ms(now, *ast_channel_dtmf_tv(chan));
3951 ast_log(LOG_DTMF, "DTMF end '%c' detected to have actual duration %ld on the wire, emulation will be triggered on %s\n", f->subclass.integer, f->len, ast_channel_name(chan));
3952 }
3953 } else if (!f->len) {
3954 ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass.integer, ast_channel_name(chan));
3956 }
3958 ast_log(LOG_DTMF, "DTMF end '%c' has duration %ld but want minimum %u, emulating on %s\n", f->subclass.integer, f->len, option_dtmfminduration, ast_channel_name(chan));
3962 ast_frfree(f);
3963 f = &ast_null_frame;
3964
3965 /* Start generating 50 fps timer events (null frames) for dtmf emulating
3966 * independently from any existing incoming voice frames.
3967 * If channel generator is already activated in regular mode use these
3968 * timer events to generate null frames.
3969 */
3970 if (!ast_channel_generator(chan)) {
3972 }
3973 } else {
3974 ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass.integer, ast_channel_name(chan));
3975 if (f->len < option_dtmfminduration) {
3977 }
3978 ast_channel_dtmf_tv_set(chan, &now);
3979
3980 /* Start generating 50 fps timer events (null frames) for dtmf emulating
3981 * independently from any existing incoming voice frames.
3982 * If channel generator is already activated in regular mode use these
3983 * timer events to generate null frames.
3984 */
3985 if (!ast_channel_generator(chan)) {
3987 }
3988 }
3989 if (ast_channel_audiohooks(chan)) {
3990 struct ast_frame *old_frame = f;
3992 if (old_frame != f)
3993 ast_frfree(old_frame);
3994 }
3995 }
3996 break;
3999 ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass.integer, ast_channel_name(chan));
4001 (!ast_tvzero(*ast_channel_dtmf_tv(chan)) &&
4003 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass.integer, ast_channel_name(chan));
4004 ast_frfree(f);
4005 f = &ast_null_frame;
4006 } else {
4007 struct timeval now = ast_tvnow();
4009 ast_channel_dtmf_tv_set(chan, &now);
4010 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass.integer, ast_channel_name(chan));
4011 }
4012 break;
4013 case AST_FRAME_NULL:
4014 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
4015 * is reached , because we want to make sure we pass at least one
4016 * voice frame through before starting the next digit, to ensure a gap
4017 * between DTMF digits. */
4019 struct timeval now = ast_tvnow();
4023 } else if (ast_tvdiff_ms(now, *ast_channel_dtmf_tv(chan)) >= ast_channel_emulate_dtmf_duration(chan)) {
4025 ast_frfree(f);
4026 f = ast_channel_dtmff(chan);
4029 f->len = ast_tvdiff_ms(now, *ast_channel_dtmf_tv(chan));
4030 ast_channel_dtmf_tv_set(chan, &now);
4033 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass.integer, ast_channel_name(chan));
4034 if (ast_channel_audiohooks(chan)) {
4035 struct ast_frame *old_frame = f;
4037 if (old_frame != f) {
4038 ast_frfree(old_frame);
4039 }
4040 }
4041
4042 /* Start generating 50 fps timer events (null frames) for dtmf emulating
4043 * independently from any existing incoming voice frames.
4044 * If channel generator is already activated in regular mode use these
4045 * timer events to generate null frames.
4046 */
4047 if (!ast_channel_generator(chan)) {
4049 }
4050 }
4051 }
4052 break;
4053 case AST_FRAME_VOICE:
4054 /* If media was received from a non-default stream don't perform any actions, let it just go through */
4055 if (stream != default_stream) {
4056 break;
4057 }
4058
4059 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration
4060 * is reached , because we want to make sure we pass at least one
4061 * voice frame through before starting the next digit, to ensure a gap
4062 * between DTMF digits. */
4066 }
4067
4068 if (dropaudio || ast_test_flag(ast_channel_flags(chan), AST_FLAG_IN_DTMF)) {
4069 if (dropaudio)
4071 ast_frfree(f);
4072 f = &ast_null_frame;
4073 }
4074
4076 struct timeval now = ast_tvnow();
4079 ast_frfree(f);
4080 f = ast_channel_dtmff(chan);
4083 f->len = ast_tvdiff_ms(now, *ast_channel_dtmf_tv(chan));
4084 ast_channel_dtmf_tv_set(chan, &now);
4085 if (ast_channel_audiohooks(chan)) {
4086 struct ast_frame *old_frame = f;
4088 if (old_frame != f)
4089 ast_frfree(old_frame);
4090 }
4091 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass.integer, ast_channel_name(chan));
4092 } else {
4093 /* Drop voice frames while we're still in the middle of the digit */
4094 ast_frfree(f);
4095 f = &ast_null_frame;
4096 }
4097 break;
4098 }
4099 if (f->frametype != AST_FRAME_VOICE) {
4100 break;
4101 }
4104 struct ast_format *core_format;
4105
4106 /*
4107 * Note: This frame may not be one of the current native
4108 * formats. We may have gotten it out of the read queue from
4109 * a previous multi-frame translation, from a framehook
4110 * injected frame, or the device we're talking to isn't
4111 * respecting negotiated formats. Regardless we will accept
4112 * all frames.
4113 *
4114 * Update the read translation path to handle the new format
4115 * that just came in. If the core wants slinear we need to
4116 * setup a new translation path because the core is usually
4117 * doing something with the audio itself and may not handle
4118 * any other format. e.g., Softmix bridge, holding bridge
4119 * announcer channel, recording, AMD... Otherwise, we'll
4120 * setup to pass the frame as is to the core. In this case
4121 * the core doesn't care. The channel is likely in
4122 * autoservice, safesleep, or the channel is in a bridge.
4123 * Let the bridge technology deal with format compatibility
4124 * between the channels in the bridge.
4125 *
4126 * Beware of the transcode_via_slin and genericplc options as
4127 * they force any transcoding to go through slin on a bridge.
4128 * Unfortunately transcode_via_slin is enabled by default and
4129 * genericplc is enabled in the codecs.conf.sample file.
4130 *
4131 * XXX Only updating translation to slinear frames has some
4132 * corner cases if slinear is one of the native formats and
4133 * there are different sample rates involved. We might wind
4134 * up with conflicting translation paths between channels
4135 * where the read translation path on this channel reduces
4136 * the sample rate followed by a write translation path on
4137 * the peer channel that increases the sample rate.
4138 */
4139 core_format = ast_channel_readformat(chan);
4140 if (!ast_format_cache_is_slinear(core_format)) {
4141 core_format = f->subclass.format;
4142 }
4143 if (ast_set_read_format_path(chan, f->subclass.format, core_format)) {
4144 /* Drop frame. We couldn't make it compatible with the core. */
4145 ast_frfree(f);
4146 f = &ast_null_frame;
4147 break;
4148 }
4149 }
4150 /*
4151 * Send frame to audiohooks if present, if frametype is linear, to preserve
4152 * functional compatibility with previous behavior. If not linear, hold off
4153 * until transcoding is done where we are more likely to have a linear frame
4154 */
4156 /* Place hooked after declaration */
4157 struct ast_frame *old_frame = f;
4158 hooked = 1;
4159
4161 if (old_frame != f) {
4162 ast_frfree(old_frame);
4163 }
4164 }
4165
4166 if (ast_channel_readtrans(chan)
4168 f = ast_translate(ast_channel_readtrans(chan), f, 1);
4169 if (!f) {
4170 f = &ast_null_frame;
4171 }
4172 }
4173
4174 /* Second chance at hooking a linear frame, also the last chance */
4175 if (ast_channel_audiohooks(chan) && !hooked) {
4176 struct ast_frame *old_frame = f;
4177
4179 if (old_frame != f) {
4180 ast_frfree(old_frame);
4181 }
4182 }
4183
4184 /*
4185 * It is possible for the translation process on the channel to have
4186 * produced multiple frames from the single input frame we passed it; if
4187 * this happens, queue the additional frames *before* the frames we may
4188 * have queued earlier. if the readq was empty, put them at the head of
4189 * the queue, and if it was not, put them just after the frame that was
4190 * at the end of the queue.
4191 */
4192 if (AST_LIST_NEXT(f, frame_list)) {
4193 struct ast_frame *cur, *multi_frame = AST_LIST_NEXT(f, frame_list);
4194
4195 /* Mark these frames as being re-queued */
4196 for (cur = multi_frame; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
4198 }
4199
4200 if (!readq_tail) {
4201 ast_queue_frame_head(chan, multi_frame);
4202 } else {
4203 __ast_queue_frame(chan, multi_frame, 0, readq_tail);
4204 }
4205 ast_frfree(multi_frame);
4207 }
4208
4209 /*
4210 * Run generator sitting on the line if timing device not available
4211 * and synchronous generation of outgoing frames is necessary
4212 */
4214 break;
4215 case AST_FRAME_RTCP:
4216 /* Incoming RTCP feedback needs to get to the translator for
4217 * outgoing media, which means we treat it as an ast_write */
4218 if (ast_channel_writetrans(chan)) {
4220 }
4221 break;
4222 default:
4223 /* Just pass it on! */
4224 break;
4225 }
4226 } else {
4227 /* Make sure we always return NULL in the future */
4230 }
4231 if (cause)
4232 ast_channel_hangupcause_set(chan, cause);
4233 if (ast_channel_generator(chan))
4235 /* We no longer End the CDR here */
4236 }
4237
4238 /* High bit prints debugging */
4239 if (ast_channel_fin(chan) & DEBUGCHAN_FLAG)
4240 ast_frame_dump(ast_channel_name(chan), f, "<<");
4242
4243done:
4246
4248 /* The list gets recreated if audiohooks are added again later */
4251 }
4252 ast_channel_unlock(chan);
4253 return f;
4254}
4255
4256struct ast_frame *ast_read(struct ast_channel *chan)
4257{
4258 return __ast_read(chan, 0, 1);
4259}
4260
4262{
4263 return __ast_read(chan, 0, 0);
4264}
4265
4267{
4268 return __ast_read(chan, 1, 1);
4269}
4270
4272{
4273 return __ast_read(chan, 1, 0);
4274}
4275
4276int ast_indicate(struct ast_channel *chan, int condition)
4277{
4278 return ast_indicate_data(chan, condition, NULL, 0);
4279}
4280
4282{
4283 /* Don't include a default case here so that we get compiler warnings
4284 * when a new type is added. */
4285
4286 switch (condition) {
4294 case AST_CONTROL_OPTION:
4295 case AST_CONTROL_WINK:
4296 case AST_CONTROL_FLASH:
4299 case AST_CONTROL_ANSWER:
4300 case AST_CONTROL_HANGUP:
4306 case AST_CONTROL_CC:
4308 case AST_CONTROL_AOC:
4310 case AST_CONTROL_MCID:
4326 break;
4327
4330 case AST_CONTROL_BUSY:
4332 case AST_CONTROL_RING:
4333 case AST_CONTROL_HOLD:
4334 /* You can hear these */
4335 return 1;
4336
4337 case AST_CONTROL_UNHOLD:
4338 /* This is a special case. You stop hearing this. */
4339 break;
4340 }
4341
4342 return 0;
4343}
4344
4346{
4347 char causevar[256];
4348
4349 if (ast_channel_dialed_causes_add(chan, cause_code, datalen)) {
4350 ast_log(LOG_WARNING, "Unable to store hangup cause for %s on %s\n", cause_code->chan_name, ast_channel_name(chan));
4351 }
4352
4353 if (cause_code->emulate_sip_cause) {
4354 snprintf(causevar, sizeof(causevar), "HASH(SIP_CAUSE,%s)", cause_code->chan_name);
4355 ast_func_write(chan, causevar, cause_code->code);
4356 }
4357}
4358
4360{
4361 if (!strcasecmp(flag, "default"))
4362 return DEFAULT_AMA_FLAGS;
4363 if (!strcasecmp(flag, "omit"))
4364 return AST_AMA_OMIT;
4365 if (!strcasecmp(flag, "billing"))
4366 return AST_AMA_BILLING;
4367 if (!strcasecmp(flag, "documentation"))
4368 return AST_AMA_DOCUMENTATION;
4369 return AST_AMA_NONE;
4370}
4371
4373{
4374 switch (flag) {
4375 case AST_AMA_OMIT:
4376 return "OMIT";
4377 case AST_AMA_BILLING:
4378 return "BILLING";
4380 return "DOCUMENTATION";
4381 default:
4382 return "Unknown";
4383 }
4384}
4385
4386/*!
4387 * \internal
4388 * \brief Preprocess connected line update.
4389 * \since 12.0.0
4390 *
4391 * \param chan channel to change the indication
4392 * \param data pointer to payload data
4393 * \param datalen size of payload data
4394 *
4395 * \note This function assumes chan is locked.
4396 *
4397 * \retval 0 keep going.
4398 * \retval -1 quit now.
4399 */
4400static int indicate_connected_line(struct ast_channel *chan, const void *data, size_t datalen)
4401{
4402 struct ast_party_connected_line *chan_connected = ast_channel_connected(chan);
4403 struct ast_party_connected_line *chan_indicated = ast_channel_connected_indicated(chan);
4405 unsigned char current[1024];
4406 unsigned char proposed[1024];
4407 int current_size;
4408 int proposed_size;
4409 int res;
4410
4412 res = ast_connected_line_parse_data(data, datalen, &connected);
4413 if (!res) {
4415 }
4417 if (res) {
4418 return -1;
4419 }
4420
4421 current_size = ast_connected_line_build_data(current, sizeof(current),
4422 chan_indicated, NULL);
4423 proposed_size = ast_connected_line_build_data(proposed, sizeof(proposed),
4424 chan_connected, NULL);
4425 if (current_size == -1 || proposed_size == -1) {
4426 return -1;
4427 }
4428
4429 if (current_size == proposed_size && !memcmp(current, proposed, current_size)) {
4430 ast_debug(1, "%s: Dropping redundant connected line update \"%s\" <%s>.\n",
4431 ast_channel_name(chan),
4432 S_COR(chan_connected->id.name.valid, chan_connected->id.name.str, ""),
4433 S_COR(chan_connected->id.number.valid, chan_connected->id.number.str, ""));
4434 return -1;
4435 }
4436
4437 ast_party_connected_line_copy(chan_indicated, chan_connected);
4438 return 0;
4439}
4440
4441/*!
4442 * \internal
4443 * \brief Preprocess redirecting update.
4444 * \since 12.0.0
4445 *
4446 * \param chan channel to change the indication
4447 * \param data pointer to payload data
4448 * \param datalen size of payload data
4449 *
4450 * \note This function assumes chan is locked.
4451 *
4452 * \retval 0 keep going.
4453 * \retval -1 quit now.
4454 */
4455static int indicate_redirecting(struct ast_channel *chan, const void *data, size_t datalen)
4456{
4457 struct ast_party_redirecting redirecting;
4458 int res;
4459
4461 res = ast_redirecting_parse_data(data, datalen, &redirecting);
4462 if (!res) {
4463 ast_channel_set_redirecting(chan, &redirecting, NULL);
4464 }
4465 ast_party_redirecting_free(&redirecting);
4466 return res ? -1 : 0;
4467}
4468
4469static int indicate_data_internal(struct ast_channel *chan, int _condition, const void *data, size_t datalen)
4470{
4471 /* By using an enum, we'll get compiler warnings for values not handled
4472 * in switch statements. */
4473 enum ast_control_frame_type condition = _condition;
4474 struct ast_tone_zone_sound *ts = NULL;
4475 const struct ast_control_t38_parameters *t38_parameters;
4476 int res;
4477
4478 switch (condition) {
4480 if (indicate_connected_line(chan, data, datalen)) {
4481 res = 0;
4482 return res;
4483 }
4484 break;
4486 if (indicate_redirecting(chan, data, datalen)) {
4487 res = 0;
4488 return res;
4489 }
4490 break;
4491 case AST_CONTROL_HOLD:
4492 case AST_CONTROL_UNHOLD:
4493 ast_channel_hold_state_set(chan, _condition);
4494 break;
4496 t38_parameters = data;
4497 switch (t38_parameters->request_response) {
4499 case AST_T38_NEGOTIATED:
4501 break;
4503 case AST_T38_TERMINATED:
4504 case AST_T38_REFUSED:
4506 break;
4507 default:
4508 break;
4509 }
4510 break;
4511 default:
4512 break;
4513 }
4514
4515 if (is_visible_indication(condition)) {
4516 /* A new visible indication is requested. */
4517 ast_channel_visible_indication_set(chan, _condition);
4518 } else if (condition == AST_CONTROL_UNHOLD || _condition < 0) {
4519 /* Visible indication is cleared/stopped. */
4521 }
4522
4523 if (ast_channel_tech(chan)->indicate) {
4524 /* See if the channel driver can handle this condition. */
4525 res = ast_channel_tech(chan)->indicate(chan, _condition, data, datalen);
4526 } else {
4527 res = -1;
4528 }
4529
4530 if (!res) {
4531 /* The channel driver successfully handled this indication */
4532 res = 0;
4533 return res;
4534 }
4535
4536 /* The channel driver does not support this indication, let's fake
4537 * it by doing our own tone generation if applicable. */
4538
4539 /*!\note If we compare the enumeration type, which does not have any
4540 * negative constants, the compiler may optimize this code away.
4541 * Therefore, we must perform an integer comparison here. */
4542 if (_condition < 0) {
4543 /* Stop any tones that are playing */
4544 ast_playtones_stop(chan);
4545 res = 0;
4546 return res;
4547 }
4548
4549 /* Handle conditions that we have tones for. */
4550 switch (condition) {
4552 /* deprecated T.38 control frame */
4553 res = -1;
4554 return res;
4556 /* there is no way to provide 'default' behavior for these
4557 * control frames, so we need to return failure, but there
4558 * is also no value in the log message below being emitted
4559 * since failure to handle these frames is not an 'error'
4560 * so just return right now. in addition, we want to return
4561 * whatever value the channel driver returned, in case it
4562 * has some meaning.*/
4563 return res;
4565 ts = ast_get_indication_tone(ast_channel_zone(chan), "ring");
4566 /* It is common practice for channel drivers to return -1 if trying
4567 * to indicate ringing on a channel which is up. The idea is to let the
4568 * core generate the ringing inband. However, we don't want the
4569 * warning message about not being able to handle the specific indication
4570 * to print nor do we want ast_indicate_data to return an "error" for this
4571 * condition
4572 */
4573 if (ast_channel_state(chan) == AST_STATE_UP) {
4574 res = 0;
4575 }
4576 break;
4577 case AST_CONTROL_BUSY:
4578 ts = ast_get_indication_tone(ast_channel_zone(chan), "busy");
4579 break;
4582 ts = ast_get_indication_tone(ast_channel_zone(chan), "congestion");
4583 break;
4585 ast_channel_hangupcause_hash_set(chan, data, datalen);
4586 res = 0;
4587 break;
4595 case AST_CONTROL_OPTION:
4596 case AST_CONTROL_WINK:
4597 case AST_CONTROL_FLASH:
4600 case AST_CONTROL_ANSWER:
4601 case AST_CONTROL_HANGUP:
4602 case AST_CONTROL_RING:
4603 case AST_CONTROL_HOLD:
4604 case AST_CONTROL_UNHOLD:
4608 case AST_CONTROL_CC:
4610 case AST_CONTROL_AOC:
4612 case AST_CONTROL_MCID:
4627 /* Nothing left to do for these. */
4628 res = 0;
4629 break;
4630 }
4631
4632 if (ts) {
4633 /* We have a tone to play, yay. */
4634 ast_debug(1, "Driver for channel '%s' does not support indication %u, emulating it\n", ast_channel_name(chan), condition);
4635 res = ast_playtones_start(chan, 0, ts->data, 1);
4636 if (!res) {
4637 ast_test_suite_event_notify("RINGING_INBAND",
4638 "Channel: %s\r\n",
4639 ast_channel_name(chan));
4640 }
4642 }
4643
4644 if (res) {
4645 /* not handled */
4646 ast_log(LOG_WARNING, "Unable to handle indication %u for '%s'\n", condition, ast_channel_name(chan));
4647 }
4648
4649 return res;
4650}
4651
4652int ast_indicate_data(struct ast_channel *chan, int _condition, const void *data, size_t datalen)
4653{
4654 int res;
4655 /* this frame is used by framehooks. if it is set, we must free it at the end of this function */
4656 struct ast_frame *awesome_frame = NULL;
4657
4658 ast_channel_lock(chan);
4659
4660 /* Don't bother if the channel is about to go away, anyway. */
4663 && _condition != AST_CONTROL_MASQUERADE_NOTIFY) {
4664 res = -1;
4665 goto indicate_cleanup;
4666 }
4667
4669 /* Do framehooks now, do it, go, go now */
4670 struct ast_frame frame = {
4672 .subclass.integer = _condition,
4673 .data.ptr = (void *) data, /* this cast from const is only okay because we do the ast_frdup below */
4674 .datalen = datalen
4675 };
4676
4677 /* we have now committed to freeing this frame */
4678 awesome_frame = ast_frdup(&frame);
4679
4680 /* who knows what we will get back! the anticipation is killing me. */
4682 awesome_frame);
4683 if (!awesome_frame
4684 || awesome_frame->frametype != AST_FRAME_CONTROL) {
4685 res = 0;
4686 goto indicate_cleanup;
4687 }
4688
4689 _condition = awesome_frame->subclass.integer;
4690 data = awesome_frame->data.ptr;
4691 datalen = awesome_frame->datalen;
4692 }
4693
4694 res = indicate_data_internal(chan, _condition, data, datalen);
4695
4696indicate_cleanup:
4697 ast_channel_unlock(chan);
4698 if (awesome_frame) {
4699 ast_frfree(awesome_frame);
4700 }
4701
4702 return res;
4703}
4704
4705int ast_recvchar(struct ast_channel *chan, int timeout)
4706{
4707 int c;
4708 char *buf = ast_recvtext(chan, timeout);
4709 if (buf == NULL)
4710 return -1; /* error or timeout */
4711 c = *(unsigned char *)buf;
4712 ast_free(buf);
4713 return c;
4714}
4715
4716char *ast_recvtext(struct ast_channel *chan, int timeout)
4717{
4718 int res;
4719 char *buf = NULL;
4720 struct timeval start = ast_tvnow();
4721 int ms;
4722
4723 while ((ms = ast_remaining_ms(start, timeout))) {
4724 struct ast_frame *f;
4725
4726 if (ast_check_hangup(chan)) {
4727 break;
4728 }
4729 res = ast_waitfor(chan, ms);
4730 if (res <= 0) {/* timeout or error */
4731 break;
4732 }
4733 f = ast_read(chan);
4734 if (f == NULL) {
4735 break; /* no frame */
4736 }
4738 ast_frfree(f);
4739 break;
4740 } else if (f->frametype == AST_FRAME_TEXT) { /* what we want */
4741 buf = ast_strndup((char *) f->data.ptr, f->datalen); /* dup and break */
4742 ast_frfree(f);
4743 break;
4744 }
4745 ast_frfree(f);
4746 }
4747 return buf;
4748}
4749
4750int ast_sendtext_data(struct ast_channel *chan, struct ast_msg_data *msg)
4751{
4752 int res = 0;
4753 const char *body = ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_BODY);
4754 const char *content_type = ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_CONTENT_TYPE);
4755
4756 ast_channel_lock(chan);
4757 /* Stop if we're a zombie or need a soft hangup */
4759 ast_channel_unlock(chan);
4760 return -1;
4761 }
4762
4763 CHECK_BLOCKING(chan);
4764 if (ast_channel_tech(chan)->write_text
4765 && (ast_strlen_zero(content_type) || ast_begins_with(content_type, "text/"))
4767 struct ast_frame f;
4768 /* T.140 payload does not include the null byte terminator */
4769 size_t body_len = strlen(body);
4770
4771 /* Process as T.140 text (moved here from ast_sendtext() */
4772 memset(&f, 0, sizeof(f));
4773 f.src = "DIALPLAN";
4776 f.datalen = body_len;
4778 f.data.ptr = ast_strdup(body);
4779 if (f.data.ptr) {
4780 res = ast_channel_tech(chan)->write_text(chan, &f);
4781 } else {
4782 res = -1;
4783 }
4784 ast_frfree(&f);
4785 } else if ((ast_channel_tech(chan)->properties & AST_CHAN_TP_SEND_TEXT_DATA)
4786 && ast_channel_tech(chan)->send_text_data) {
4787 /* Send enhanced message to a channel driver that supports it */
4788 ast_debug(1, "Sending TEXT_DATA from '%s' to %s:%s %s\n",
4791 ast_channel_name(chan), body);
4792 res = ast_channel_tech(chan)->send_text_data(chan, msg);
4793 } else if (ast_channel_tech(chan)->send_text
4794 && (ast_strlen_zero(content_type) || ast_begins_with(content_type, "text/"))) {
4795 /* Send the body of an enhanced message to a channel driver that supports only a char str */
4796 ast_debug(1, "Sending TEXT to %s: %s\n", ast_channel_name(chan), body);
4797 res = ast_channel_tech(chan)->send_text(chan, body);
4798 } else {
4799 ast_debug(1, "Channel technology does not support sending content type '%s' on channel '%s'\n",
4800 S_OR(content_type, "text/plain"), ast_channel_name(chan));
4801 res = -1;
4802 }
4804 ast_channel_unlock(chan);
4805 return res;
4806}
4807
4808int ast_sendtext(struct ast_channel *chan, const char *text)
4809{
4810 struct ast_msg_data *msg;
4811 int rc;
4812 struct ast_msg_data_attribute attrs[] =
4813 {
4814 {
4816 .value = (char *)text,
4817 }
4818 };
4819
4820 if (ast_strlen_zero(text)) {
4821 return 0;
4822 }
4823
4825 if (!msg) {
4826 return -1;
4827 }
4828 rc = ast_sendtext_data(chan, msg);
4829 ast_free(msg);
4830
4831 return rc;
4832}
4833
4835{
4836 static const char * const mf_tones[] = {
4837 "1300+1500", /* 0 */
4838 "700+900", /* 1 */
4839 "700+1100", /* 2 */
4840 "900+1100", /* 3 */
4841 "700+1300", /* 4 */
4842 "900+1300", /* 5 */
4843 "1100+1300", /* 6 */
4844 "700+1500", /* 7 */
4845 "900+1500", /* 8 */
4846 "1100+1500", /* 9 */
4847 "1100+1700", /* * (KP) */
4848 "1500+1700", /* # (ST) */
4849 "900+1700", /* A (STP) */
4850 "1300+1700", /* B (ST2P) */
4851 "700+1700" /* C (ST3P) */
4852 };
4853
4854 if (digit >= '0' && digit <='9') {
4855 ast_playtones_start(chan, 0, mf_tones[digit-'0'], 0);
4856 } else if (digit == '*') {
4857 ast_playtones_start(chan, 0, mf_tones[10], 0);
4858 } else if (digit == '#') {
4859 ast_playtones_start(chan, 0, mf_tones[11], 0);
4860 } else if (digit == 'A') {
4861 ast_playtones_start(chan, 0, mf_tones[12], 0);
4862 } else if (digit == 'B') {
4863 ast_playtones_start(chan, 0, mf_tones[13], 0);
4864 } else if (digit == 'C') {
4865 ast_playtones_start(chan, 0, mf_tones[14], 0);
4866 } else {
4867 /* not handled */
4868 ast_log(LOG_WARNING, "Unable to generate MF tone '%c' for '%s'\n", digit, ast_channel_name(chan));
4869 }
4870 return 0;
4871}
4872
4874{
4875 /* Device does not support DTMF tones, lets fake
4876 * it by doing our own generation. */
4877 static const char * const dtmf_tones[] = {
4878 "941+1336", /* 0 */
4879 "697+1209", /* 1 */
4880 "697+1336", /* 2 */
4881 "697+1477", /* 3 */
4882 "770+1209", /* 4 */
4883 "770+1336", /* 5 */
4884 "770+1477", /* 6 */
4885 "852+1209", /* 7 */
4886 "852+1336", /* 8 */
4887 "852+1477", /* 9 */
4888 "697+1633", /* A */
4889 "770+1633", /* B */
4890 "852+1633", /* C */
4891 "941+1633", /* D */
4892 "941+1209", /* * */
4893 "941+1477" /* # */
4894 };
4895
4896 if (!ast_channel_tech(chan)->send_digit_begin)
4897 return 0;
4898
4899 ast_channel_lock(chan);
4902 ast_channel_unlock(chan);
4903
4904 if (!ast_channel_tech(chan)->send_digit_begin(chan, digit))
4905 return 0;
4906
4907 if (digit >= '0' && digit <='9')
4908 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
4909 else if (digit >= 'A' && digit <= 'D')
4910 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
4911 else if (digit == '*')
4912 ast_playtones_start(chan, 0, dtmf_tones[14], 0);
4913 else if (digit == '#')
4914 ast_playtones_start(chan, 0, dtmf_tones[15], 0);
4915 else {
4916 /* not handled */
4917 ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, ast_channel_name(chan));
4918 }
4919
4920 return 0;
4921}
4922
4923int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
4924{
4925 int res = -1;
4926
4927 if (ast_channel_tech(chan)->send_digit_end)
4928 res = ast_channel_tech(chan)->send_digit_end(chan, digit, duration);
4929
4930 ast_channel_lock(chan);
4933 }
4934 ast_channel_unlock(chan);
4935
4936 if (res && ast_channel_generator(chan))
4937 ast_playtones_stop(chan);
4938
4939 return 0;
4940}
4941
4943{
4944 if (ast_channel_generator(chan)) {
4945 ast_playtones_stop(chan);
4946 return 0;
4947 }
4948 return -1;
4949}
4950
4951int ast_senddigit_mf(struct ast_channel *chan, char digit, unsigned int duration,
4952 unsigned int durationkp, unsigned int durationst, int is_external)
4953{
4954 if (duration < DEFAULT_EMULATE_MF_DURATION) {
4955 duration = DEFAULT_EMULATE_MF_DURATION;
4956 }
4957 if (ast_channel_tech(chan)->send_digit_begin) {
4958 if (digit == '*') {
4959 duration = durationkp;
4960 } else if (digit == '#' || digit == 'A' || digit == 'B' || digit == 'C') {
4961 duration = durationst;
4962 }
4964 if (is_external) {
4965 usleep(duration * 1000);
4966 } else {
4967 ast_safe_sleep(chan, duration);
4968 }
4969 }
4970 return ast_senddigit_mf_end(chan);
4971}
4972
4973int ast_senddigit(struct ast_channel *chan, char digit, unsigned int duration)
4974{
4975 if (duration < AST_DEFAULT_EMULATE_DTMF_DURATION) {
4977 }
4978 if (ast_channel_tech(chan)->send_digit_begin) {
4980 ast_safe_sleep(chan, duration);
4981 }
4982
4983 return ast_senddigit_end(chan, digit, duration);
4984}
4985
4986int ast_senddigit_external(struct ast_channel *chan, char digit, unsigned int duration)
4987{
4988 if (duration < AST_DEFAULT_EMULATE_DTMF_DURATION) {
4990 }
4991 if (ast_channel_tech(chan)->send_digit_begin) {
4993 usleep(duration * 1000);
4994 }
4995
4996 return ast_senddigit_end(chan, digit, duration);
4997}
4998
4999int ast_prod(struct ast_channel *chan)
5000{
5001 struct ast_frame a = { AST_FRAME_VOICE };
5002 char nothing[128];
5003
5004 /* Send an empty audio frame to get things moving */
5005 if (ast_channel_state(chan) != AST_STATE_UP) {
5006 ast_debug(3, "Prodding channel '%s'\n", ast_channel_name(chan));
5007 a.subclass.format = ast_channel_rawwriteformat(chan);
5008 a.data.ptr = nothing + AST_FRIENDLY_OFFSET;
5009 a.src = "ast_prod"; /* this better match check in ast_write */
5010 if (ast_write(chan, &a))
5011 ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", ast_channel_name(chan));
5012 }
5013 return 0;
5014}
5015
5016int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
5017{
5018 int res;
5019 if (!ast_channel_tech(chan)->write_video)
5020 return 0;
5021 res = ast_write(chan, fr);
5022 if (!res)
5023 res = 1;
5024 return res;
5025}
5026
5027struct plc_ds {
5028 /* A buffer in which to store SLIN PLC
5029 * samples generated by the generic PLC
5030 * functionality in plc.c
5031 */
5033 /* The current number of samples in the
5034 * samples_buf
5035 */
5038};
5039
5040static void plc_ds_destroy(void *data)
5041{
5042 struct plc_ds *plc = data;
5043 ast_free(plc->samples_buf);
5044 ast_free(plc);
5045}
5046
5047static const struct ast_datastore_info plc_ds_info = {
5048 .type = "plc",
5049 .destroy = plc_ds_destroy,
5050};
5051
5052static void adjust_frame_for_plc(struct ast_channel *chan, struct ast_frame *frame, struct ast_datastore *datastore)
5053{
5054 int num_new_samples = frame->samples;
5055 struct plc_ds *plc = datastore->data;
5056
5057 /* As a general note, let me explain the somewhat odd calculations used when taking
5058 * the frame offset into account here. According to documentation in frame.h, the frame's
5059 * offset field indicates the number of bytes that the audio is offset. The plc->samples_buf
5060 * is not an array of bytes, but rather an array of 16-bit integers since it holds SLIN
5061 * samples. So I had two choices to make here with the offset.
5062 *
5063 * 1. Make the offset AST_FRIENDLY_OFFSET bytes. The main downside for this is that
5064 * I can't just add AST_FRIENDLY_OFFSET to the plc->samples_buf and have the pointer
5065 * arithmetic come out right. I would have to do some odd casting or division for this to
5066 * work as I wanted.
5067 * 2. Make the offset AST_FRIENDLY_OFFSET * 2 bytes. This allows the pointer arithmetic
5068 * to work out better with the plc->samples_buf. The downside here is that the buffer's
5069 * allocation contains an extra 64 bytes of unused space.
5070 *
5071 * I decided to go with option 2. This is why in the calloc statement and the statement that
5072 * sets the frame's offset, AST_FRIENDLY_OFFSET is multiplied by 2.
5073 */
5074
5075 /* If this audio frame has no samples to fill in, ignore it */
5076 if (!num_new_samples) {
5077 return;
5078 }
5079
5080 /* First, we need to be sure that our buffer is large enough to accomodate
5081 * the samples we need to fill in. This will likely only occur on the first
5082 * frame we write.
5083 */
5084 if (plc->num_samples < num_new_samples) {
5085 ast_free(plc->samples_buf);
5086 plc->samples_buf = ast_calloc(1, (num_new_samples * sizeof(*plc->samples_buf)) + (AST_FRIENDLY_OFFSET * 2));
5087 if (!plc->samples_buf) {
5088 ast_channel_datastore_remove(chan, datastore);
5089 ast_datastore_free(datastore);
5090 return;
5091 }
5092 plc->num_samples = num_new_samples;
5093 }
5094
5095 if (frame->datalen == 0) {
5097 frame->data.ptr = plc->samples_buf + AST_FRIENDLY_OFFSET;
5098 frame->datalen = num_new_samples * 2;
5099 frame->offset = AST_FRIENDLY_OFFSET * 2;
5100 } else {
5101 plc_rx(&plc->plc_state, frame->data.ptr, frame->samples);
5102 }
5103}
5104
5105static void apply_plc(struct ast_channel *chan, struct ast_frame *frame)
5106{
5107 struct ast_datastore *datastore;
5108 struct plc_ds *plc;
5109
5110 datastore = ast_channel_datastore_find(chan, &plc_ds_info, NULL);
5111 if (datastore) {
5112 plc = datastore->data;
5113 adjust_frame_for_plc(chan, frame, datastore);
5114 return;
5115 }
5116
5117 datastore = ast_datastore_alloc(&plc_ds_info, NULL);
5118 if (!datastore) {
5119 return;
5120 }
5121 plc = ast_calloc(1, sizeof(*plc));
5122 if (!plc) {
5123 ast_datastore_free(datastore);
5124 return;
5125 }
5126 datastore->data = plc;
5127 ast_channel_datastore_add(chan, datastore);
5128 adjust_frame_for_plc(chan, frame, datastore);
5129}
5130
5131static int tech_write(struct ast_channel *chan, struct ast_stream *stream,
5132 struct ast_stream *default_stream, struct ast_frame *frame)
5133{
5134 if (ast_channel_tech(chan)->write_stream) {
5135 return stream ? ast_channel_tech(chan)->write_stream(
5136 chan, ast_stream_get_position(stream), frame) : 0;
5137 }
5138
5139 return ((stream == default_stream) && ast_channel_tech(chan)->write) ?
5140 ast_channel_tech(chan)->write(chan, frame) : 0;
5141}
5142
5143int ast_write(struct ast_channel *chan, struct ast_frame *fr)
5144{
5145 return ast_write_stream(chan, -1, fr);
5146}
5147
5148int ast_write_stream(struct ast_channel *chan, int stream_num, struct ast_frame *fr)
5149{
5150 struct ast_stream *stream = NULL, *default_stream = NULL;
5151 int res = -1;
5152 struct ast_frame *f = NULL;
5153 int count = 0;
5154 int hooked = 0;
5155
5156 /*Deadlock avoidance*/
5157 while(ast_channel_trylock(chan)) {
5158 /*cannot goto done since the channel is not locked*/
5159 if(count++ > 10) {
5160 ast_debug(1, "Deadlock avoided for write to channel '%s'\n", ast_channel_name(chan));
5161 return 0;
5162 }
5163 usleep(1);
5164 }
5165
5166 /* Stop if we're a zombie or need a soft hangup */
5168 goto done;
5169 }
5170
5171 if (stream_num >= 0) {
5172 /* If we were told to write to an explicit stream then allow this frame through, no matter
5173 * if the type is expected or not (a framehook could change)
5174 */
5176 goto done;
5177 }
5179 default_stream = ast_channel_get_default_stream(chan, ast_stream_get_type(stream));
5180 } else if (fr->frametype == AST_FRAME_VOICE || fr->frametype == AST_FRAME_VIDEO || fr->frametype == AST_FRAME_MODEM) {
5181 /* If we haven't been told of a stream then we need to figure out which once we need */
5183
5184 /* Some frame types have a fixed media type */
5185 if (fr->frametype == AST_FRAME_VOICE || fr->frametype == AST_FRAME_VIDEO) {
5187 } else if (fr->frametype == AST_FRAME_MODEM) {
5189 }
5190
5191 /* No stream was specified, so use the default one */
5192 stream = default_stream = ast_channel_get_default_stream(chan, type);
5193 }
5194
5195 /* Perform the framehook write event here. After the frame enters the framehook list
5196 * there is no telling what will happen, how awesome is that!!! */
5197 if ((stream == default_stream) && !(fr = ast_framehook_list_write_event(ast_channel_framehooks(chan), fr))) {
5198 res = 0;
5199 goto done;
5200 }
5201
5202 if (ast_channel_generatordata(chan) && (fr->frametype != AST_FRAME_RTCP) && (!fr->src || strcasecmp(fr->src, "ast_prod"))) {
5205 } else {
5206 if (fr->frametype == AST_FRAME_DTMF_END) {
5207 /* There is a generator running while we're in the middle of a digit.
5208 * It's probably inband DTMF, so go ahead and pass it so it can
5209 * stop the generator */
5210 ast_channel_unlock(chan);
5211 res = ast_senddigit_end(chan, fr->subclass.integer, fr->len);
5212 ast_channel_lock(chan);
5213 } else if (fr->frametype == AST_FRAME_CONTROL
5215 /*
5216 * This is a side case where Echo is basically being called
5217 * and the person put themselves on hold and took themselves
5218 * off hold.
5219 */
5221 fr->datalen);
5222 }
5223 res = 0; /* XXX explain, why 0 ? */
5224 goto done;
5225 }
5226 }
5227 /* High bit prints debugging */
5228 if (ast_channel_fout(chan) & DEBUGCHAN_FLAG)
5229 ast_frame_dump(ast_channel_name(chan), fr, ">>");
5230 switch (fr->frametype) {
5231 case AST_FRAME_CONTROL:
5233 res = 0;
5234 break;
5236 if (ast_channel_audiohooks(chan)) {
5237 struct ast_frame *old_frame = fr;
5239 if (old_frame != fr)
5240 f = fr;
5241 }
5243 ast_channel_unlock(chan);
5244 res = ast_senddigit_begin(chan, fr->subclass.integer);
5245 ast_channel_lock(chan);
5246 break;
5247 case AST_FRAME_DTMF_END:
5248 if (ast_channel_audiohooks(chan)) {
5249 struct ast_frame *new_frame = fr;
5250
5252 if (new_frame != fr) {
5253 ast_frfree(new_frame);
5254 }
5255 }
5257 ast_channel_unlock(chan);
5258 res = ast_senddigit_end(chan, fr->subclass.integer, fr->len);
5259 ast_channel_lock(chan);
5260 break;
5261 case AST_FRAME_TEXT:
5262 CHECK_BLOCKING(chan);
5264 res = (ast_channel_tech(chan)->write_text == NULL) ? 0 :
5265 ast_channel_tech(chan)->write_text(chan, fr);
5266 } else {
5267 res = (ast_channel_tech(chan)->send_text == NULL) ? 0 :
5268 ast_channel_tech(chan)->send_text(chan, (char *) fr->data.ptr);
5269 }
5271 break;
5272 case AST_FRAME_HTML:
5273 CHECK_BLOCKING(chan);
5274 res = (ast_channel_tech(chan)->send_html == NULL) ? 0 :
5275 ast_channel_tech(chan)->send_html(chan, fr->subclass.integer, (char *) fr->data.ptr, fr->datalen);
5277 break;
5278 case AST_FRAME_VIDEO:
5279 /* XXX Handle translation of video codecs one day XXX */
5280 CHECK_BLOCKING(chan);
5281 if (ast_channel_tech(chan)->write_stream) {
5282 if (stream) {
5283 res = ast_channel_tech(chan)->write_stream(chan, ast_stream_get_position(stream), fr);
5284 } else {
5285 res = 0;
5286 }
5287 } else if ((stream == default_stream) && ast_channel_tech(chan)->write_video) {
5288 res = ast_channel_tech(chan)->write_video(chan, fr);
5289 } else {
5290 res = 0;
5291 }
5293 break;
5294 case AST_FRAME_MODEM:
5295 CHECK_BLOCKING(chan);
5296 res = tech_write(chan, stream, default_stream, fr);
5298 break;
5299 case AST_FRAME_VOICE:
5301 apply_plc(chan, fr);
5302 }
5303
5304 f = fr;
5305
5306 /*
5307 * Send frame to audiohooks if present, if frametype is linear (else, later as per
5308 * previous behavior)
5309 */
5310 if ((stream == default_stream) && ast_channel_audiohooks(chan)) {
5312 hooked = 1;
5314 }
5315 }
5316
5317 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
5318 if ((stream == default_stream) && ast_format_cmp(fr->subclass.format, ast_channel_rawwriteformat(chan)) != AST_FORMAT_CMP_EQUAL) {
5320 struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
5321
5322 /*
5323 * We are not setup to write this frame. Things may have changed
5324 * on the peer side of the world and we try to adjust the format to
5325 * make it compatible again. However, bad things can happen if we
5326 * cannot setup a new translation path. Problems range from no
5327 * audio, one-way audio, to garbled audio. The best we can do is
5328 * request the call to hangup since we could not make it compatible.
5329 *
5330 * Being continuously spammed by this message likely indicates a
5331 * problem with the peer because it cannot make up its mind about
5332 * which format to use.
5333 */
5334 ast_debug(1, "Channel %s changing write format from %s to %s, native formats %s\n",
5335 ast_channel_name(chan),
5339 if (ast_set_write_format(chan, fr->subclass.format)) {
5340 /* Could not handle the new write format. Induce a hangup. */
5341 break;
5342 }
5343 }
5344
5345 if (ast_channel_writetrans(chan)) {
5346 struct ast_frame *trans_frame = ast_translate(ast_channel_writetrans(chan), f, 0);
5347 if (trans_frame != f && f != fr) {
5348 /*
5349 * If translate gives us a new frame and so did the audio
5350 * hook then we need to free the one from the audio hook.
5351 */
5352 ast_frfree(f);
5353 }
5354 f = trans_frame;
5355 }
5356 }
5357
5358 if (!f) {
5359 res = 0;
5360 break;
5361 }
5362
5363 if ((stream == default_stream) && ast_channel_audiohooks(chan) && !hooked) {
5364 struct ast_frame *prev = NULL, *new_frame, *cur, *dup;
5365 int freeoldlist = 0;
5366
5367 if (f != fr) {
5368 freeoldlist = 1;
5369 }
5370
5371 /* Since ast_audiohook_write may return a new frame, and the cur frame is
5372 * an item in a list of frames, create a new list adding each cur frame back to it
5373 * regardless if the cur frame changes or not. */
5374 for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
5376
5377 /* if this frame is different than cur, preserve the end of the list,
5378 * free the old frames, and set cur to be the new frame */
5379 if (new_frame != cur) {
5380
5381 /* doing an ast_frisolate here seems silly, but we are not guaranteed the new_frame
5382 * isn't part of local storage, meaning if ast_audiohook_write is called multiple
5383 * times it may override the previous frame we got from it unless we dup it */
5384 if ((dup = ast_frisolate(new_frame))) {
5386 if (freeoldlist) {
5388 ast_frfree(cur);
5389 }
5390 if (new_frame != dup) {
5391 ast_frfree(new_frame);
5392 }
5393 cur = dup;
5394 }
5395 }
5396
5397 /* now, regardless if cur is new or not, add it to the new list,
5398 * if the new list has not started, cur will become the first item. */
5399 if (prev) {
5400 AST_LIST_NEXT(prev, frame_list) = cur;
5401 } else {
5402 f = cur; /* set f to be the beginning of our new list */
5403 }
5404 prev = cur;
5405 }
5406 }
5407
5408 /* the translator on chan->writetrans may have returned multiple frames
5409 from the single frame we passed in; if so, feed each one of them to the
5410 channel, freeing each one after it has been written */
5411 CHECK_BLOCKING(chan);
5412 if ((f != fr) && AST_LIST_NEXT(f, frame_list)) {
5413 struct ast_frame *cur, *next = NULL;
5414 unsigned int skip = 0;
5415
5416 cur = f;
5417 while (cur) {
5420 if (!skip) {
5421 res = tech_write(chan, stream, default_stream, cur);
5422 if (res < 0) {
5424 skip = 1;
5425 } else if (next) {
5426 /* don't do this for the last frame in the list,
5427 as the code outside the loop will do it once
5428 */
5430 }
5431 }
5432 ast_frfree(cur);
5433 cur = next;
5434 }
5435
5436 /* reset f so the code below doesn't attempt to free it */
5437 f = NULL;
5438 } else {
5439 res = tech_write(chan, stream, default_stream, f);
5440 }
5442 break;
5443 case AST_FRAME_NULL:
5444 case AST_FRAME_IAX:
5445 /* Ignore these */
5446 res = 0;
5447 break;
5448 case AST_FRAME_RTCP:
5449 /* RTCP information is on a per-stream basis and only available on multistream capable channels */
5450 CHECK_BLOCKING(chan);
5451 if (ast_channel_tech(chan)->write_stream && stream) {
5452 res = ast_channel_tech(chan)->write_stream(chan, ast_stream_get_position(stream), fr);
5453 } else {
5454 res = 0;
5455 }
5457 break;
5458 default:
5459 /* At this point, fr is the incoming frame and f is NULL. Channels do
5460 * not expect to get NULL as a frame pointer and will segfault. Hence,
5461 * we output the original frame passed in. */
5462 CHECK_BLOCKING(chan);
5463 res = ast_channel_tech(chan)->write(chan, fr);
5465 break;
5466 }
5467
5468 if (f && f != fr)
5469 ast_frfree(f);
5470
5471 /* Consider a write failure to force a soft hangup */
5472 if (res < 0) {
5474 } else {
5476 }
5477done:
5479 /* The list gets recreated if audiohooks are added again later */
5482 }
5483 ast_channel_unlock(chan);
5484 return res;
5485}
5486
5487int ast_set_read_format_path(struct ast_channel *chan, struct ast_format *raw_format, struct ast_format *core_format)
5488{
5489 struct ast_trans_pvt *trans_old;
5490 struct ast_trans_pvt *trans_new;
5491
5494 /* Nothing to setup */
5495 return 0;
5496 }
5497
5498 ast_debug(1, "Channel %s setting read format path: %s -> %s\n",
5499 ast_channel_name(chan),
5500 ast_format_get_name(raw_format),
5501 ast_format_get_name(core_format));
5502
5503 /* Setup new translation path. */
5504 if (ast_format_cmp(raw_format, core_format) != AST_FORMAT_CMP_EQUAL) {
5505 trans_new = ast_translator_build_path(core_format, raw_format);
5506 if (!trans_new) {
5507 return -1;
5508 }
5509 } else {
5510 /* No translation needed. */
5511 trans_new = NULL;
5512 }
5513 trans_old = ast_channel_readtrans(chan);
5514 if (trans_old) {
5515 ast_translator_free_path(trans_old);
5516 }
5517 ast_channel_readtrans_set(chan, trans_new);
5518 ast_channel_set_rawreadformat(chan, raw_format);
5519 ast_channel_set_readformat(chan, core_format);
5520 return 0;
5521}
5522
5523int ast_set_write_format_path(struct ast_channel *chan, struct ast_format *core_format, struct ast_format *raw_format)
5524{
5525 struct ast_trans_pvt *trans_old;
5526 struct ast_trans_pvt *trans_new;
5527
5530 /* Nothing to setup */
5531 return 0;
5532 }
5533
5534 ast_debug(1, "Channel %s setting write format path: %s -> %s\n",
5535 ast_channel_name(chan),
5536 ast_format_get_name(core_format),
5537 ast_format_get_name(raw_format));
5538
5539 /* Setup new translation path. */
5540 if (ast_format_cmp(raw_format, core_format) != AST_FORMAT_CMP_EQUAL) {
5541 trans_new = ast_translator_build_path(raw_format, core_format);
5542 if (!trans_new) {
5543 return -1;
5544 }
5545 } else {
5546 /* No translation needed. */
5547 trans_new = NULL;
5548 }
5549 trans_old = ast_channel_writetrans(chan);
5550 if (trans_old) {
5551 ast_translator_free_path(trans_old);
5552 }
5553 ast_channel_writetrans_set(chan, trans_new);
5554 ast_channel_set_rawwriteformat(chan, raw_format);
5555 ast_channel_set_writeformat(chan, core_format);
5556 return 0;
5557}
5558
5560 const char *direction;
5561 struct ast_trans_pvt *(*get_trans)(const struct ast_channel *chan);
5562 void (*set_trans)(struct ast_channel *chan, struct ast_trans_pvt *value);
5563 struct ast_format *(*get_format)(struct ast_channel *chan);
5564 void (*set_format)(struct ast_channel *chan, struct ast_format *format);
5565 struct ast_format *(*get_rawformat)(struct ast_channel *chan);
5566 void (*set_rawformat)(struct ast_channel *chan, struct ast_format *format);
5568};
5569
5571 .direction = "read",
5572 .get_trans = ast_channel_readtrans,
5573 .set_trans = ast_channel_readtrans_set,
5574 .get_format = ast_channel_readformat,
5575 .set_format = ast_channel_set_readformat,
5576 .get_rawformat = ast_channel_rawreadformat,
5577 .set_rawformat = ast_channel_set_rawreadformat,
5578 .setoption = AST_OPTION_FORMAT_READ,
5579};
5580
5582 .direction = "write",
5583 .get_trans = ast_channel_writetrans,
5584 .set_trans = ast_channel_writetrans_set,
5585 .get_format = ast_channel_writeformat,
5586 .set_format = ast_channel_set_writeformat,
5587 .get_rawformat = ast_channel_rawwriteformat,
5588 .set_rawformat = ast_channel_set_rawwriteformat,
5589 .setoption = AST_OPTION_FORMAT_WRITE,
5590};
5591
5592static int set_format(struct ast_channel *chan, struct ast_format_cap *cap_set, const int direction, int interleaved_stereo)
5593{
5594 struct ast_trans_pvt *trans_pvt;
5595 struct ast_format_cap *cap_native;
5596 const struct set_format_access *access;
5597 struct ast_format *rawformat;
5598 struct ast_format *format;
5599 RAII_VAR(struct ast_format *, best_set_fmt, NULL, ao2_cleanup);
5600 RAII_VAR(struct ast_format *, best_native_fmt, NULL, ao2_cleanup);
5601 int res;
5602
5603 if (!direction) {
5604 /* reading */
5605 access = &set_format_access_read;
5606 } else {
5607 /* writing */
5608 access = &set_format_access_write;
5609 }
5610
5612 if (!best_set_fmt) {
5613 /*
5614 * Not setting any audio formats?
5615 * Assume a call without any sounds (video, text)
5616 */
5617 return 0;
5618 }
5619
5620 /* See if the underlying channel driver is capable of performing transcoding for us */
5621 res = ast_channel_setoption(chan, access->setoption,
5622 &best_set_fmt, sizeof(best_set_fmt), 0);
5623 if (!res) {
5624 ast_debug(1, "Channel driver natively set channel %s to %s format %s\n",
5625 ast_channel_name(chan), access->direction, ast_format_get_name(best_set_fmt));
5626
5627 ast_channel_lock(chan);
5629 if (!cap_native
5630 || ast_format_cap_append(cap_native, best_set_fmt, 0)) {
5631 ast_channel_unlock(chan);
5632 ao2_cleanup(cap_native);
5633 return -1;
5634 }
5635 ast_channel_nativeformats_set(chan, cap_native);
5636 ao2_cleanup(cap_native);
5637 access->set_format(chan, best_set_fmt);
5638 access->set_rawformat(chan, best_set_fmt);
5639
5640 trans_pvt = access->get_trans(chan);
5641 if (trans_pvt) {
5642 ast_translator_free_path(trans_pvt);
5643 access->set_trans(chan, NULL);
5644 }
5645 ast_channel_unlock(chan);
5646
5647 /* If there is a generator on the channel, it needs to know about this
5648 * change if it is the write format. */
5649 if (direction && ast_channel_generatordata(chan)) {
5651 }
5652
5653 return 0;
5654 }
5655
5656 ast_channel_lock(chan);
5657
5658 format = access->get_format(chan);
5659 rawformat = access->get_rawformat(chan);
5660 ast_assert(format != NULL);
5661 ast_assert(rawformat != NULL);
5662
5663 cap_native = ast_channel_nativeformats(chan);
5664 if (ast_format_cap_empty(cap_native)) {
5665 ast_channel_unlock(chan);
5666 ast_log(LOG_ERROR, "Unable to set format because channel %s supports no formats\n",
5667 ast_channel_name(chan));
5668 return -1;
5669 }
5670
5671 /* Find a translation path from the native format to one of the desired formats */
5672 if (!direction) {
5673 /* reading */
5674 res = ast_translator_best_choice(cap_set, cap_native, &best_set_fmt, &best_native_fmt);
5675 } else {
5676 /* writing */
5677 res = ast_translator_best_choice(cap_native, cap_set, &best_native_fmt, &best_set_fmt);
5678 }
5679 if (res < 0) {
5680 struct ast_str *codec_native = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
5681 struct ast_str *codec_set = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
5682
5683 ast_format_cap_get_names(cap_native, &codec_native);
5684 ast_channel_unlock(chan);
5685 ast_format_cap_get_names(cap_set, &codec_set);
5686
5687 ast_log(LOG_WARNING, "Unable to find a codec translation path: %s -> %s\n",
5688 ast_str_buffer(direction ? codec_set : codec_native),
5689 ast_str_buffer(direction ? codec_native : codec_set));
5690 return -1;
5691 }
5692
5693 /* Now we have a good choice for both. */
5694 trans_pvt = access->get_trans(chan);
5695 if ((ast_format_cmp(rawformat, best_native_fmt) != AST_FORMAT_CMP_NOT_EQUAL) &&
5696 (ast_format_cmp(format, best_set_fmt) != AST_FORMAT_CMP_NOT_EQUAL) &&
5697 ((ast_format_cmp(rawformat, format) != AST_FORMAT_CMP_NOT_EQUAL) || access->get_trans(chan))) {
5698 /* the channel is already in these formats, so nothing to do, unless the interleaved format is not set correctly */
5699 if (trans_pvt != NULL) {
5700 if (trans_pvt->interleaved_stereo == interleaved_stereo) {
5701 ast_channel_unlock(chan);
5702 return 0;
5703 }
5704 }
5705 }
5706
5707 /* Free any translation we have right now */
5708 if (trans_pvt) {
5709 ast_translator_free_path(trans_pvt);
5710 access->set_trans(chan, NULL);
5711 }
5712
5713 /* Build a translation path from the raw format to the desired format */
5714 if (ast_format_cmp(best_set_fmt, best_native_fmt) != AST_FORMAT_CMP_NOT_EQUAL) {
5715 /*
5716 * If we were able to swap the native format to the format that
5717 * has been requested, then there is no need to try to build
5718 * a translation path.
5719 */
5720 res = 0;
5721 } else {
5722 if (!direction) {
5723 /* reading */
5724 trans_pvt = ast_translator_build_path(best_set_fmt, best_native_fmt);
5725 if (trans_pvt) {
5726 trans_pvt->interleaved_stereo = 0;
5727 }
5728 } else {
5729 /* writing */
5730 trans_pvt = ast_translator_build_path(best_native_fmt, best_set_fmt);
5731 if (trans_pvt) {
5732 trans_pvt->interleaved_stereo = interleaved_stereo;
5733 }
5734 }
5735 access->set_trans(chan, trans_pvt);
5736 res = trans_pvt ? 0 : -1;
5737 }
5738
5739 if (!res) {
5740 access->set_format(chan, best_set_fmt);
5741 access->set_rawformat(chan, best_native_fmt);
5742
5743 ast_debug(1, "Channel %s setting %s format path: %s -> %s\n",
5744 ast_channel_name(chan),
5745 access->direction,
5746 ast_format_get_name(direction ? best_set_fmt : best_native_fmt),
5747 ast_format_get_name(direction ? best_native_fmt : best_set_fmt));
5748 }
5749
5750 ast_channel_unlock(chan);
5751
5752 /* If there is a generator on the channel, it needs to know about this
5753 * change if it is the write format. */
5754 if (direction && ast_channel_generatordata(chan)) {
5756 }
5757
5758 return res;
5759}
5760
5761int ast_set_read_format(struct ast_channel *chan, struct ast_format *format)
5762{
5764 int res;
5765
5766 ast_assert(format != NULL);
5767
5768 if (!cap) {
5769 return -1;
5770 }
5771 ast_format_cap_append(cap, format, 0);
5772
5773 res = set_format(chan, cap, 0, 0);
5774
5775 ao2_cleanup(cap);
5776 return res;
5777}
5778
5780{
5781 return set_format(chan, cap, 0, 0);
5782}
5783
5785{
5787 int res;
5788
5789 ast_assert(format != NULL);
5790
5791 if (!cap) {
5792 return -1;
5793 }
5794 ast_format_cap_append(cap, format, 0);
5795
5796 res = set_format(chan, cap, 1, 1);
5797
5798 ao2_cleanup(cap);
5799 return res;
5800}
5801
5802int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
5803{
5805 int res;
5806
5807 ast_assert(format != NULL);
5808
5809 if (!cap) {
5810 return -1;
5811 }
5812 ast_format_cap_append(cap, format, 0);
5813
5814 res = set_format(chan, cap, 1, 0);
5815
5816 ao2_cleanup(cap);
5817 return res;
5818}
5819
5821{
5822 return set_format(chan, cap, 1, 0);
5823}
5824
5825const char *ast_channel_reason2str(int reason)
5826{
5827 switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */
5828 {
5829 case 0:
5830 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
5831 case AST_CONTROL_HANGUP:
5832 return "Hangup";
5833 case AST_CONTROL_RING:
5834 return "Local Ring";
5836 return "Remote end Ringing";
5837 case AST_CONTROL_ANSWER:
5838 return "Remote end has Answered";
5839 case AST_CONTROL_BUSY:
5840 return "Remote end is Busy";
5842 return "Congestion (circuits busy)";
5843 default:
5844 return "Unknown Reason!!";
5845 }
5846}
5847
5848static void handle_cause(int cause, int *outstate)
5849{
5850 if (outstate) {
5851 /* compute error and return */
5852 if (cause == AST_CAUSE_BUSY)
5853 *outstate = AST_CONTROL_BUSY;
5854 else if (cause == AST_CAUSE_CONGESTION)
5855 *outstate = AST_CONTROL_CONGESTION;
5856 else
5857 *outstate = 0;
5858 }
5859}
5860
5861/*!
5862 * \internal
5863 * \brief Helper function to inherit info from parent channel.
5864 *
5865 * \param new_chan Channel inheriting information.
5866 * \param parent Channel new_chan inherits information.
5867 * \param orig Channel being replaced by the call forward channel.
5868 */
5869static void call_forward_inherit(struct ast_channel *new_chan, struct ast_channel *parent, struct ast_channel *orig)
5870{
5872 struct ast_party_redirecting redirecting;
5873
5874 /*
5875 * The parent is not a ZOMBIE or hungup so update it with the
5876 * original channel's redirecting information.
5877 */
5878 ast_party_redirecting_init(&redirecting);
5882 if (ast_channel_redirecting_sub(orig, parent, &redirecting, 0)) {
5883 ast_channel_update_redirecting(parent, &redirecting, NULL);
5884 }
5885 ast_party_redirecting_free(&redirecting);
5886 }
5887
5888 /* Safely inherit variables and datastores from the parent channel. */
5889 ast_channel_lock_both(parent, new_chan);
5890 ast_channel_inherit_variables(parent, new_chan);
5891 ast_channel_datastore_inherit(parent, new_chan);
5893 ast_channel_unlock(new_chan);
5894 ast_channel_unlock(parent);
5895}
5896
5897struct ast_channel *ast_call_forward(struct ast_channel *caller, struct ast_channel *orig, int *timeout, struct ast_format_cap *cap, struct outgoing_helper *oh, int *outstate)
5898{
5899 char tmpchan[256];
5900 char forwarder[AST_CHANNEL_NAME];
5901 struct ast_channel *new_chan = NULL;
5902 char *data, *type;
5903 int cause = 0;
5904 int res;
5905
5906 /* gather data and request the new forward channel */
5907 ast_copy_string(tmpchan, ast_channel_call_forward(orig), sizeof(tmpchan));
5908 ast_copy_string(forwarder, ast_channel_name(orig), sizeof(forwarder));
5909 if ((data = strchr(tmpchan, '/'))) {
5910 *data++ = '\0';
5911 type = tmpchan;
5912 } else {
5913 const char *forward_context;
5914 ast_channel_lock(orig);
5915 forward_context = pbx_builtin_getvar_helper(orig, "FORWARD_CONTEXT");
5916 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", ast_channel_call_forward(orig), S_OR(forward_context, ast_channel_context(orig)));
5917 ast_channel_unlock(orig);
5918 data = tmpchan;
5919 type = "Local";
5920 }
5921 if (!(new_chan = ast_request(type, cap, NULL, orig, data, &cause))) {
5922 ast_log(LOG_NOTICE, "Unable to create channel for call forward to '%s/%s' (cause = %d)\n", type, data, cause);
5923 handle_cause(cause, outstate);
5924 ast_hangup(orig);
5925 return NULL;
5926 }
5927
5928 /* Copy/inherit important information into new channel */
5929 if (oh) {
5930 if (oh->vars) {
5931 ast_channel_lock(new_chan);
5932 ast_set_variables(new_chan, oh->vars);
5933 ast_channel_unlock(new_chan);
5934 }
5935 if (oh->parent_channel) {
5936 call_forward_inherit(new_chan, oh->parent_channel, orig);
5937 }
5938 if (!ast_strlen_zero(oh->account)) {
5939 ast_channel_lock(new_chan);
5941 ast_channel_accountcode_set(new_chan, oh->account);
5942 ast_channel_peeraccount_set(new_chan, oh->account);
5944 ast_channel_unlock(new_chan);
5945 }
5946 } else if (caller) { /* no outgoing helper so use caller if available */
5947 call_forward_inherit(new_chan, caller, orig);
5948 }
5949
5950 ast_channel_lock_both(orig, new_chan);
5952 pbx_builtin_setvar_helper(new_chan, "FORWARDERNAME", forwarder);
5956 ast_channel_unlock(new_chan);
5957 ast_channel_unlock(orig);
5958
5959 /* call new channel */
5960 res = ast_call(new_chan, data, 0);
5961 if (timeout) {
5962 *timeout = res;
5963 }
5964 if (res) {
5965 ast_log(LOG_NOTICE, "Unable to call forward to channel %s/%s\n", type, (char *)data);
5966 ast_hangup(orig);
5967 ast_hangup(new_chan);
5968 return NULL;
5969 }
5970 ast_hangup(orig);
5971
5972 return new_chan;
5973}
5974
5975struct ast_channel *__ast_request_and_dial(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int timeout, int *outstate, const char *cid_num, const char *cid_name, struct outgoing_helper *oh)
5976{
5977 int dummy_outstate;
5978 int cause = 0;
5979 struct ast_channel *chan;
5980 int res = 0;
5981 int last_subclass = 0;
5983
5984 if (outstate)
5985 *outstate = 0;
5986 else
5987 outstate = &dummy_outstate; /* make outstate always a valid pointer */
5988
5989 chan = ast_request(type, cap, assignedids, requestor, addr, &cause);
5990 if (!chan) {
5991 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, addr);
5992 handle_cause(cause, outstate);
5993 return NULL;
5994 }
5995
5996 if (oh) {
5997 if (oh->vars) {
5998 ast_channel_lock(chan);
5999 ast_set_variables(chan, oh->vars);
6000 ast_channel_unlock(chan);
6001 }
6002 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name)) {
6003 /*
6004 * Use the oh values instead of the function parameters for the
6005 * outgoing CallerID.
6006 */
6007 cid_num = oh->cid_num;
6008 cid_name = oh->cid_name;
6009 }
6010 if (oh->parent_channel) {
6011 /* Safely inherit variables and datastores from the parent channel. */
6017 ast_channel_unlock(chan);
6018 }
6019 if (!ast_strlen_zero(oh->account)) {
6020 ast_channel_lock(chan);
6022 ast_channel_accountcode_set(chan, oh->account);
6023 ast_channel_peeraccount_set(chan, oh->account);
6025 ast_channel_unlock(chan);
6026 }
6027 }
6028
6029 /*
6030 * It seems strange to set the CallerID on an outgoing call leg
6031 * to whom we are calling, but this function's callers are doing
6032 * various Originate methods. This call leg goes to the local
6033 * user. Once the local user answers, the dialplan needs to be
6034 * able to access the CallerID from the CALLERID function as if
6035 * the local user had placed this call.
6036 */
6037 ast_set_callerid(chan, cid_num, cid_name, cid_num);
6038
6039 ast_channel_lock(chan);
6041 ast_channel_unlock(chan);
6043 if (cid_num) {
6044 connected.id.number.valid = 1;
6045 connected.id.number.str = (char *) cid_num;
6047 }
6048 if (cid_name) {
6049 connected.id.name.valid = 1;
6050 connected.id.name.str = (char *) cid_name;
6052 }
6054 if (requestor) {
6055 ast_channel_lock_both(chan, (struct ast_channel *) requestor);
6057 ast_channel_unlock(chan);
6058 ast_channel_unlock((struct ast_channel *) requestor);
6059 }
6060
6061 if (ast_call(chan, addr, 0)) { /* ast_call failed... */
6062 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, addr);
6063 } else {
6064 struct timeval start = ast_tvnow();
6065 res = 1; /* mark success in case chan->_state is already AST_STATE_UP */
6066 while (timeout && ast_channel_state(chan) != AST_STATE_UP) {
6067 struct ast_frame *f;
6068 int ms = ast_remaining_ms(start, timeout);
6069
6070 res = ast_waitfor(chan, ms);
6071 if (res == 0) { /* timeout, treat it like ringing */
6072 *outstate = AST_CONTROL_RINGING;
6073 break;
6074 }
6075 if (res < 0) /* error or done */
6076 break;
6078 if (!(chan = ast_call_forward(NULL, chan, NULL, cap, oh, outstate))) {
6079 return NULL;
6080 }
6081 continue;
6082 }
6083
6084 f = ast_read(chan);
6085 if (!f) {
6086 *outstate = AST_CONTROL_HANGUP;
6087 res = 0;
6088 break;
6089 }
6090 if (f->frametype == AST_FRAME_CONTROL) {
6091 switch (f->subclass.integer) {
6092 case AST_CONTROL_RINGING: /* record but keep going */
6093 *outstate = f->subclass.integer;
6094 break;
6095
6096 case AST_CONTROL_BUSY:
6097 *outstate = f->subclass.integer;
6098 timeout = 0;
6099 break;
6100
6102 *outstate = AST_CONTROL_CONGESTION;
6103 timeout = 0;
6104 break;
6105
6107 *outstate = f->subclass.integer;
6108 timeout = 0;
6109 break;
6110
6111 case AST_CONTROL_ANSWER:
6112 *outstate = f->subclass.integer;
6113 timeout = 0; /* trick to force exit from the while() */
6114 break;
6115
6118 break;
6119
6121 if (oh && oh->connect_on_early_media) {
6122 *outstate = f->subclass.integer;
6123 timeout = 0; /* trick to force exit from the while() */
6124 break;
6125 }
6126 /* Fallthrough */
6127 /* Ignore these */
6129 case AST_CONTROL_HOLD:
6130 case AST_CONTROL_UNHOLD:
6136 case AST_CONTROL_CC:
6137 case -1: /* Ignore -- just stopping indications */
6138 break;
6139
6140 default:
6141 ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass.integer);
6142 }
6143 last_subclass = f->subclass.integer;
6144 }
6145 ast_frfree(f);
6146 }
6147 }
6148
6149 /* Final fixups */
6150 if (oh) {
6151 if (!ast_strlen_zero(oh->context))
6153 if (!ast_strlen_zero(oh->exten))
6154 ast_channel_exten_set(chan, oh->exten);
6155 if (oh->priority)
6157 }
6158 if (ast_channel_state(chan) == AST_STATE_UP)
6159 *outstate = AST_CONTROL_ANSWER;
6160
6161 if (res <= 0) {
6162 ast_channel_lock(chan);
6163 if (AST_CONTROL_RINGING == last_subclass) {
6165 }
6166 ast_channel_unlock(chan);
6167 ast_hangup(chan);
6168 chan = NULL;
6169 }
6170 return chan;
6171}
6172
6173struct ast_channel *ast_request_and_dial(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int timeout, int *outstate, const char *cidnum, const char *cidname)
6174{
6175 return __ast_request_and_dial(type, cap, assignedids, requestor, addr, timeout, outstate, cidnum, cidname, NULL);
6176}
6177
6178static int set_security_requirements(const struct ast_channel *requestor, struct ast_channel *out)
6179{
6180 int ops[2][2] = {
6183 };
6184 int i;
6185 struct ast_channel *r = (struct ast_channel *) requestor; /* UGLY */
6186 struct ast_datastore *ds;
6187
6188 if (!requestor || !out) {
6189 return 0;
6190 }
6191
6194 struct ast_secure_call_store *encrypt = ds->data;
6195 ops[0][1] = encrypt->signaling;
6196 ops[1][1] = encrypt->media;
6197 } else {
6199 return 0;
6200 }
6202
6203 for (i = 0; i < 2; i++) {
6204 if (ops[i][1]) {
6205 if (ast_channel_setoption(out, ops[i][0], &ops[i][1], sizeof(ops[i][1]), 0)) {
6206 /* We require a security feature, but the channel won't provide it */
6207 return -1;
6208 }
6209 } else {
6210 /* We don't care if we can't clear the option on a channel that doesn't support it */
6211 ast_channel_setoption(out, ops[i][0], &ops[i][1], sizeof(ops[i][1]), 0);
6212 }
6213 }
6214
6215 return 0;
6216}
6217
6218static struct ast_channel *request_channel(const char *type, struct ast_format_cap *request_cap, struct ast_stream_topology *topology,
6219 const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int *cause)
6220{
6221 struct chanlist *chan;
6222 struct ast_channel *c = NULL;
6223 int res;
6224 int foo;
6225
6226 if (!cause)
6227 cause = &foo;
6228 *cause = AST_CAUSE_NOTDEFINED;
6229
6231 ast_log(LOG_WARNING, "Unable to lock technology backend list\n");
6232 return NULL;
6233 }
6234
6235 AST_RWLIST_TRAVERSE(&backends, chan, list) {
6236 if (strcasecmp(type, chan->tech->type)) {
6237 continue;
6238 }
6239
6240 break;
6241 }
6242
6244
6245 if (!chan) {
6246 ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
6247 *cause = AST_CAUSE_NOSUCHDRIVER;
6248 return NULL;
6249 }
6250
6251 /* Allow either format capabilities or stream topology to be provided and adapt */
6252 if (chan->tech->requester_with_stream_topology) {
6253 struct ast_stream_topology *tmp_converted_topology = NULL;
6254
6255 if (!topology && request_cap) {
6256 /* Turn the requested capabilities into a stream topology */
6257 topology = tmp_converted_topology = ast_stream_topology_create_from_format_cap(request_cap);
6258 }
6259
6260 c = chan->tech->requester_with_stream_topology(type, topology, assignedids, requestor, addr, cause);
6261
6262 ast_stream_topology_free(tmp_converted_topology);
6263 } else if (chan->tech->requester) {
6264 struct ast_format_cap *tmp_converted_cap = NULL;
6265 struct ast_format_cap *tmp_cap;
6266 RAII_VAR(struct ast_format *, tmp_fmt, NULL, ao2_cleanup);
6267 RAII_VAR(struct ast_format *, best_audio_fmt, NULL, ao2_cleanup);
6268 struct ast_format_cap *joint_cap;
6269
6270 if (!request_cap && topology) {
6271 /* Turn the request stream topology into capabilities */
6272 request_cap = tmp_converted_cap = ast_stream_topology_get_formats(topology);
6273 }
6274
6275 /* find the best audio format to use */
6277 if (!tmp_cap) {
6279 return NULL;
6280 }
6281
6283 if (!ast_format_cap_empty(tmp_cap)) {
6284 /* We have audio - is it possible to connect the various calls to each other?
6285 (Avoid this check for calls without audio, like text+video calls)
6286 */
6287 res = ast_translator_best_choice(tmp_cap, chan->tech->capabilities, &tmp_fmt, &best_audio_fmt);
6288 ao2_ref(tmp_cap, -1);
6289 if (res < 0) {
6290 struct ast_str *tech_codecs = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
6291 struct ast_str *request_codecs = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
6292
6293 ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %s) to %s\n", type,
6294 ast_format_cap_get_names(chan->tech->capabilities, &tech_codecs),
6295 ast_format_cap_get_names(request_cap, &request_codecs));
6297 ao2_cleanup(tmp_converted_cap);
6298 return NULL;
6299 }
6300 }
6301
6302 /* XXX Only the audio format calculated as being the best for translation
6303 * purposes is used for the request. This is because we don't have the ability
6304 * to signal to the initiator which one of their codecs that was offered is
6305 * the one that was selected, particularly in a chain of Local channels.
6306 */
6308 if (!joint_cap) {
6309 ao2_cleanup(tmp_converted_cap);
6310 return NULL;
6311 }
6314 if (best_audio_fmt) { /* text+video call? then, this is NULL */
6315 ast_format_cap_append(joint_cap, best_audio_fmt, 0);
6316 }
6317 ao2_cleanup(tmp_converted_cap);
6318
6319 c = chan->tech->requester(type, joint_cap, assignedids, requestor, addr, cause);
6320 ao2_ref(joint_cap, -1);
6321 }
6322
6323 if (!c) {
6324 return NULL;
6325 }
6326
6327 if (requestor) {
6328 ast_callid callid;
6329
6330 ast_channel_lock_both(c, (struct ast_channel *) requestor);
6331
6332 /* Set the newly created channel's callid to the same as the requestor. */
6333 callid = ast_channel_callid(requestor);
6334 if (callid) {
6335 ast_channel_callid_set(c, callid);
6336 }
6337
6339 ast_channel_unlock((struct ast_channel *) requestor);
6340 }
6341
6342 if (set_security_requirements(requestor, c)) {
6343 ast_log(LOG_WARNING, "Setting security requirements failed\n");
6344 ast_hangup(c);
6346 return NULL;
6347 }
6348
6349 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
6350 return c;
6351}
6352
6353struct ast_channel *ast_request(const char *type, struct ast_format_cap *request_cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int *cause)
6354{
6355 return request_channel(type, request_cap, NULL, assignedids, requestor, addr, cause);
6356}
6357
6358struct ast_channel *ast_request_with_stream_topology(const char *type, struct ast_stream_topology *topology, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int *cause)
6359{
6360 return request_channel(type, NULL, topology, assignedids, requestor, addr, cause);
6361}
6362
6363/*!
6364 * \internal
6365 * \brief Setup new channel accountcodes from the requestor channel after ast_request().
6366 * \since 13.0.0
6367 *
6368 * \param chan New channel to get accountcodes setup.
6369 * \param requestor Requesting channel to get accountcodes from.
6370 * \param relationship What the new channel was created for.
6371 * \param precious TRUE if pre-existing accountcodes on chan will not be overwritten.
6372 *
6373 * \pre The chan and requestor channels are already locked.
6374 */
6375static void channel_req_accountcodes(struct ast_channel *chan, const struct ast_channel *requestor, enum ast_channel_requestor_relationship relationship, int precious)
6376{
6377 /*
6378 * The primary reason for the existence of this function is
6379 * so local channels can propagate accountcodes to the ;2
6380 * channel before ast_call().
6381 *
6382 * The secondary reason is to propagate the CHANNEL(peeraccount)
6383 * value set before Dial, FollowMe, and Queue while maintaining
6384 * the historic straight across accountcode propagation as a
6385 * fallback.
6386 */
6387 switch (relationship) {
6389 /* Crossover the requestor's accountcode and peeraccount */
6390 if (!precious || ast_strlen_zero(ast_channel_accountcode(chan))) {
6391 /*
6392 * The newly created channel does not have an accountcode
6393 * or we don't care.
6394 */
6395 if (!ast_strlen_zero(ast_channel_peeraccount(requestor))) {
6396 /*
6397 * Set it to the requestor's peeraccount. This allows the
6398 * dialplan to indicate the accountcode to use when dialing
6399 * by setting CHANNEL(peeraccount).
6400 */
6401 ast_channel_accountcode_set(chan, ast_channel_peeraccount(requestor));
6402 } else if (!precious
6403 && !ast_strlen_zero(ast_channel_accountcode(requestor))) {
6404 /*
6405 * Fallback to the historic propagation and set it to the
6406 * requestor's accountcode.
6407 */
6408 ast_channel_accountcode_set(chan, ast_channel_accountcode(requestor));
6409 }
6410 }
6411 if (!ast_strlen_zero(ast_channel_accountcode(requestor))) {
6412 ast_channel_peeraccount_set(chan, ast_channel_accountcode(requestor));
6413 }
6414 break;
6416 /* Pass the requestor's accountcode and peeraccount straight. */
6417 if (!precious || ast_strlen_zero(ast_channel_accountcode(chan))) {
6418 /*
6419 * The newly created channel does not have an accountcode
6420 * or we don't care.
6421 */
6422 if (!ast_strlen_zero(ast_channel_accountcode(requestor))) {
6423 ast_channel_accountcode_set(chan, ast_channel_accountcode(requestor));
6424 }
6425 }
6426 if (!ast_strlen_zero(ast_channel_peeraccount(requestor))) {
6427 ast_channel_peeraccount_set(chan, ast_channel_peeraccount(requestor));
6428 }
6429 break;
6430 }
6431}
6432
6433void ast_channel_req_accountcodes(struct ast_channel *chan, const struct ast_channel *requestor, enum ast_channel_requestor_relationship relationship)
6434{
6435 channel_req_accountcodes(chan, requestor, relationship, 0);
6436}
6437
6438void ast_channel_req_accountcodes_precious(struct ast_channel *chan, const struct ast_channel *requestor, enum ast_channel_requestor_relationship relationship)
6439{
6440 channel_req_accountcodes(chan, requestor, relationship, 1);
6441}
6442
6443int ast_pre_call(struct ast_channel *chan, const char *sub_args)
6444{
6445 int (*pre_call)(struct ast_channel *chan, const char *sub_args);
6446
6447 ast_channel_lock(chan);
6448 pre_call = ast_channel_tech(chan)->pre_call;
6449 if (pre_call) {
6450 int res;
6451
6452 res = pre_call(chan, sub_args);
6453 ast_channel_unlock(chan);
6454 return res;
6455 }
6456 ast_channel_unlock(chan);
6457 return ast_app_exec_sub(NULL, chan, sub_args, 0);
6458}
6459
6460int ast_call(struct ast_channel *chan, const char *addr, int timeout)
6461{
6462 /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
6463 If the remote end does not answer within the timeout, then do NOT hang up, but
6464 return anyway. */
6465 int res = -1;
6466 /* Stop if we're a zombie or need a soft hangup */
6467 ast_channel_lock(chan);
6469 if (ast_channel_tech(chan)->call)
6470 res = ast_channel_tech(chan)->call(chan, addr, timeout);
6472 }
6473 ast_channel_unlock(chan);
6474 return res;
6475}
6476
6477/*!
6478 \brief Transfer a call to dest, if the channel supports transfer
6479
6480 Called by:
6481 \arg app_transfer
6482 \arg the manager interface
6483*/
6484int ast_transfer(struct ast_channel *chan, char *dest)
6485{
6486 int protocol;
6487 return ast_transfer_protocol(chan, dest, &protocol);
6488}
6489
6490/*!
6491 \brief Transfer a call to dest, if the channel supports transfer
6492
6493 Called by:
6494 \arg app_transfer
6495 \arg the manager interface
6496*/
6497int ast_transfer_protocol(struct ast_channel *chan, char *dest, int *protocol)
6498{
6499 int res = -1;
6500
6501 if (protocol) {
6502 *protocol = 0;
6503 }
6504
6505 /* Stop if we're a zombie or need a soft hangup */
6506 ast_channel_lock(chan);
6508 if (ast_channel_tech(chan)->transfer) {
6509 res = ast_channel_tech(chan)->transfer(chan, dest);
6510 if (!res)
6511 res = 1;
6512 } else
6513 res = 0;
6514 }
6515 ast_channel_unlock(chan);
6516
6517 if (res <= 0) {
6518 return res;
6519 }
6520
6521 for (;;) {
6522 struct ast_frame *fr;
6523
6524 res = ast_waitfor(chan, -1);
6525
6526 if (res < 0 || !(fr = ast_read(chan))) {
6527 res = -1;
6528 break;
6529 }
6530
6533
6534 if (*message == AST_TRANSFER_SUCCESS) {
6535 res = 1;
6536 } else {
6537 res = -1;
6538 /* Message can contain a protocol specific code
6539 AST_TRANSFER_SUCCESS indicates success
6540 Else, failure. Protocol will be set to the failure reason.
6541 SIP example, 0 is success, else error code 3xx-6xx */
6542 if (protocol) {
6543 *protocol = *message;
6544 }
6545 }
6546
6547 ast_frfree(fr);
6548 break;
6549 }
6550
6551 ast_frfree(fr);
6552 }
6553
6554 return res;
6555}
6556
6557int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
6558{
6559 return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
6560}
6561
6562int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
6563{
6564 int pos = 0; /* index in the buffer where we accumulate digits */
6565 int to = ftimeout;
6566
6567 struct ast_silence_generator *silgen = NULL;
6568
6569 /* Stop if we're a zombie or need a soft hangup */
6571 return -1;
6572 if (!len)
6573 return -1;
6574 for (;;) {
6575 int d;
6576 if (ast_channel_stream(c)) {
6577 d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
6579 if (!silgen && ast_opt_transmit_silence)
6581 usleep(1000);
6582 if (!d)
6583 d = ast_waitfordigit_full(c, to, NULL, audiofd, ctrlfd);
6584 } else {
6585 if (!silgen && ast_opt_transmit_silence)
6587 d = ast_waitfordigit_full(c, to, NULL, audiofd, ctrlfd);
6588 }
6589 if (d < 0) {
6591 return AST_GETDATA_FAILED;
6592 }
6593 if (d == 0) {
6594 s[pos] = '\0';
6596 return AST_GETDATA_TIMEOUT;
6597 }
6598 if (d == 1) {
6599 s[pos] = '\0';
6602 }
6603 if (strchr(enders, d) && (pos == 0)) {
6604 s[pos] = '\0';
6607 }
6608 if (!strchr(enders, d)) {
6609 s[pos++] = d;
6610 }
6611 if (strchr(enders, d) || (pos >= len)) {
6612 s[pos] = '\0';
6614 return AST_GETDATA_COMPLETE;
6615 }
6616 to = timeout;
6617 }
6618 /* Never reached */
6619 return 0;
6620}
6621
6623{
6624 return (ast_channel_tech(chan)->send_html) ? 1 : 0;
6625}
6626
6627int ast_channel_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen)
6628{
6629 if (ast_channel_tech(chan)->send_html)
6630 return ast_channel_tech(chan)->send_html(chan, subclass, data, datalen);
6631 return -1;
6632}
6633
6634int ast_channel_sendurl(struct ast_channel *chan, const char *url)
6635{
6636 return ast_channel_sendhtml(chan, AST_HTML_URL, url, strlen(url) + 1);
6637}
6638
6639/*! \brief Set up translation from one channel to another */
6641{
6642 struct ast_format_cap *src_cap;
6643 struct ast_format_cap *dst_cap;
6644 RAII_VAR(struct ast_format *, best_src_fmt, NULL, ao2_cleanup);
6645 RAII_VAR(struct ast_format *, best_dst_fmt, NULL, ao2_cleanup);
6646 int no_path;
6647
6648 /*
6649 * We cannot short circuit this code because it is possible to ask
6650 * to make compatible two channels that are "compatible" because
6651 * they already have translation paths setup but together make for
6652 * a sub-optimal path. e.g., The From channel has g722 -> ulaw
6653 * and the To channel has ulaw -> g722. They are "compatible" but
6654 * together the translations are unnecessary and the audio loses
6655 * fidelity in the process.
6656 */
6657
6658 ast_channel_lock_both(from, to);
6659
6660 src_cap = ast_channel_nativeformats(from); /* shallow copy, do not destroy */
6661 dst_cap = ast_channel_nativeformats(to); /* shallow copy, do not destroy */
6662
6663 /* If there's no audio in this call, don't bother with trying to find a translation path */
6667 ast_channel_unlock(from);
6668 return 0;
6669 }
6670
6671 no_path = ast_translator_best_choice(dst_cap, src_cap, &best_dst_fmt, &best_src_fmt);
6672
6674 ast_channel_unlock(from);
6675
6676 if (no_path) {
6677 ast_log(LOG_WARNING, "No path to translate from %s to %s\n",
6679 return -1;
6680 }
6681
6682 /* if the best path is not 'pass through', then
6683 * transcoding is needed; if desired, force transcode path
6684 * to use SLINEAR between channels, but only if there is
6685 * no direct conversion available. If generic PLC is
6686 * desired, then transcoding via SLINEAR is a requirement
6687 * even if the formats are the same.
6688 */
6690 || (ast_format_cmp(best_dst_fmt, best_src_fmt) == AST_FORMAT_CMP_NOT_EQUAL
6692
6693 int use_slin = (ast_format_cache_is_slinear(best_src_fmt)
6694 || ast_format_cache_is_slinear(best_dst_fmt))
6696
6697 if (use_slin || ast_translate_path_steps(best_dst_fmt, best_src_fmt) != 1) {
6698 int best_sample_rate = (ast_format_get_sample_rate(best_src_fmt) > ast_format_get_sample_rate(best_dst_fmt)) ?
6699 ast_format_get_sample_rate(best_src_fmt) : ast_format_get_sample_rate(best_dst_fmt);
6700
6701 /* pick the best signed linear format based upon what preserves the sample rate the best. */
6702 ao2_replace(best_src_fmt, ast_format_cache_get_slin_by_rate(best_sample_rate));
6703 }
6704 }
6705
6706 if (ast_set_read_format(from, best_src_fmt)) {
6707 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %s\n",
6708 ast_channel_name(from), ast_format_get_name(best_src_fmt));
6709 return -1;
6710 }
6711 if (ast_set_write_format(to, best_src_fmt)) {
6712 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %s\n",
6713 ast_channel_name(to), ast_format_get_name(best_src_fmt));
6714 return -1;
6715 }
6716 return 0;
6717}
6718
6720{
6721 /*
6722 * Set up translation from the peer to the chan first in case we
6723 * need to hear any in-band tones and the other direction fails.
6724 */
6725 if (ast_channel_make_compatible_helper(peer, chan)) {
6726 return -1;
6727 }
6728
6729 /* Set up translation from the chan to the peer */
6730 if (ast_channel_make_compatible_helper(chan, peer)) {
6731 return -1;
6732 }
6733
6734 return 0;
6735}
6736
6737/*! \brief this function simply changes the name of the channel and issues a manager_event
6738 * with out unlinking and linking the channel from the ao2_container. This should
6739 * only be used when the channel has already been unlinked from the ao2_container.
6740 */
6741static void __ast_change_name_nolink(struct ast_channel *chan, const char *newname)
6742{
6743 /*** DOCUMENTATION
6744 <managerEvent language="en_US" name="Rename">
6745 <managerEventInstance class="EVENT_FLAG_CALL">
6746 <synopsis>Raised when the name of a channel is changed.</synopsis>
6747 </managerEventInstance>
6748 </managerEvent>
6749 ***/
6750 ast_manager_event(chan, EVENT_FLAG_CALL, "Rename",
6751 "Channel: %s\r\n"
6752 "Newname: %s\r\n"
6753 "Uniqueid: %s\r\n",
6754 ast_channel_name(chan), newname, ast_channel_uniqueid(chan));
6755 ast_channel_name_set(chan, newname);
6756}
6757
6758void ast_change_name(struct ast_channel *chan, const char *newname)
6759{
6760 /* We must re-link, as the hash value will change here. */
6762 ast_channel_lock(chan);
6763 ao2_unlink(channels, chan);
6764 __ast_change_name_nolink(chan, newname);
6765 ao2_link(channels, chan);
6766 ast_channel_unlock(chan);
6768}
6769
6770void ast_channel_inherit_variables(const struct ast_channel *parent, struct ast_channel *child)
6771{
6772 struct ast_var_t *current;
6773 struct ast_var_t *newvar;
6774 const char *varname;
6775 int vartype;
6776
6778 varname = ast_var_full_name(current);
6779 if (!varname) {
6780 continue;
6781 }
6782
6783 vartype = 0;
6784 if (varname[0] == '_') {
6785 vartype = 1;
6786 if (varname[1] == '_') {
6787 vartype = 2;
6788 }
6789 }
6790
6791 switch (vartype) {
6792 case 1:
6793 newvar = ast_var_assign(&varname[1], ast_var_value(current));
6794 break;
6795 case 2:
6796 newvar = ast_var_assign(varname, ast_var_value(current));
6797 break;
6798 default:
6799 continue;
6800 }
6801 if (newvar) {
6802 ast_debug(1, "Inheriting variable %s from %s to %s.\n",
6803 ast_var_full_name(newvar), ast_channel_name(parent),
6804 ast_channel_name(child));
6807 ast_var_value(newvar));
6808 }
6809 }
6810}
6811
6812/*!
6813 \brief Clone channel variables from 'clone' channel into 'original' channel
6814
6815 All variables except those related to app_groupcount are cloned.
6816 Variables are actually _removed_ from 'clone' channel, presumably
6817 because it will subsequently be destroyed.
6818
6819 \note Assumes locks will be in place on both channels when called.
6820*/
6821static void clone_variables(struct ast_channel *original, struct ast_channel *clonechan)
6822{
6823 struct ast_var_t *current, *newvar;
6824 /* Append variables from clone channel into original channel */
6825 /* XXX Is this always correct? We have to in order to keep MACROS working XXX */
6827
6828 /* then, dup the varshead list into the clone */
6829
6831 newvar = ast_var_assign(current->name, current->value);
6832 if (newvar)
6834 }
6835}
6836
6837
6838void ast_channel_name_to_dial_string(char *channel_name)
6839{
6840 char *dash;
6841
6842 /* Truncate after the dash */
6843 dash = strrchr(channel_name, '-');
6844 if (dash) {
6845 *dash = '\0';
6846 }
6847}
6848
6849/*!
6850 * \brief Masquerade a channel
6851 *
6852 * \note Assumes _NO_ channels and _NO_ channel pvt's are locked. If a channel is locked while calling
6853 * this function, it invalidates our channel container locking order. All channels
6854 * must be unlocked before it is permissible to lock the channels' ao2 container.
6855 */
6856static void channel_do_masquerade(struct ast_channel *original, struct ast_channel *clonechan)
6857{
6858 int x;
6859 int origstate;
6860 unsigned int orig_disablestatecache;
6861 unsigned int clone_disablestatecache;
6862 int generator_fd;
6863 int visible_indication;
6864 int clone_hold_state;
6865 int moh_is_playing;
6866 struct ast_frame *current;
6867 const struct ast_channel_tech *t;
6868 void *t_pvt;
6869 union {
6871 struct ast_party_dialed dialed;
6872 struct ast_party_caller caller;
6874 struct ast_party_redirecting redirecting;
6875 } exchange;
6876 struct ast_channel *bridged;
6877 struct ast_format *rformat;
6878 struct ast_format *wformat;
6879 struct ast_format *tmp_format;
6880 struct ast_format_cap *tmp_cap;
6881 char tmp_name[AST_CHANNEL_NAME];
6882 char clone_sending_dtmf_digit;
6883 struct timeval clone_sending_dtmf_tv;
6884
6885 /* XXX This operation is a bit odd. We're essentially putting the guts of
6886 * the clone channel into the original channel. Start by killing off the
6887 * original channel's backend. While the features are nice, which is the
6888 * reason we're keeping it, it's still awesomely weird. XXX */
6889
6890 /* Indicate to each channel that a masquerade is about to begin. */
6891 x = 1;
6892 ast_indicate_data(original, AST_CONTROL_MASQUERADE_NOTIFY, &x, sizeof(x));
6893 ast_indicate_data(clonechan, AST_CONTROL_MASQUERADE_NOTIFY, &x, sizeof(x));
6894
6895 /*
6896 * The container lock is necessary for proper locking order
6897 * because the channels must be unlinked to change their
6898 * names.
6899 *
6900 * The original and clonechan locks must be held while the
6901 * channel contents are shuffled around for the masquerade.
6902 *
6903 * The masq and masqr pointers need to be left alone until the masquerade
6904 * has restabilized the channels to hold off ast_hangup() and until
6905 * AST_FLAG_ZOMBIE can be set on the clonechan.
6906 */
6908
6909 /* Bump the refs to ensure that they won't dissapear on us. */
6910 ast_channel_ref(original);
6911 ast_channel_ref(clonechan);
6912
6913 /* unlink from channels container as name (which is the hash value) will change */
6914 ao2_unlink(channels, original);
6915 ao2_unlink(channels, clonechan);
6916
6917 moh_is_playing = ast_test_flag(ast_channel_flags(original), AST_FLAG_MOH);
6918 if (moh_is_playing) {
6919 /* Stop MOH on the old original channel. */
6920 ast_moh_stop(original);
6921 }
6922
6923 /*
6924 * Stop any visible indication on the original channel so we can
6925 * transfer it to the clonechan taking the original's place.
6926 */
6927 ast_channel_lock(original);
6928 visible_indication = ast_channel_visible_indication(original);
6929 ast_channel_unlock(original);
6930 ast_indicate(original, -1);
6931
6932 /* Start the masquerade channel contents rearrangement. */
6933 ast_channel_lock_both(original, clonechan);
6934
6935 ast_debug(1, "Actually Masquerading %s(%u) into the structure of %s(%u)\n",
6936 ast_channel_name(clonechan), ast_channel_state(clonechan),
6937 ast_channel_name(original), ast_channel_state(original));
6938
6939 /* When all is said and done force new snapshot segments so they are
6940 * up to date.
6941 */
6944
6945 /*
6946 * Remember the original read/write formats. We turn off any
6947 * translation on either one
6948 */
6949 rformat = ao2_bump(ast_channel_readformat(original));
6950 wformat = ao2_bump(ast_channel_writeformat(original));
6951 free_translation(clonechan);
6952 free_translation(original);
6953
6954 clone_hold_state = ast_channel_hold_state(clonechan);
6955
6956 /* Save the current DTMF digit being sent if any. */
6957 clone_sending_dtmf_digit = ast_channel_sending_dtmf_digit(clonechan);
6958 clone_sending_dtmf_tv = ast_channel_sending_dtmf_tv(clonechan);
6959
6960 /* Swap uniqueid's of the channels. This needs to happen before channel renames,
6961 * so rename events get the proper id's.
6962 */
6964
6965 /* Make sure the Stasis topic on the channel is updated appropriately */
6966 ast_channel_internal_swap_topics(clonechan, original);
6967
6968 /* Swap endpoint forward so channel created with endpoint exchanges its state
6969 * with other channel for proper endpoint cleanup.
6970 */
6971 ast_channel_internal_swap_endpoint_forward(clonechan, original);
6972
6973 /* The old snapshots need to follow the channels so the snapshot update is correct */
6974 ast_channel_internal_swap_snapshots(clonechan, original);
6975
6976 /* Swap channel names. This uses ast_channel_name_set directly, so we
6977 * don't get any spurious rename events.
6978 */
6979 ast_copy_string(tmp_name, ast_channel_name(clonechan), sizeof(tmp_name));
6980 ast_channel_name_set(clonechan, ast_channel_name(original));
6981 ast_channel_name_set(original, tmp_name);
6982
6983 /* Swap the technologies */
6984 t = ast_channel_tech(original);
6985 ast_channel_tech_set(original, ast_channel_tech(clonechan));
6986 ast_channel_tech_set(clonechan, t);
6987
6988 t_pvt = ast_channel_tech_pvt(original);
6989 ast_channel_tech_pvt_set(original, ast_channel_tech_pvt(clonechan));
6990 ast_channel_tech_pvt_set(clonechan, t_pvt);
6991
6992 /* Swap the alertpipes */
6993 ast_channel_internal_alertpipe_swap(original, clonechan);
6994
6995 /*
6996 * Swap the readq's. The end result should be this:
6997 *
6998 * 1) All frames should be on the new (original) channel.
6999 * 2) Any frames that were already on the new channel before this
7000 * masquerade need to be at the end of the readq, after all of the
7001 * frames on the old (clone) channel.
7002 * 3) The alertpipe needs to get poked for every frame that was already
7003 * on the new channel, since we are now using the alert pipe from the
7004 * old (clone) channel.
7005 */
7006 {
7007 AST_LIST_HEAD_NOLOCK(, ast_frame) tmp_readq;
7008
7009 AST_LIST_HEAD_INIT_NOLOCK(&tmp_readq);
7010 AST_LIST_APPEND_LIST(&tmp_readq, ast_channel_readq(original), frame_list);
7012
7013 while ((current = AST_LIST_REMOVE_HEAD(&tmp_readq, frame_list))) {
7015 if (ast_channel_alert_write(original)) {
7016 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
7017 }
7018 }
7019 }
7020
7021 /* Swap the raw formats */
7022 tmp_format = ao2_bump(ast_channel_rawreadformat(original));
7024 ast_channel_set_rawreadformat(clonechan, tmp_format);
7025 ao2_cleanup(tmp_format);
7026
7027 tmp_format = ao2_bump(ast_channel_rawwriteformat(original));
7029 ast_channel_set_rawwriteformat(clonechan, tmp_format);
7030 ao2_cleanup(tmp_format);
7031
7033
7034 /* And of course, so does our current state. Note we need not
7035 call ast_setstate since the event manager doesn't really consider
7036 these separate. We do this early so that the clone has the proper
7037 state of the original channel. */
7038 origstate = ast_channel_state(original);
7039 ast_channel_state_set(original, ast_channel_state(clonechan));
7040 ast_channel_state_set(clonechan, origstate);
7041
7042 /* And the swap the cachable state too. Otherwise we'd start caching
7043 * Local channels and ignoring real ones. */
7044 orig_disablestatecache = ast_test_flag(ast_channel_flags(original), AST_FLAG_DISABLE_DEVSTATE_CACHE);
7045 clone_disablestatecache = ast_test_flag(ast_channel_flags(clonechan), AST_FLAG_DISABLE_DEVSTATE_CACHE);
7046 if (orig_disablestatecache != clone_disablestatecache) {
7047 if (orig_disablestatecache) {
7050 } else {
7053 }
7054 }
7055
7056 /* Keep the same language. */
7057 ast_channel_language_set(original, ast_channel_language(clonechan));
7058
7059 /* Keep the same parkinglot. */
7060 ast_channel_parkinglot_set(original, ast_channel_parkinglot(clonechan));
7061
7062 /* Clear all existing file descriptors but retain the generator */
7063 generator_fd = ast_channel_fd(original, AST_GENERATOR_FD);
7065 ast_channel_set_fd(original, AST_GENERATOR_FD, generator_fd);
7066
7067 /* Copy all file descriptors present on clonechan to original, skipping generator */
7068 for (x = 0; x < ast_channel_fd_count(clonechan); x++) {
7069 if (x != AST_GENERATOR_FD)
7070 ast_channel_set_fd(original, x, ast_channel_fd(clonechan, x));
7071 }
7072
7073 ast_app_group_update(clonechan, original);
7074
7075 /* Swap hangup handlers. */
7076 exchange.handlers = *ast_channel_hangup_handlers(original);
7078 *ast_channel_hangup_handlers(clonechan) = exchange.handlers;
7079
7080 /* Call fixup handlers for the clone chan */
7081 if (AST_LIST_FIRST(ast_channel_datastores(clonechan))) {
7082 struct ast_datastore *ds;
7083 /* We use a safe traversal here because some fixup routines actually
7084 * remove the datastore from the list and free them.
7085 */
7087 if (ds->info->chan_fixup) {
7088 ds->info->chan_fixup(ds->data, clonechan, original);
7089 }
7090 }
7092 }
7093
7094 /* Call breakdown handlers for the original chan */
7095 if (AST_LIST_FIRST(ast_channel_datastores(original))) {
7096 struct ast_datastore *ds;
7097 /* We use a safe traversal here because some breakdown routines may
7098 * remove the datastore from the list and free them.
7099 */
7101 if (ds->info->chan_breakdown) {
7102 ds->info->chan_breakdown(ds->data, clonechan, original);
7103 }
7104 }
7106 }
7107
7108 /* Move data stores over */
7109 if (AST_LIST_FIRST(ast_channel_datastores(clonechan))) {
7111 }
7112
7113 /* Move framehooks over */
7114 ast_framehook_list_fixup(clonechan, original);
7115
7116 /* Move audiohooks over */
7117 ast_audiohook_move_all(clonechan, original);
7118
7119 ast_autochan_new_channel(clonechan, original);
7120
7121 clone_variables(original, clonechan);
7122 /* Presense of ADSI capable CPE follows clone */
7123 ast_channel_adsicpe_set(original, ast_channel_adsicpe(clonechan));
7124 /* Bridge remains the same */
7125 /* CDR fields remain the same */
7126 /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */
7127 /* Application and data remain the same */
7128 /* Clone exception becomes real one, as with fdno */
7130 ast_channel_fdno_set(original, ast_channel_fdno(clonechan));
7131 /* Schedule context remains the same */
7132 /* Stream stuff stays the same */
7133 /* Keep the original state. The fixup code will need to work with it most likely */
7134
7135 /*
7136 * Just swap the whole structures, nevermind the allocations,
7137 * they'll work themselves out.
7138 */
7139 exchange.dialed = *ast_channel_dialed(original);
7140 ast_channel_dialed_set(original, ast_channel_dialed(clonechan));
7141 ast_channel_dialed_set(clonechan, &exchange.dialed);
7142
7143 /* Reset any earlier private caller id representations */
7144 ast_party_id_reset(&ast_channel_caller(original)->priv);
7145 ast_party_id_reset(&ast_channel_caller(clonechan)->priv);
7146
7147 exchange.caller = *ast_channel_caller(original);
7148 ast_channel_caller_set(original, ast_channel_caller(clonechan));
7149 ast_channel_caller_set(clonechan, &exchange.caller);
7150
7151 /* Reset any earlier private connected id representations */
7152 ast_party_id_reset(&ast_channel_connected(original)->priv);
7153 ast_party_id_reset(&ast_channel_connected(clonechan)->priv);
7154
7155 exchange.connected = *ast_channel_connected(original);
7157 ast_channel_connected_set(clonechan, &exchange.connected);
7158
7159 /* Reset any earlier private redirecting orig, from or to representations */
7160 ast_party_id_reset(&ast_channel_redirecting(original)->priv_orig);
7161 ast_party_id_reset(&ast_channel_redirecting(clonechan)->priv_orig);
7162 ast_party_id_reset(&ast_channel_redirecting(original)->priv_from);
7163 ast_party_id_reset(&ast_channel_redirecting(clonechan)->priv_from);
7164 ast_party_id_reset(&ast_channel_redirecting(original)->priv_to);
7165 ast_party_id_reset(&ast_channel_redirecting(clonechan)->priv_to);
7166
7167 exchange.redirecting = *ast_channel_redirecting(original);
7169 ast_channel_redirecting_set(clonechan, &exchange.redirecting);
7170
7172
7173 /* Restore original timing file descriptor */
7175
7176 /* Our native formats are different now */
7178 if (tmp_cap) {
7180 ast_channel_nativeformats_set(original, tmp_cap);
7181 ao2_ref(tmp_cap, -1);
7182 }
7183
7184 /* Context, extension, priority, app data, jump table, remain the same */
7185 /* pvt switches. pbx stays the same, as does next */
7186
7187 /* Set the write format */
7188 ast_set_write_format(original, wformat);
7189
7190 /* Set the read format */
7191 ast_set_read_format(original, rformat);
7192
7193 /* Copy the music class */
7194 ast_channel_musicclass_set(original, ast_channel_musicclass(clonechan));
7195
7196 /* copy over accuntcode and set peeraccount across the bridge */
7197 ast_channel_accountcode_set(original, S_OR(ast_channel_accountcode(clonechan), ""));
7198
7199 ast_debug(1, "Putting channel %s in %s/%s formats\n", ast_channel_name(original),
7200 ast_format_get_name(wformat), ast_format_get_name(rformat));
7201
7202 /* Fixup the original clonechan's physical side */
7203 if (ast_channel_tech(original)->fixup && ast_channel_tech(original)->fixup(clonechan, original)) {
7204 ast_log(LOG_WARNING, "Channel type '%s' could not fixup channel %s, strange things may happen. (clonechan)\n",
7205 ast_channel_tech(original)->type, ast_channel_name(original));
7206 }
7207
7208 /* Fixup the original original's physical side */
7209 if (ast_channel_tech(clonechan)->fixup && ast_channel_tech(clonechan)->fixup(original, clonechan)) {
7210 ast_log(LOG_WARNING, "Channel type '%s' could not fixup channel %s, strange things may happen. (original)\n",
7211 ast_channel_tech(clonechan)->type, ast_channel_name(clonechan));
7212 }
7213
7214 ast_channel_internal_swap_stream_topology(original, clonechan);
7215
7216 /*
7217 * Now, at this point, the "clone" channel is totally F'd up.
7218 * We mark it as a zombie so nothing tries to touch it.
7219 *
7220 * This must be done before we unlock clonechan to prevent
7221 * setting up another masquerade on the clonechan.
7222 */
7224 ast_queue_frame(clonechan, &ast_null_frame);
7225
7226 ast_channel_unlock(original);
7227 ast_channel_unlock(clonechan);
7228
7229 /*
7230 * Indicate to each channel that a masquerade is complete.
7231 *
7232 * We can still do this to clonechan even though it is a
7233 * zombie because ast_indicate_data() will explicitly pass
7234 * this control and ast_hangup() is held off until the
7235 * ast_channel_masq() and ast_channel_masqr() pointers are
7236 * cleared.
7237 */
7238 x = 0;
7239 ast_indicate_data(original, AST_CONTROL_MASQUERADE_NOTIFY, &x, sizeof(x));
7240 ast_indicate_data(clonechan, AST_CONTROL_MASQUERADE_NOTIFY, &x, sizeof(x));
7241
7243
7244 if (clone_hold_state == AST_CONTROL_HOLD) {
7245 ast_debug(1, "Channel %s simulating UNHOLD for masquerade.\n",
7246 ast_channel_name(original));
7248 }
7249 if (clone_sending_dtmf_digit) {
7250 /*
7251 * The clonechan was sending a DTMF digit that was not completed
7252 * before the masquerade.
7253 */
7254 ast_channel_end_dtmf(original, clone_sending_dtmf_digit, clone_sending_dtmf_tv,
7255 "masquerade");
7256 }
7257
7258 /*
7259 * If an indication is currently playing, maintain it on the
7260 * channel that is taking the place of original.
7261 *
7262 * This is needed because the masquerade is swapping out the
7263 * internals of the channel, and the new channel private data
7264 * needs to be made aware of the current visible indication
7265 * (RINGING, CONGESTION, etc.)
7266 */
7267 if (visible_indication) {
7268 if (visible_indication == AST_CONTROL_HOLD) {
7269 const char *latest_musicclass;
7270 int len;
7271
7272 ast_channel_lock(original);
7273 latest_musicclass = ast_strdupa(ast_channel_latest_musicclass(original));
7274 ast_channel_unlock(original);
7275 if (ast_strlen_zero(latest_musicclass)) {
7276 latest_musicclass = NULL;
7277 len = 0;
7278 } else {
7279 len = strlen(latest_musicclass) + 1;
7280 }
7281 ast_indicate_data(original, visible_indication, latest_musicclass, len);
7282 } else {
7283 ast_indicate(original, visible_indication);
7284 }
7285 }
7286
7287 /*
7288 * If MOH was playing on the original channel then it needs to be
7289 * maintained on the channel that is replacing it.
7290 */
7291 if (moh_is_playing) {
7292 /* Start MOH on the new original channel. */
7293 ast_moh_start(original, NULL, NULL);
7294 }
7295
7296 ast_channel_lock(original);
7297
7298 /* Signal any blocker */
7300 pthread_kill(ast_channel_blocker(original), SIGURG);
7301 }
7302
7303 ast_debug(1, "Done Masquerading %s (%u)\n", ast_channel_name(original), ast_channel_state(original));
7304 ast_channel_unlock(original);
7305
7306 if ((bridged = ast_channel_bridge_peer(original))) {
7308 ast_channel_unref(bridged);
7309 }
7311
7312 /* Now that the operation is complete, we can clear the masq
7313 * and masqr fields of both channels.
7314 */
7315 ast_channel_lock_both(original, clonechan);
7316 ast_channel_masq_set(original, NULL);
7317 ast_channel_masqr_set(clonechan, NULL);
7318 ast_channel_unlock(original);
7319 ast_channel_unlock(clonechan);
7320
7321 ao2_link(channels, clonechan);
7322 ao2_link(channels, original);
7324
7325 /* Release our held safety references. */
7326 ast_channel_unref(original);
7327 ast_channel_unref(clonechan);
7328
7329 ao2_cleanup(rformat);
7330 ao2_cleanup(wformat);
7331}
7332
7333void ast_set_callerid(struct ast_channel *chan, const char *cid_num, const char *cid_name, const char *cid_ani)
7334{
7335 ast_channel_lock(chan);
7336
7337 if (cid_num) {
7338 ast_channel_caller(chan)->id.number.valid = 1;
7339 ast_free(ast_channel_caller(chan)->id.number.str);
7340 ast_channel_caller(chan)->id.number.str = ast_strdup(cid_num);
7341 }
7342 if (cid_name) {
7343 ast_channel_caller(chan)->id.name.valid = 1;
7344 ast_free(ast_channel_caller(chan)->id.name.str);
7345 ast_channel_caller(chan)->id.name.str = ast_strdup(cid_name);
7346 }
7347 if (cid_ani) {
7349 ast_free(ast_channel_caller(chan)->ani.number.str);
7350 ast_channel_caller(chan)->ani.number.str = ast_strdup(cid_ani);
7351 }
7352
7354
7355 ast_channel_unlock(chan);
7356}
7357
7358void ast_channel_set_caller(struct ast_channel *chan, const struct ast_party_caller *caller, const struct ast_set_party_caller *update)
7359{
7360 if (ast_channel_caller(chan) == caller) {
7361 /* Don't set to self */
7362 return;
7363 }
7364
7365 ast_channel_lock(chan);
7368 ast_channel_unlock(chan);
7369}
7370
7371void ast_channel_set_caller_event(struct ast_channel *chan, const struct ast_party_caller *caller, const struct ast_set_party_caller *update)
7372{
7373 if (ast_channel_caller(chan) == caller) {
7374 /* Don't set to self */
7375 return;
7376 }
7377
7378 ast_channel_lock(chan);
7382 ast_channel_unlock(chan);
7383}
7384
7386{
7387 int oldstate = ast_channel_state(chan);
7388 char name[AST_CHANNEL_NAME], *dashptr;
7389
7390 if (oldstate == state)
7391 return 0;
7392
7393 ast_copy_string(name, ast_channel_name(chan), sizeof(name));
7394 if ((dashptr = strrchr(name, '-'))) {
7395 *dashptr = '\0';
7396 }
7397
7399
7401
7402 /* We have to pass AST_DEVICE_UNKNOWN here because it is entirely possible that the channel driver
7403 * for this channel is using the callback method for device state. If we pass in an actual state here
7404 * we override what they are saying the state is and things go amuck. */
7406
7407 return 0;
7408}
7409
7410/*! \brief Bridge two channels together (early) */
7412{
7413 /* Make sure we can early bridge, if not error out */
7414 if (!ast_channel_tech(c0)->early_bridge || (c1 && (!ast_channel_tech(c1)->early_bridge || ast_channel_tech(c0)->early_bridge != ast_channel_tech(c1)->early_bridge)))
7415 return -1;
7416
7417 return ast_channel_tech(c0)->early_bridge(c0, c1);
7418}
7419
7420/*! \brief Sets an option on a channel */
7421int ast_channel_setoption(struct ast_channel *chan, int option, void *data, int datalen, int block)
7422{
7423 int res;
7424
7425 ast_channel_lock(chan);
7426 if (!ast_channel_tech(chan)->setoption) {
7427 errno = ENOSYS;
7428 ast_channel_unlock(chan);
7429 return -1;
7430 }
7431
7432 if (block)
7433 ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
7434
7435 res = ast_channel_tech(chan)->setoption(chan, option, data, datalen);
7436 ast_channel_unlock(chan);
7437
7438 return res;
7439}
7440
7441int ast_channel_queryoption(struct ast_channel *chan, int option, void *data, int *datalen, int block)
7442{
7443 int res;
7444
7445 ast_channel_lock(chan);
7446 if (!ast_channel_tech(chan)->queryoption) {
7447 errno = ENOSYS;
7448 ast_channel_unlock(chan);
7449 return -1;
7450 }
7451
7452 if (block)
7453 ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
7454
7455 res = ast_channel_tech(chan)->queryoption(chan, option, data, datalen);
7456 ast_channel_unlock(chan);
7457
7458 return res;
7459}
7460
7465 int vol;
7466};
7467
7469 int fac1;
7470 int fac2;
7471 int v1_1;
7472 int v2_1;
7473 int v3_1;
7474 int v1_2;
7475 int v2_2;
7476 int v3_2;
7478 int pos;
7481 struct ast_frame f;
7483 short data[4000];
7484};
7485
7486static void tonepair_release(struct ast_channel *chan, void *params)
7487{
7488 struct tonepair_state *ts = params;
7489
7490 if (chan) {
7491 ast_set_write_format(chan, ts->origwfmt);
7492 }
7493 ao2_cleanup(ts->origwfmt);
7494 ast_free(ts);
7495}
7496
7497static void *tonepair_alloc(struct ast_channel *chan, void *params)
7498{
7499 struct tonepair_state *ts;
7500 struct tonepair_def *td = params;
7501
7502 if (!(ts = ast_calloc(1, sizeof(*ts)))) {
7503 return NULL;
7504 }
7505
7508 ast_log(LOG_WARNING, "Unable to set '%s' to signed linear format (write)\n", ast_channel_name(chan));
7510 ts = NULL;
7511 } else {
7512 ts->fac1 = 2.0 * cos(2.0 * M_PI * (td->freq1 / 8000.0)) * 32768.0;
7513 ts->v1_1 = 0;
7514 ts->v2_1 = sin(-4.0 * M_PI * (td->freq1 / 8000.0)) * td->vol;
7515 ts->v3_1 = sin(-2.0 * M_PI * (td->freq1 / 8000.0)) * td->vol;
7516 ts->v2_1 = 0;
7517 ts->fac2 = 2.0 * cos(2.0 * M_PI * (td->freq2 / 8000.0)) * 32768.0;
7518 ts->v2_2 = sin(-4.0 * M_PI * (td->freq2 / 8000.0)) * td->vol;
7519 ts->v3_2 = sin(-2.0 * M_PI * (td->freq2 / 8000.0)) * td->vol;
7520 ts->duration = td->duration;
7521 ts->modulate = 0;
7522 }
7523 /* Let interrupts interrupt :) */
7525 return ts;
7526}
7527
7528static int tonepair_generator(struct ast_channel *chan, void *data, int len, int samples)
7529{
7530 struct tonepair_state *ts = data;
7531 int x;
7532
7533 /* we need to prepare a frame with 16 * timelen samples as we're
7534 * generating SLIN audio
7535 */
7536 len = samples * 2;
7537
7538 if (len > sizeof(ts->data) / 2 - 1) {
7539 ast_log(LOG_WARNING, "Can't generate that much data!\n");
7540 return -1;
7541 }
7542 memset(&ts->f, 0, sizeof(ts->f));
7543 for (x=0;x<len/2;x++) {
7544 ts->v1_1 = ts->v2_1;
7545 ts->v2_1 = ts->v3_1;
7546 ts->v3_1 = (ts->fac1 * ts->v2_1 >> 15) - ts->v1_1;
7547
7548 ts->v1_2 = ts->v2_2;
7549 ts->v2_2 = ts->v3_2;
7550 ts->v3_2 = (ts->fac2 * ts->v2_2 >> 15) - ts->v1_2;
7551 if (ts->modulate) {
7552 int p;
7553 p = ts->v3_2 - 32768;
7554 if (p < 0) p = -p;
7555 p = ((p * 9) / 10) + 1;
7556 ts->data[x] = (ts->v3_1 * p) >> 15;
7557 } else
7558 ts->data[x] = ts->v3_1 + ts->v3_2;
7559 }
7562 ts->f.datalen = len;
7563 ts->f.samples = samples;
7565 ts->f.data.ptr = ts->data;
7566 ast_write(chan, &ts->f);
7567 ts->pos += x;
7568 if (ts->duration > 0) {
7569 if (ts->pos >= ts->duration * 8)
7570 return -1;
7571 }
7572 return 0;
7573}
7574
7575static struct ast_generator tonepair = {
7577 .release = tonepair_release,
7578 .generate = tonepair_generator,
7579};
7580
7581int ast_tonepair_start(struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
7582{
7583 struct tonepair_def d = { 0, };
7584
7585 d.freq1 = freq1;
7586 d.freq2 = freq2;
7587 d.duration = duration;
7588 d.vol = (vol < 1) ? 8192 : vol; /* force invalid to 8192 */
7589 if (ast_activate_generator(chan, &tonepair, &d))
7590 return -1;
7591 return 0;
7592}
7593
7595{
7597}
7598
7599int ast_tonepair(struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
7600{
7601 int res;
7602
7603 if ((res = ast_tonepair_start(chan, freq1, freq2, duration, vol)))
7604 return res;
7605
7606 /* Give us some wiggle room */
7607 while (ast_channel_generatordata(chan) && ast_waitfor(chan, 100) >= 0) {
7608 struct ast_frame *f = ast_read(chan);
7609 if (f)
7610 ast_frfree(f);
7611 else
7612 return -1;
7613 }
7614 return 0;
7615}
7616
7618{
7619 char *piece;
7620 char *c;
7621 int start=0, finish=0, x;
7622 ast_group_t group = 0;
7623
7624 if (ast_strlen_zero(s))
7625 return 0;
7626
7627 c = ast_strdupa(s);
7628
7629 while ((piece = strsep(&c, ","))) {
7630 if (sscanf(piece, "%30d-%30d", &start, &finish) == 2) {
7631 /* Range */
7632 } else if (sscanf(piece, "%30d", &start)) {
7633 /* Just one */
7634 finish = start;
7635 } else {
7636 ast_log(LOG_ERROR, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s, piece);
7637 continue;
7638 }
7639 for (x = start; x <= finish; x++) {
7640 if ((x > 63) || (x < 0)) {
7641 ast_log(LOG_WARNING, "Ignoring invalid group %d (maximum group is 63)\n", x);
7642 } else
7643 group |= ((ast_group_t) 1 << x);
7644 }
7645 }
7646 return group;
7647}
7648
7649/*! \brief Named group member structure */
7651 /*! Pre-built hash of group member name. */
7652 unsigned int hash;
7653 /*! Group member name. (End allocation of name string.) */
7654 char name[1];
7655};
7656
7657/*! \brief Comparison function used for named group container */
7658static int namedgroup_cmp_cb(void *obj, void *arg, int flags)
7659{
7660 const struct namedgroup_member *an = obj;
7661 const struct namedgroup_member *bn = arg;
7662
7663 return strcmp(an->name, bn->name) ? 0 : CMP_MATCH | CMP_STOP;
7664}
7665
7666/*! \brief Hashing function used for named group container */
7667static int namedgroup_hash_cb(const void *obj, const int flags)
7668{
7669 const struct namedgroup_member *member = obj;
7670
7671 return member->hash;
7672}
7673
7674struct ast_namedgroups *ast_get_namedgroups(const char *s)
7675{
7676 struct ao2_container *namedgroups;
7677 char *piece;
7678 char *c;
7679
7680 if (!s) {
7681 return NULL;
7682 }
7683
7684 /*! \brief Remove leading and trailing whitespace */
7686 if (ast_strlen_zero(c)) {
7687 return NULL;
7688 }
7689
7692 if (!namedgroups) {
7693 return NULL;
7694 }
7695
7696 while ((piece = strsep(&c, ","))) {
7697 struct namedgroup_member *member;
7698 size_t len;
7699
7700 /* remove leading/trailing whitespace */
7701 piece = ast_strip(piece);
7702
7703 len = strlen(piece);
7704 if (!len) {
7705 continue;
7706 }
7707
7709 if (!member) {
7710 ao2_ref(namedgroups, -1);
7711 return NULL;
7712 }
7713 strcpy(member->name, piece);/* Safe */
7714 member->hash = ast_str_hash(member->name);
7715
7716 /* every group name may exist only once, delete duplicates */
7717 ao2_find(namedgroups, member, OBJ_POINTER | OBJ_UNLINK | OBJ_NODATA);
7718 ao2_link(namedgroups, member);
7719 ao2_ref(member, -1);
7720 }
7721
7722 if (!ao2_container_count(namedgroups)) {
7723 /* There were no group names specified. */
7724 ao2_ref(namedgroups, -1);
7725 namedgroups = NULL;
7726 }
7727
7728 return (struct ast_namedgroups *) namedgroups;
7729}
7730
7731struct ast_namedgroups *ast_unref_namedgroups(struct ast_namedgroups *groups)
7732{
7734 return NULL;
7735}
7736
7737struct ast_namedgroups *ast_ref_namedgroups(struct ast_namedgroups *groups)
7738{
7739 if (groups) {
7740 ao2_ref(groups, 1);
7741 }
7742 return groups;
7743}
7744
7745static int (*ast_moh_start_ptr)(struct ast_channel *, const char *, const char *) = NULL;
7746static void (*ast_moh_stop_ptr)(struct ast_channel *) = NULL;
7747static void (*ast_moh_cleanup_ptr)(struct ast_channel *) = NULL;
7748
7749void ast_install_music_functions(int (*start_ptr)(struct ast_channel *, const char *, const char *),
7750 void (*stop_ptr)(struct ast_channel *),
7751 void (*cleanup_ptr)(struct ast_channel *))
7752{
7753 ast_moh_start_ptr = start_ptr;
7754 ast_moh_stop_ptr = stop_ptr;
7755 ast_moh_cleanup_ptr = cleanup_ptr;
7756}
7757
7759{
7763}
7764
7765int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
7766{
7768 return ast_moh_start_ptr(chan, mclass, interpclass);
7769
7770 ast_verb(3, "Music class %s requested but no musiconhold loaded.\n", mclass ? mclass : (interpclass ? interpclass : "default"));
7771
7772 return -1;
7773}
7774
7775void ast_moh_stop(struct ast_channel *chan)
7776{
7777 if (ast_moh_stop_ptr)
7778 ast_moh_stop_ptr(chan);
7779}
7780
7782{
7784 ast_moh_cleanup_ptr(chan);
7785}
7786
7787static int ast_channel_hash_cb(const void *obj, const int flags)
7788{
7789 const char *name = (flags & OBJ_KEY) ? obj : ast_channel_name((struct ast_channel *) obj);
7790
7791 /* If the name isn't set, return 0 so that the ao2_find() search will
7792 * start in the first bucket. */
7793 if (ast_strlen_zero(name)) {
7794 return 0;
7795 }
7796
7797 return ast_str_case_hash(name);
7798}
7799
7800/*!
7801 * \internal
7802 * \brief Print channel object key (name).
7803 * \since 12.0.0
7804 *
7805 * \param v_obj A pointer to the object we want the key printed.
7806 * \param where User data needed by prnt to determine where to put output.
7807 * \param prnt Print output callback function to use.
7808 */
7809static void prnt_channel_key(void *v_obj, void *where, ao2_prnt_fn *prnt)
7810{
7811 struct ast_channel *chan = v_obj;
7812
7813 if (!chan) {
7814 return;
7815 }
7816 prnt(where, "%s", ast_channel_name(chan));
7817}
7818
7819/*!
7820 * \brief List of channel variables to append to all channel-related events.
7821 */
7824 unsigned int isfunc:1;
7825 char name[];
7826};
7827
7829
7832
7833static void free_external_channelvars(struct external_vars *channelvars)
7834{
7836 AST_RWLIST_WRLOCK(channelvars);
7837 while ((var = AST_RWLIST_REMOVE_HEAD(channelvars, entry))) {
7838 ast_free(var);
7839 }
7840 AST_RWLIST_UNLOCK(channelvars);
7841}
7842
7843static int channel_has_external_vars(struct external_vars *channelvars)
7844{
7845 int vars_present;
7846
7847 AST_RWLIST_RDLOCK(channelvars);
7848 vars_present = !AST_LIST_EMPTY(channelvars);
7849 AST_RWLIST_UNLOCK(channelvars);
7850
7851 return vars_present;
7852}
7853
7855{
7857}
7858
7860{
7862}
7863
7864static void channel_set_external_vars(struct external_vars *channelvars, size_t varc, char **vars)
7865{
7866 size_t i;
7867
7868 free_external_channelvars(channelvars);
7869 AST_RWLIST_WRLOCK(channelvars);
7870 for (i = 0; i < varc; ++i) {
7871 const char *var = vars[i];
7872 struct manager_channel_variable *mcv;
7873 if (!(mcv = ast_calloc(1, sizeof(*mcv) + strlen(var) + 1))) {
7874 break;
7875 }
7876 strcpy(mcv->name, var); /* SAFE */
7877 if (strchr(var, '(')) {
7878 mcv->isfunc = 1;
7879 }
7880 AST_RWLIST_INSERT_TAIL(channelvars, mcv, entry);
7881 }
7882 AST_RWLIST_UNLOCK(channelvars);
7883
7884}
7885
7886void ast_channel_set_manager_vars(size_t varc, char **vars)
7887{
7888 channel_set_external_vars(&ami_vars, varc, vars);
7889}
7890
7891void ast_channel_set_ari_vars(size_t varc, char **vars)
7892{
7893 channel_set_external_vars(&ari_vars, varc, vars);
7894}
7895
7896/*!
7897 * \brief Destructor for lists of variables.
7898 * \param obj AO2 object.
7899 */
7900static void varshead_dtor(void *obj)
7901{
7902 struct varshead *head = obj;
7903 struct ast_var_t *var;
7904
7905 while ((var = AST_RWLIST_REMOVE_HEAD(head, entries))) {
7907 }
7908}
7909
7911{
7912 RAII_VAR(struct varshead *, ret, NULL, ao2_cleanup);
7913 struct ast_var_t *cv;
7914
7915 ret = ao2_alloc(sizeof(*ret), varshead_dtor);
7916
7917 if (!ret) {
7918 return NULL;
7919 }
7920
7923
7924 if (!var) {
7925 return NULL;
7926 }
7927
7929 }
7930
7931 ao2_ref(ret, +1);
7932 return ret;
7933}
7934
7935static struct varshead *channel_get_external_vars(struct external_vars *channelvars,
7936 struct ast_channel *chan)
7937{
7938 RAII_VAR(struct varshead *, ret, NULL, ao2_cleanup);
7939 RAII_VAR(struct ast_str *, tmp, NULL, ast_free);
7940 struct manager_channel_variable *mcv;
7942
7943 if (AST_LIST_EMPTY(channelvars)) {
7944 return NULL;
7945 }
7946
7947 ret = ao2_alloc(sizeof(*ret), varshead_dtor);
7948 tmp = ast_str_create(16);
7949
7950 if (!ret || !tmp) {
7951 return NULL;
7952 }
7953
7954 AST_LIST_TRAVERSE(channelvars, mcv, entry) {
7955 const char *val = NULL;
7956 struct ast_var_t *var;
7957
7958 if (mcv->isfunc) {
7959 if (ast_func_read2(chan, mcv->name, &tmp, 0) == 0) {
7961 } else {
7963 "Error invoking function %s\n", mcv->name);
7964 }
7965 } else {
7966 val = pbx_builtin_getvar_helper(chan, mcv->name);
7967 }
7968
7969 var = ast_var_assign(mcv->name, val ? val : "");
7970 if (!var) {
7971 return NULL;
7972 }
7973
7975 }
7976
7977 ao2_ref(ret, +1);
7978 return ret;
7979
7980}
7981
7983{
7984 return channel_get_external_vars(&ami_vars, chan);
7985}
7986
7988{
7989 return channel_get_external_vars(&ari_vars, chan);
7990}
7991
7992static void channels_shutdown(void)
7993{
7996
7998 if (channels) {
7999 ao2_container_unregister("channels");
8000 ao2_ref(channels, -1);
8001 channels = NULL;
8002 }
8004}
8005
8007{
8010 if (!channels) {
8011 return -1;
8012 }
8014
8016
8018
8020
8022
8025
8026 return 0;
8027}
8028
8029/*! \brief Print call group and pickup group ---*/
8030char *ast_print_group(char *buf, int buflen, ast_group_t group)
8031{
8032 unsigned int i;
8033 int first = 1;
8034 char num[3];
8035
8036 buf[0] = '\0';
8037
8038 if (!group) /* Return empty string if no group */
8039 return buf;
8040
8041 for (i = 0; i <= 63; i++) { /* Max group is 63 */
8042 if (group & ((ast_group_t) 1 << i)) {
8043 if (!first) {
8044 strncat(buf, ", ", buflen - strlen(buf) - 1);
8045 } else {
8046 first = 0;
8047 }
8048 snprintf(num, sizeof(num), "%u", i);
8049 strncat(buf, num, buflen - strlen(buf) - 1);
8050 }
8051 }
8052 return buf;
8053}
8054
8055char *ast_print_namedgroups(struct ast_str **buf, struct ast_namedgroups *group)
8056{
8057 struct ao2_container *grp = (struct ao2_container *) group;
8058 struct namedgroup_member *ng;
8059 int first = 1;
8060 struct ao2_iterator it;
8061
8062 if (!grp) {
8063 return ast_str_buffer(*buf);
8064 }
8065
8066 for (it = ao2_iterator_init(grp, 0); (ng = ao2_iterator_next(&it)); ao2_ref(ng, -1)) {
8067 if (!first) {
8068 ast_str_append(buf, 0, ", ");
8069 } else {
8070 first = 0;
8071 }
8072 ast_str_append(buf, 0, "%s", ng->name);
8073 }
8075
8076 return ast_str_buffer(*buf);
8077}
8078
8079static int namedgroup_match(void *obj, void *arg, int flags)
8080{
8081 void *match;
8082
8083 match = ao2_find(arg, obj, OBJ_POINTER);
8085
8086 return match ? CMP_MATCH | CMP_STOP : 0;
8087}
8088
8089int ast_namedgroups_intersect(struct ast_namedgroups *a, struct ast_namedgroups *b)
8090{
8091 void *match;
8092 struct ao2_container *group_a = (struct ao2_container *) a;
8093 struct ao2_container *group_b = (struct ao2_container *) b;
8094
8095 if (!a || !b) {
8096 return 0;
8097 }
8098
8099 /*
8100 * Do groups a and b intersect? Since a and b are hash tables,
8101 * the average time complexity is:
8102 * O(a.count <= b.count ? a.count : b.count)
8103 */
8104 if (ao2_container_count(group_b) < ao2_container_count(group_a)) {
8105 /* Traverse over the smaller group. */
8106 SWAP(group_a, group_b);
8107 }
8108 match = ao2_callback(group_a, 0, namedgroup_match, group_b);
8110
8111 return match != NULL;
8112}
8113
8114void ast_set_variables(struct ast_channel *chan, struct ast_variable *vars)
8115{
8116 struct ast_variable *cur;
8117
8118 for (cur = vars; cur; cur = cur->next) {
8119 pbx_builtin_setvar_helper(chan, cur->name, cur->value);
8120 }
8121}
8122
8123static void *silence_generator_alloc(struct ast_channel *chan, void *data)
8124{
8125 /* just store the data pointer in the channel structure */
8126 return data;
8127}
8128
8129static void silence_generator_release(struct ast_channel *chan, void *data)
8130{
8131 /* nothing to do */
8132}
8133
8134static int silence_generator_generate(struct ast_channel *chan, void *data, int len, int samples)
8135{
8136 short buf[samples];
8137 struct ast_frame frame = {
8139 .data.ptr = buf,
8140 .samples = samples,
8141 .datalen = sizeof(buf),
8142 };
8144
8145 memset(buf, 0, sizeof(buf));
8146
8147 if (ast_write(chan, &frame))
8148 return -1;
8149
8150 return 0;
8151}
8152
8155 .release = silence_generator_release,
8156 .generate = silence_generator_generate,
8157};
8158
8161};
8162
8164{
8166
8167 if (!(state = ast_calloc(1, sizeof(*state)))) {
8168 return NULL;
8169 }
8170
8171 state->old_write_format = ao2_bump(ast_channel_writeformat(chan));
8172
8173 if (ast_set_write_format(chan, ast_format_slin) < 0) {
8174 ast_log(LOG_ERROR, "Could not set write format to SLINEAR\n");
8175 ast_free(state);
8176 return NULL;
8177 }
8178
8180
8181 ast_debug(1, "Started silence generator on '%s'\n", ast_channel_name(chan));
8182
8183 return state;
8184}
8185
8187{
8188 ast_channel_lock(chan);
8189
8190 if (!ast_channel_generatordata(chan)) {
8191 ast_debug(1, "Trying to stop silence generator when there is no generator on '%s'\n",
8192 ast_channel_name(chan));
8193 ast_channel_unlock(chan);
8194 return 0;
8195 }
8197 ast_debug(1, "Trying to stop silence generator when it is not the current generator on '%s'\n",
8198 ast_channel_name(chan));
8199 ast_channel_unlock(chan);
8200 return 0;
8201 }
8203
8204 ast_channel_unlock(chan);
8205
8206 return 1;
8207}
8208
8210{
8211 if (!state) {
8212 return;
8213 }
8214
8215 if (deactivate_silence_generator(chan)) {
8216 ast_debug(1, "Stopped silence generator on '%s'\n", ast_channel_name(chan));
8217 if (ast_set_write_format(chan, state->old_write_format) < 0) {
8218 ast_log(LOG_ERROR, "Could not return write format to its original state\n");
8219 }
8220 }
8221 ao2_cleanup(state->old_write_format);
8222 ast_free(state);
8223}
8224
8225
8226/*
8227 * Wrappers for various ast_say_*() functions that call the full version
8228 * of the same functions.
8229 * The proper place would be say.c, but that file is optional and one
8230 * must be able to build asterisk even without it (using a loadable 'say'
8231 * implementation that only supplies the 'full' version of the functions.
8232 */
8233
8234int ast_say_number(struct ast_channel *chan, int num,
8235 const char *ints, const char *language, const char *options)
8236{
8237 return ast_say_number_full(chan, num, ints, language, options, -1, -1);
8238}
8239
8240int ast_say_ordinal(struct ast_channel *chan, int num,
8241 const char *ints, const char *language, const char *options)
8242{
8243 return ast_say_ordinal_full(chan, num, ints, language, options, -1, -1);
8244}
8245
8246int ast_say_enumeration(struct ast_channel *chan, int num,
8247 const char *ints, const char *language, const char *options)
8248{
8249 return ast_say_enumeration_full(chan, num, ints, language, options, -1, -1);
8250}
8251
8252int ast_say_digits(struct ast_channel *chan, int num,
8253 const char *ints, const char *lang)
8254{
8255 return ast_say_digits_full(chan, num, ints, lang, -1, -1);
8256}
8257
8258int ast_say_digit_str(struct ast_channel *chan, const char *str,
8259 const char *ints, const char *lang)
8260{
8261 return ast_say_digit_str_full(chan, str, ints, lang, -1, -1);
8262}
8263
8264int ast_say_money_str(struct ast_channel *chan, const char *str,
8265 const char *ints, const char *lang)
8266{
8267 return ast_say_money_str_full(chan, str, ints, lang, -1, -1);
8268}
8269
8270int ast_say_character_str(struct ast_channel *chan, const char *str,
8271 const char *ints, const char *lang, enum ast_say_case_sensitivity sensitivity)
8272{
8273 return ast_say_character_str_full(chan, str, ints, lang, sensitivity, -1, -1);
8274}
8275
8276int ast_say_phonetic_str(struct ast_channel *chan, const char *str,
8277 const char *ints, const char *lang)
8278{
8279 return ast_say_phonetic_str_full(chan, str, ints, lang, -1, -1);
8280}
8281
8282int ast_say_digits_full(struct ast_channel *chan, int num,
8283 const char *ints, const char *lang, int audiofd, int ctrlfd)
8284{
8285 char buf[256];
8286
8287 snprintf(buf, sizeof(buf), "%d", num);
8288
8289 return ast_say_digit_str_full(chan, buf, ints, lang, audiofd, ctrlfd);
8290}
8291
8293{
8294 ast_party_id_copy(&dest->id, &src->id);
8295 ast_party_id_copy(&dest->ani, &src->ani);
8296 dest->ani2 = src->ani2;
8297}
8298
8300{
8301 ast_party_id_copy(&dest->id, &src->id);
8302 ast_party_id_copy(&dest->ani, &src->ani);
8303
8304 dest->ani2 = src->ani2;
8305}
8306
8308{
8309 if (ast_channel_connected(chan) == connected) {
8310 /* Don't set to self */
8311 return;
8312 }
8313
8314 ast_channel_lock(chan);
8318 ast_channel_unlock(chan);
8319}
8320
8321/*! \note Should follow struct ast_party_name */
8323 /*! \brief Subscriber name ie */
8324 int str;
8325 /*! \brief Character set ie. */
8327 /*! \brief presentation-indicator ie */
8329 /*! \brief valid/present ie */
8331};
8332
8333/*!
8334 * \internal
8335 * \since 1.8
8336 * \brief Build a party name information data frame component.
8337 *
8338 * \param data Buffer to fill with the frame data
8339 * \param datalen Size of the buffer to fill
8340 * \param name Party name information
8341 * \param label Name of particular party name
8342 * \param ies Data frame ie values for the party name components
8343 *
8344 * \retval -1 if error
8345 * \retval Amount of data buffer used
8346 */
8347static int party_name_build_data(unsigned char *data, size_t datalen, const struct ast_party_name *name, const char *label, const struct ast_party_name_ies *ies)
8348{
8349 size_t length;
8350 size_t pos = 0;
8351
8352 /*
8353 * The size of integer values must be fixed in case the frame is
8354 * shipped to another machine.
8355 */
8356 if (name->str) {
8357 length = strlen(name->str);
8358 if (datalen < pos + (sizeof(data[0]) * 2) + length) {
8359 ast_log(LOG_WARNING, "No space left for %s name\n", label);
8360 return -1;
8361 }
8362 data[pos++] = ies->str;
8363 data[pos++] = length;
8364 memcpy(data + pos, name->str, length);
8365 pos += length;
8366 }
8367
8368 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8369 ast_log(LOG_WARNING, "No space left for %s name char set\n", label);
8370 return -1;
8371 }
8372 data[pos++] = ies->char_set;
8373 data[pos++] = 1;
8374 data[pos++] = name->char_set;
8375
8376 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8377 ast_log(LOG_WARNING, "No space left for %s name presentation\n", label);
8378 return -1;
8379 }
8380 data[pos++] = ies->presentation;
8381 data[pos++] = 1;
8382 data[pos++] = name->presentation;
8383
8384 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8385 ast_log(LOG_WARNING, "No space left for %s name valid\n", label);
8386 return -1;
8387 }
8388 data[pos++] = ies->valid;
8389 data[pos++] = 1;
8390 data[pos++] = name->valid;
8391
8392 return pos;
8393}
8394
8395/*! \note Should follow struct ast_party_number */
8397 /*! \brief Subscriber phone number ie */
8398 int str;
8399 /*! \brief Type-Of-Number and Numbering-Plan ie */
8400 int plan;
8401 /*! \brief presentation-indicator ie */
8403 /*! \brief valid/present ie */
8405};
8406
8407/*!
8408 * \internal
8409 * \since 1.8
8410 * \brief Build a party number information data frame component.
8411 *
8412 * \param data Buffer to fill with the frame data
8413 * \param datalen Size of the buffer to fill
8414 * \param number Party number information
8415 * \param label Name of particular party number
8416 * \param ies Data frame ie values for the party number components
8417 *
8418 * \retval -1 if error
8419 * \retval Amount of data buffer used
8420 */
8421static int party_number_build_data(unsigned char *data, size_t datalen, const struct ast_party_number *number, const char *label, const struct ast_party_number_ies *ies)
8422{
8423 size_t length;
8424 size_t pos = 0;
8425
8426 /*
8427 * The size of integer values must be fixed in case the frame is
8428 * shipped to another machine.
8429 */
8430 if (number->str) {
8431 length = strlen(number->str);
8432 if (datalen < pos + (sizeof(data[0]) * 2) + length) {
8433 ast_log(LOG_WARNING, "No space left for %s number\n", label);
8434 return -1;
8435 }
8436 data[pos++] = ies->str;
8437 data[pos++] = length;
8438 memcpy(data + pos, number->str, length);
8439 pos += length;
8440 }
8441
8442 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8443 ast_log(LOG_WARNING, "No space left for %s numbering plan\n", label);
8444 return -1;
8445 }
8446 data[pos++] = ies->plan;
8447 data[pos++] = 1;
8448 data[pos++] = number->plan;
8449
8450 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8451 ast_log(LOG_WARNING, "No space left for %s number presentation\n", label);
8452 return -1;
8453 }
8454 data[pos++] = ies->presentation;
8455 data[pos++] = 1;
8456 data[pos++] = number->presentation;
8457
8458 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8459 ast_log(LOG_WARNING, "No space left for %s number valid\n", label);
8460 return -1;
8461 }
8462 data[pos++] = ies->valid;
8463 data[pos++] = 1;
8464 data[pos++] = number->valid;
8465
8466 return pos;
8467}
8468
8469/*! \note Should follow struct ast_party_subaddress */
8471 /*! \brief subaddress ie. */
8472 int str;
8473 /*! \brief subaddress type ie */
8474 int type;
8475 /*! \brief odd/even indicator ie */
8477 /*! \brief valid/present ie */
8479};
8480
8481/*!
8482 * \internal
8483 * \since 1.8
8484 * \brief Build a party subaddress information data frame component.
8485 *
8486 * \param data Buffer to fill with the frame data
8487 * \param datalen Size of the buffer to fill
8488 * \param subaddress Party subaddress information
8489 * \param label Name of particular party subaddress
8490 * \param ies Data frame ie values for the party subaddress components
8491 *
8492 * \retval -1 if error
8493 * \retval Amount of data buffer used
8494 */
8495static int party_subaddress_build_data(unsigned char *data, size_t datalen, const struct ast_party_subaddress *subaddress, const char *label, const struct ast_party_subaddress_ies *ies)
8496{
8497 size_t length;
8498 size_t pos = 0;
8499
8500 /*
8501 * The size of integer values must be fixed in case the frame is
8502 * shipped to another machine.
8503 */
8504 if (subaddress->str) {
8505 length = strlen(subaddress->str);
8506 if (datalen < pos + (sizeof(data[0]) * 2) + length) {
8507 ast_log(LOG_WARNING, "No space left for %s subaddress\n", label);
8508 return -1;
8509 }
8510 data[pos++] = ies->str;
8511 data[pos++] = length;
8512 memcpy(data + pos, subaddress->str, length);
8513 pos += length;
8514 }
8515
8516 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8517 ast_log(LOG_WARNING, "No space left for %s type of subaddress\n", label);
8518 return -1;
8519 }
8520 data[pos++] = ies->type;
8521 data[pos++] = 1;
8522 data[pos++] = subaddress->type;
8523
8524 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8526 "No space left for %s subaddress odd-even indicator\n", label);
8527 return -1;
8528 }
8529 data[pos++] = ies->odd_even_indicator;
8530 data[pos++] = 1;
8531 data[pos++] = subaddress->odd_even_indicator;
8532
8533 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8534 ast_log(LOG_WARNING, "No space left for %s subaddress valid\n", label);
8535 return -1;
8536 }
8537 data[pos++] = ies->valid;
8538 data[pos++] = 1;
8539 data[pos++] = subaddress->valid;
8540
8541 return pos;
8542}
8543
8544/*! \note Should follow struct ast_party_id */
8546 /*! \brief Subscriber name ies */
8548 /*! \brief Subscriber phone number ies */
8550 /*! \brief Subscriber subaddress ies. */
8552 /*! \brief User party id tag ie. */
8553 int tag;
8554 /*!
8555 * \brief Combined name and number presentation ie.
8556 * \note Not sent if value is zero.
8557 */
8559};
8560
8561/*!
8562 * \internal
8563 * \since 1.8
8564 * \brief Build a party id information data frame component.
8565 *
8566 * \param data Buffer to fill with the frame data
8567 * \param datalen Size of the buffer to fill
8568 * \param id Party id information
8569 * \param label Name of particular party id
8570 * \param ies Data frame ie values for the party id components
8571 * \param update What id information to build. NULL if all.
8572 *
8573 * \retval -1 if error
8574 * \retval Amount of data buffer used
8575 */
8576static int party_id_build_data(unsigned char *data, size_t datalen,
8577 const struct ast_party_id *id, const char *label, const struct ast_party_id_ies *ies,
8578 const struct ast_set_party_id *update)
8579{
8580 size_t length;
8581 size_t pos = 0;
8582 int res;
8583
8584 /*
8585 * The size of integer values must be fixed in case the frame is
8586 * shipped to another machine.
8587 */
8588
8589 if (!update || update->name) {
8590 res = party_name_build_data(data + pos, datalen - pos, &id->name, label,
8591 &ies->name);
8592 if (res < 0) {
8593 return -1;
8594 }
8595 pos += res;
8596 }
8597
8598 if (!update || update->number) {
8599 res = party_number_build_data(data + pos, datalen - pos, &id->number, label,
8600 &ies->number);
8601 if (res < 0) {
8602 return -1;
8603 }
8604 pos += res;
8605 }
8606
8607 if (!update || update->subaddress) {
8608 res = party_subaddress_build_data(data + pos, datalen - pos, &id->subaddress,
8609 label, &ies->subaddress);
8610 if (res < 0) {
8611 return -1;
8612 }
8613 pos += res;
8614 }
8615
8616 /* *************** Party id user tag **************************** */
8617 if (id->tag) {
8618 length = strlen(id->tag);
8619 if (datalen < pos + (sizeof(data[0]) * 2) + length) {
8620 ast_log(LOG_WARNING, "No space left for %s tag\n", label);
8621 return -1;
8622 }
8623 data[pos++] = ies->tag;
8624 data[pos++] = length;
8625 memcpy(data + pos, id->tag, length);
8626 pos += length;
8627 }
8628
8629 /* *************** Party id combined presentation *************** */
8630 if (ies->combined_presentation && (!update || update->number)) {
8631 int presentation;
8632
8633 if (!update || update->name) {
8634 presentation = ast_party_id_presentation(id);
8635 } else {
8636 /*
8637 * We must compromise because not all the information is available
8638 * to determine a combined presentation value.
8639 * We will only send the number presentation instead.
8640 */
8641 presentation = id->number.presentation;
8642 }
8643
8644 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8645 ast_log(LOG_WARNING, "No space left for %s combined presentation\n", label);
8646 return -1;
8647 }
8648 data[pos++] = ies->combined_presentation;
8649 data[pos++] = 1;
8650 data[pos++] = presentation;
8651 }
8652
8653 return pos;
8654}
8655
8656/*!
8657 * \brief Element identifiers for connected line indication frame data
8658 * \note Only add to the end of this enum.
8659 */
8660enum {
8664 AST_CONNECTED_LINE_ID_PRESENTATION,/* Combined number and name presentation. */
8672 /*
8673 * No more party id combined number and name presentation values
8674 * need to be created.
8675 */
8694};
8695
8696int ast_connected_line_build_data(unsigned char *data, size_t datalen, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update)
8697{
8698 int32_t value;
8699 size_t pos = 0;
8700 int res;
8701
8702 static const struct ast_party_id_ies ies = {
8704 .name.char_set = AST_CONNECTED_LINE_NAME_CHAR_SET,
8705 .name.presentation = AST_CONNECTED_LINE_NAME_PRESENTATION,
8706 .name.valid = AST_CONNECTED_LINE_NAME_VALID,
8707
8708 .number.str = AST_CONNECTED_LINE_NUMBER,
8709 .number.plan = AST_CONNECTED_LINE_NUMBER_PLAN,
8710 .number.presentation = AST_CONNECTED_LINE_NUMBER_PRESENTATION,
8711 .number.valid = AST_CONNECTED_LINE_NUMBER_VALID,
8712
8713 .subaddress.str = AST_CONNECTED_LINE_SUBADDRESS,
8714 .subaddress.type = AST_CONNECTED_LINE_SUBADDRESS_TYPE,
8715 .subaddress.odd_even_indicator = AST_CONNECTED_LINE_SUBADDRESS_ODD_EVEN,
8716 .subaddress.valid = AST_CONNECTED_LINE_SUBADDRESS_VALID,
8717
8719 .combined_presentation = AST_CONNECTED_LINE_ID_PRESENTATION,
8720 };
8721
8722 static const struct ast_party_id_ies priv_ies = {
8725 .name.presentation = AST_CONNECTED_LINE_PRIV_NAME_PRESENTATION,
8727
8728 .number.str = AST_CONNECTED_LINE_PRIV_NUMBER,
8730 .number.presentation = AST_CONNECTED_LINE_PRIV_NUMBER_PRESENTATION,
8732
8733 .subaddress.str = AST_CONNECTED_LINE_PRIV_SUBADDRESS,
8734 .subaddress.type = AST_CONNECTED_LINE_PRIV_SUBADDRESS_TYPE,
8735 .subaddress.odd_even_indicator = AST_CONNECTED_LINE_PRIV_SUBADDRESS_ODD_EVEN,
8736 .subaddress.valid = AST_CONNECTED_LINE_PRIV_SUBADDRESS_VALID,
8737
8739 .combined_presentation = 0,/* Not sent. */
8740 };
8741
8742 /*
8743 * The size of integer values must be fixed in case the frame is
8744 * shipped to another machine.
8745 */
8746
8747 /* Connected line frame version */
8748 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
8749 ast_log(LOG_WARNING, "No space left for connected line frame version\n");
8750 return -1;
8751 }
8752 data[pos++] = AST_CONNECTED_LINE_VERSION;
8753 data[pos++] = 1;
8754 data[pos++] = 2;/* Version 1 did not have a version ie */
8755
8756 res = party_id_build_data(data + pos, datalen - pos, &connected->id,
8757 "connected line", &ies, update ? &update->id : NULL);
8758 if (res < 0) {
8759 return -1;
8760 }
8761 pos += res;
8762
8763 res = party_id_build_data(data + pos, datalen - pos, &connected->priv,
8764 "connected line priv", &priv_ies, update ? &update->priv : NULL);
8765 if (res < 0) {
8766 return -1;
8767 }
8768 pos += res;
8769
8770 /* Connected line source */
8771 if (datalen < pos + (sizeof(data[0]) * 2) + sizeof(value)) {
8772 ast_log(LOG_WARNING, "No space left for connected line source\n");
8773 return -1;
8774 }
8775 data[pos++] = AST_CONNECTED_LINE_SOURCE;
8776 data[pos++] = sizeof(value);
8777 value = htonl(connected->source);
8778 memcpy(data + pos, &value, sizeof(value));
8779 pos += sizeof(value);
8780
8781 return pos;
8782}
8783
8784int ast_connected_line_parse_data(const unsigned char *data, size_t datalen, struct ast_party_connected_line *connected)
8785{
8786 size_t pos;
8787 unsigned char ie_len;
8788 unsigned char ie_id;
8789 int32_t value;
8790 int frame_version = 1;
8791 int combined_presentation = 0;
8792 int got_combined_presentation = 0;/* TRUE if got a combined name and number presentation value. */
8793
8794 for (pos = 0; pos < datalen; pos += ie_len) {
8795 if (datalen < pos + sizeof(ie_id) + sizeof(ie_len)) {
8796 ast_log(LOG_WARNING, "Invalid connected line update\n");
8797 return -1;
8798 }
8799 ie_id = data[pos++];
8800 ie_len = data[pos++];
8801 if (datalen < pos + ie_len) {
8802 ast_log(LOG_WARNING, "Invalid connected line update\n");
8803 return -1;
8804 }
8805
8806 switch (ie_id) {
8807/* Connected line party frame version */
8809 if (ie_len != 1) {
8810 ast_log(LOG_WARNING, "Invalid connected line frame version (%u)\n",
8811 (unsigned) ie_len);
8812 break;
8813 }
8814 frame_version = data[pos];
8815 break;
8816/* Connected line party id name */
8818 ast_free(connected->id.name.str);
8819 connected->id.name.str = ast_malloc(ie_len + 1);
8820 if (connected->id.name.str) {
8821 memcpy(connected->id.name.str, data + pos, ie_len);
8822 connected->id.name.str[ie_len] = 0;
8823 }
8824 break;
8826 if (ie_len != 1) {
8827 ast_log(LOG_WARNING, "Invalid connected line name char set (%u)\n",
8828 (unsigned) ie_len);
8829 break;
8830 }
8831 connected->id.name.char_set = data[pos];
8832 break;
8834 if (ie_len != 1) {
8835 ast_log(LOG_WARNING, "Invalid connected line name presentation (%u)\n",
8836 (unsigned) ie_len);
8837 break;
8838 }
8839 connected->id.name.presentation = data[pos];
8840 break;
8842 if (ie_len != 1) {
8843 ast_log(LOG_WARNING, "Invalid connected line name valid (%u)\n",
8844 (unsigned) ie_len);
8845 break;
8846 }
8847 connected->id.name.valid = data[pos];
8848 break;
8849/* Connected line party id number */
8851 ast_free(connected->id.number.str);
8852 connected->id.number.str = ast_malloc(ie_len + 1);
8853 if (connected->id.number.str) {
8854 memcpy(connected->id.number.str, data + pos, ie_len);
8855 connected->id.number.str[ie_len] = 0;
8856 }
8857 break;
8859 if (ie_len != 1) {
8860 ast_log(LOG_WARNING, "Invalid connected line numbering plan (%u)\n",
8861 (unsigned) ie_len);
8862 break;
8863 }
8864 connected->id.number.plan = data[pos];
8865 break;
8867 if (ie_len != 1) {
8868 ast_log(LOG_WARNING, "Invalid connected line number presentation (%u)\n",
8869 (unsigned) ie_len);
8870 break;
8871 }
8872 connected->id.number.presentation = data[pos];
8873 break;
8875 if (ie_len != 1) {
8876 ast_log(LOG_WARNING, "Invalid connected line number valid (%u)\n",
8877 (unsigned) ie_len);
8878 break;
8879 }
8880 connected->id.number.valid = data[pos];
8881 break;
8882/* Connected line party id subaddress */
8884 ast_free(connected->id.subaddress.str);
8885 connected->id.subaddress.str = ast_malloc(ie_len + 1);
8886 if (connected->id.subaddress.str) {
8887 memcpy(connected->id.subaddress.str, data + pos, ie_len);
8888 connected->id.subaddress.str[ie_len] = 0;
8889 }
8890 break;
8892 if (ie_len != 1) {
8893 ast_log(LOG_WARNING, "Invalid connected line type of subaddress (%u)\n",
8894 (unsigned) ie_len);
8895 break;
8896 }
8897 connected->id.subaddress.type = data[pos];
8898 break;
8900 if (ie_len != 1) {
8902 "Invalid connected line subaddress odd-even indicator (%u)\n",
8903 (unsigned) ie_len);
8904 break;
8905 }
8906 connected->id.subaddress.odd_even_indicator = data[pos];
8907 break;
8909 if (ie_len != 1) {
8910 ast_log(LOG_WARNING, "Invalid connected line subaddress valid (%u)\n",
8911 (unsigned) ie_len);
8912 break;
8913 }
8914 connected->id.subaddress.valid = data[pos];
8915 break;
8916/* Connected line party tag */
8918 ast_free(connected->id.tag);
8919 connected->id.tag = ast_malloc(ie_len + 1);
8920 if (connected->id.tag) {
8921 memcpy(connected->id.tag, data + pos, ie_len);
8922 connected->id.tag[ie_len] = 0;
8923 }
8924 break;
8925/* Connected line party id combined presentation */
8927 if (ie_len != 1) {
8928 ast_log(LOG_WARNING, "Invalid connected line combined presentation (%u)\n",
8929 (unsigned) ie_len);
8930 break;
8931 }
8932 combined_presentation = data[pos];
8933 got_combined_presentation = 1;
8934 break;
8935/* Private connected line party id name */
8937 ast_free(connected->priv.name.str);
8938 connected->priv.name.str = ast_malloc(ie_len + 1);
8939 if (connected->priv.name.str) {
8940 memcpy(connected->priv.name.str, data + pos, ie_len);
8941 connected->priv.name.str[ie_len] = 0;
8942 }
8943 break;
8945 if (ie_len != 1) {
8946 ast_log(LOG_WARNING, "Invalid connected line private name char set (%u)\n",
8947 (unsigned) ie_len);
8948 break;
8949 }
8950 connected->priv.name.char_set = data[pos];
8951 break;
8953 if (ie_len != 1) {
8954 ast_log(LOG_WARNING, "Invalid connected line private name presentation (%u)\n",
8955 (unsigned) ie_len);
8956 break;
8957 }
8958 connected->priv.name.presentation = data[pos];
8959 break;
8961 if (ie_len != 1) {
8962 ast_log(LOG_WARNING, "Invalid connected line private name valid (%u)\n",
8963 (unsigned) ie_len);
8964 break;
8965 }
8966 connected->priv.name.valid = data[pos];
8967 break;
8968/* Private connected line party id number */
8970 ast_free(connected->priv.number.str);
8971 connected->priv.number.str = ast_malloc(ie_len + 1);
8972 if (connected->priv.number.str) {
8973 memcpy(connected->priv.number.str, data + pos, ie_len);
8974 connected->priv.number.str[ie_len] = 0;
8975 }
8976 break;
8978 if (ie_len != 1) {
8979 ast_log(LOG_WARNING, "Invalid connected line private numbering plan (%u)\n",
8980 (unsigned) ie_len);
8981 break;
8982 }
8983 connected->priv.number.plan = data[pos];
8984 break;
8986 if (ie_len != 1) {
8987 ast_log(LOG_WARNING, "Invalid connected line private number presentation (%u)\n",
8988 (unsigned) ie_len);
8989 break;
8990 }
8991 connected->priv.number.presentation = data[pos];
8992 break;
8994 if (ie_len != 1) {
8995 ast_log(LOG_WARNING, "Invalid connected line private number valid (%u)\n",
8996 (unsigned) ie_len);
8997 break;
8998 }
8999 connected->priv.number.valid = data[pos];
9000 break;
9001/* Private connected line party id subaddress */
9003 ast_free(connected->priv.subaddress.str);
9004 connected->priv.subaddress.str = ast_malloc(ie_len + 1);
9005 if (connected->priv.subaddress.str) {
9006 memcpy(connected->priv.subaddress.str, data + pos, ie_len);
9007 connected->priv.subaddress.str[ie_len] = 0;
9008 }
9009 break;
9011 if (ie_len != 1) {
9012 ast_log(LOG_WARNING, "Invalid connected line private type of subaddress (%u)\n",
9013 (unsigned) ie_len);
9014 break;
9015 }
9016 connected->priv.subaddress.type = data[pos];
9017 break;
9019 if (ie_len != 1) {
9021 "Invalid connected line private subaddress odd-even indicator (%u)\n",
9022 (unsigned) ie_len);
9023 break;
9024 }
9025 connected->priv.subaddress.odd_even_indicator = data[pos];
9026 break;
9028 if (ie_len != 1) {
9029 ast_log(LOG_WARNING, "Invalid connected line private subaddress valid (%u)\n",
9030 (unsigned) ie_len);
9031 break;
9032 }
9033 connected->priv.subaddress.valid = data[pos];
9034 break;
9035/* Private connected line party tag */
9037 ast_free(connected->priv.tag);
9038 connected->priv.tag = ast_malloc(ie_len + 1);
9039 if (connected->priv.tag) {
9040 memcpy(connected->priv.tag, data + pos, ie_len);
9041 connected->priv.tag[ie_len] = 0;
9042 }
9043 break;
9044/* Connected line party source */
9046 if (ie_len != sizeof(value)) {
9047 ast_log(LOG_WARNING, "Invalid connected line source (%u)\n",
9048 (unsigned) ie_len);
9049 break;
9050 }
9051 memcpy(&value, data + pos, sizeof(value));
9052 connected->source = ntohl(value);
9053 break;
9054/* Connected line party unknown element */
9055 default:
9056 ast_debug(1, "Unknown connected line element: %u (%u)\n",
9057 (unsigned) ie_id, (unsigned) ie_len);
9058 break;
9059 }
9060 }
9061
9062 switch (frame_version) {
9063 case 1:
9064 /*
9065 * The other end is an earlier version that we need to adjust
9066 * for compatibility.
9067 */
9068 connected->id.name.valid = 1;
9069 connected->id.name.char_set = AST_PARTY_CHAR_SET_ISO8859_1;
9070 connected->id.number.valid = 1;
9071 if (got_combined_presentation) {
9072 connected->id.name.presentation = combined_presentation;
9073 connected->id.number.presentation = combined_presentation;
9074 }
9075 break;
9076 case 2:
9077 /* The other end is at the same level as we are. */
9078 break;
9079 default:
9080 /*
9081 * The other end is newer than we are.
9082 * We need to assume that they are compatible with us.
9083 */
9084 ast_debug(1, "Connected line frame has newer version: %u\n",
9085 (unsigned) frame_version);
9086 break;
9087 }
9088
9089 return 0;
9090}
9091
9093{
9094 unsigned char data[1024]; /* This should be large enough */
9095 size_t datalen;
9096
9097 datalen = ast_connected_line_build_data(data, sizeof(data), connected, update);
9098 if (datalen == (size_t) -1) {
9099 return;
9100 }
9101
9102 ast_indicate_data(chan, AST_CONTROL_CONNECTED_LINE, data, datalen);
9103}
9104
9106{
9107 unsigned char data[1024]; /* This should be large enough */
9108 size_t datalen;
9109
9110 datalen = ast_connected_line_build_data(data, sizeof(data), connected, update);
9111 if (datalen == (size_t) -1) {
9112 return;
9113 }
9114
9116}
9117
9118void ast_channel_set_redirecting(struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update)
9119{
9120 if (ast_channel_redirecting(chan) == redirecting) {
9121 /* Don't set to self */
9122 return;
9123 }
9124
9125 ast_channel_lock(chan);
9129 ast_channel_unlock(chan);
9130}
9131
9132/*!
9133 * \brief Element identifiers for redirecting indication frame data
9134 * \note Only add to the end of this enum.
9135 */
9136enum {
9140 AST_REDIRECTING_FROM_ID_PRESENTATION,/* Combined number and name presentation. */
9144 AST_REDIRECTING_TO_ID_PRESENTATION,/* Combined number and name presentation. */
9158 /*
9159 * No more party id combined number and name presentation values
9160 * need to be created.
9161 */
9227};
9228
9230 int code;
9231 int str;
9232};
9233
9234static int redirecting_reason_build_data(unsigned char *data, size_t datalen,
9235 const struct ast_party_redirecting_reason *reason, const char *label,
9236 const struct ast_party_redirecting_reason_ies *ies)
9237{
9238 size_t length;
9239 size_t pos = 0;
9240 int32_t value;
9241
9242 if (datalen < pos + (sizeof(data[0]) * 2) + sizeof(value)) {
9243 ast_log(LOG_WARNING, "No space left for %s code\n", label);
9244 return -1;
9245 }
9246 data[pos++] = ies->code;
9247 data[pos++] = sizeof(value);
9248 value = htonl(reason->code);
9249 memcpy(data + pos, &value, sizeof(value));
9250 pos += sizeof(value);
9251
9252 if (reason->str) {
9253 length = strlen(reason->str);
9254 if (datalen < pos + (sizeof(data[0]) * 2) + length) {
9255 ast_log(LOG_WARNING, "No space left for %s string\n", label);
9256 return -1;
9257 }
9258 data[pos++] = ies->str;
9259 data[pos++] = length;
9260 memcpy(data + pos, reason->str, length);
9261 pos += length;
9262 }
9263
9264 return pos;
9265}
9266
9267int ast_redirecting_build_data(unsigned char *data, size_t datalen, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update)
9268{
9269 int32_t value;
9270 size_t pos = 0;
9271 int res;
9272
9273 static const struct ast_party_id_ies orig_ies = {
9275 .name.char_set = AST_REDIRECTING_ORIG_NAME_CHAR_SET,
9276 .name.presentation = AST_REDIRECTING_ORIG_NAME_PRESENTATION,
9277 .name.valid = AST_REDIRECTING_ORIG_NAME_VALID,
9278
9279 .number.str = AST_REDIRECTING_ORIG_NUMBER,
9280 .number.plan = AST_REDIRECTING_ORIG_NUMBER_PLAN,
9281 .number.presentation = AST_REDIRECTING_ORIG_NUMBER_PRESENTATION,
9282 .number.valid = AST_REDIRECTING_ORIG_NUMBER_VALID,
9283
9284 .subaddress.str = AST_REDIRECTING_ORIG_SUBADDRESS,
9285 .subaddress.type = AST_REDIRECTING_ORIG_SUBADDRESS_TYPE,
9286 .subaddress.odd_even_indicator = AST_REDIRECTING_ORIG_SUBADDRESS_ODD_EVEN,
9287 .subaddress.valid = AST_REDIRECTING_ORIG_SUBADDRESS_VALID,
9288
9290 .combined_presentation = 0,/* Not sent. */
9291 };
9292 static const struct ast_party_id_ies from_ies = {
9294 .name.char_set = AST_REDIRECTING_FROM_NAME_CHAR_SET,
9295 .name.presentation = AST_REDIRECTING_FROM_NAME_PRESENTATION,
9296 .name.valid = AST_REDIRECTING_FROM_NAME_VALID,
9297
9298 .number.str = AST_REDIRECTING_FROM_NUMBER,
9299 .number.plan = AST_REDIRECTING_FROM_NUMBER_PLAN,
9300 .number.presentation = AST_REDIRECTING_FROM_NUMBER_PRESENTATION,
9301 .number.valid = AST_REDIRECTING_FROM_NUMBER_VALID,
9302
9303 .subaddress.str = AST_REDIRECTING_FROM_SUBADDRESS,
9304 .subaddress.type = AST_REDIRECTING_FROM_SUBADDRESS_TYPE,
9305 .subaddress.odd_even_indicator = AST_REDIRECTING_FROM_SUBADDRESS_ODD_EVEN,
9306 .subaddress.valid = AST_REDIRECTING_FROM_SUBADDRESS_VALID,
9307
9309 .combined_presentation = AST_REDIRECTING_FROM_ID_PRESENTATION,
9310 };
9311 static const struct ast_party_id_ies to_ies = {
9313 .name.char_set = AST_REDIRECTING_TO_NAME_CHAR_SET,
9314 .name.presentation = AST_REDIRECTING_TO_NAME_PRESENTATION,
9315 .name.valid = AST_REDIRECTING_TO_NAME_VALID,
9316
9317 .number.str = AST_REDIRECTING_TO_NUMBER,
9318 .number.plan = AST_REDIRECTING_TO_NUMBER_PLAN,
9319 .number.presentation = AST_REDIRECTING_TO_NUMBER_PRESENTATION,
9320 .number.valid = AST_REDIRECTING_TO_NUMBER_VALID,
9321
9322 .subaddress.str = AST_REDIRECTING_TO_SUBADDRESS,
9323 .subaddress.type = AST_REDIRECTING_TO_SUBADDRESS_TYPE,
9324 .subaddress.odd_even_indicator = AST_REDIRECTING_TO_SUBADDRESS_ODD_EVEN,
9325 .subaddress.valid = AST_REDIRECTING_TO_SUBADDRESS_VALID,
9326
9328 .combined_presentation = AST_REDIRECTING_TO_ID_PRESENTATION,
9329 };
9330 static const struct ast_party_id_ies priv_orig_ies = {
9335
9338 .number.presentation = AST_REDIRECTING_PRIV_ORIG_NUMBER_PRESENTATION,
9340
9341 .subaddress.str = AST_REDIRECTING_PRIV_ORIG_SUBADDRESS,
9343 .subaddress.odd_even_indicator = AST_REDIRECTING_PRIV_ORIG_SUBADDRESS_ODD_EVEN,
9345
9347 .combined_presentation = 0,/* Not sent. */
9348 };
9349 static const struct ast_party_id_ies priv_from_ies = {
9354
9357 .number.presentation = AST_REDIRECTING_PRIV_FROM_NUMBER_PRESENTATION,
9359
9360 .subaddress.str = AST_REDIRECTING_PRIV_FROM_SUBADDRESS,
9362 .subaddress.odd_even_indicator = AST_REDIRECTING_PRIV_FROM_SUBADDRESS_ODD_EVEN,
9364
9366 .combined_presentation = 0,/* Not sent. */
9367 };
9368 static const struct ast_party_id_ies priv_to_ies = {
9371 .name.presentation = AST_REDIRECTING_PRIV_TO_NAME_PRESENTATION,
9373
9374 .number.str = AST_REDIRECTING_PRIV_TO_NUMBER,
9376 .number.presentation = AST_REDIRECTING_PRIV_TO_NUMBER_PRESENTATION,
9378
9379 .subaddress.str = AST_REDIRECTING_PRIV_TO_SUBADDRESS,
9380 .subaddress.type = AST_REDIRECTING_PRIV_TO_SUBADDRESS_TYPE,
9381 .subaddress.odd_even_indicator = AST_REDIRECTING_PRIV_TO_SUBADDRESS_ODD_EVEN,
9382 .subaddress.valid = AST_REDIRECTING_PRIV_TO_SUBADDRESS_VALID,
9383
9385 .combined_presentation = 0,/* Not sent. */
9386 };
9387 static const struct ast_party_redirecting_reason_ies reason_ies = {
9390 };
9391
9392 static const struct ast_party_redirecting_reason_ies orig_reason_ies = {
9395 };
9396
9397 /* Redirecting frame version */
9398 if (datalen < pos + (sizeof(data[0]) * 2) + 1) {
9399 ast_log(LOG_WARNING, "No space left for redirecting frame version\n");
9400 return -1;
9401 }
9402 data[pos++] = AST_REDIRECTING_VERSION;
9403 data[pos++] = 1;
9404 data[pos++] = 2;/* Version 1 did not have a version ie */
9405
9406 res = party_id_build_data(data + pos, datalen - pos, &redirecting->orig,
9407 "redirecting-orig", &orig_ies, update ? &update->orig : NULL);
9408 if (res < 0) {
9409 return -1;
9410 }
9411 pos += res;
9412
9413 res = party_id_build_data(data + pos, datalen - pos, &redirecting->from,
9414 "redirecting-from", &from_ies, update ? &update->from : NULL);
9415 if (res < 0) {
9416 return -1;
9417 }
9418 pos += res;
9419
9420 res = party_id_build_data(data + pos, datalen - pos, &redirecting->to,
9421 "redirecting-to", &to_ies, update ? &update->to : NULL);
9422 if (res < 0) {
9423 return -1;
9424 }
9425 pos += res;
9426
9427 res = party_id_build_data(data + pos, datalen - pos, &redirecting->priv_orig,
9428 "redirecting-priv-orig", &priv_orig_ies, update ? &update->priv_orig : NULL);
9429 if (res < 0) {
9430 return -1;
9431 }
9432 pos += res;
9433
9434 res = party_id_build_data(data + pos, datalen - pos, &redirecting->priv_from,
9435 "redirecting-priv-from", &priv_from_ies, update ? &update->priv_from : NULL);
9436 if (res < 0) {
9437 return -1;
9438 }
9439 pos += res;
9440
9441 res = party_id_build_data(data + pos, datalen - pos, &redirecting->priv_to,
9442 "redirecting-priv-to", &priv_to_ies, update ? &update->priv_to : NULL);
9443 if (res < 0) {
9444 return -1;
9445 }
9446 pos += res;
9447
9448 /* Redirecting reason */
9449 res = redirecting_reason_build_data(data + pos, datalen - pos, &redirecting->reason,
9450 "redirecting-reason", &reason_ies);
9451 if (res < 0) {
9452 return -1;
9453 }
9454 pos += res;
9455
9456 /* Redirecting original reason */
9457 res = redirecting_reason_build_data(data + pos, datalen - pos, &redirecting->orig_reason,
9458 "redirecting-orig-reason", &orig_reason_ies);
9459 if (res < 0) {
9460 return -1;
9461 }
9462 pos += res;
9463
9464 /* Redirecting count */
9465 if (datalen < pos + (sizeof(data[0]) * 2) + sizeof(value)) {
9466 ast_log(LOG_WARNING, "No space left for redirecting count\n");
9467 return -1;
9468 }
9469 data[pos++] = AST_REDIRECTING_COUNT;
9470 data[pos++] = sizeof(value);
9471 value = htonl(redirecting->count);
9472 memcpy(data + pos, &value, sizeof(value));
9473 pos += sizeof(value);
9474
9475 return pos;
9476}
9477
9478int ast_redirecting_parse_data(const unsigned char *data, size_t datalen, struct ast_party_redirecting *redirecting)
9479{
9480 size_t pos;
9481 unsigned char ie_len;
9482 unsigned char ie_id;
9483 int32_t value;
9484 int frame_version = 1;
9485 int from_combined_presentation = 0;
9486 int got_from_combined_presentation = 0;/* TRUE if got a combined name and number presentation value. */
9487 int to_combined_presentation = 0;
9488 int got_to_combined_presentation = 0;/* TRUE if got a combined name and number presentation value. */
9489
9490 for (pos = 0; pos < datalen; pos += ie_len) {
9491 if (datalen < pos + sizeof(ie_id) + sizeof(ie_len)) {
9492 ast_log(LOG_WARNING, "Invalid redirecting update\n");
9493 return -1;
9494 }
9495 ie_id = data[pos++];
9496 ie_len = data[pos++];
9497 if (datalen < pos + ie_len) {
9498 ast_log(LOG_WARNING, "Invalid redirecting update\n");
9499 return -1;
9500 }
9501
9502 switch (ie_id) {
9503/* Redirecting frame version */
9505 if (ie_len != 1) {
9506 ast_log(LOG_WARNING, "Invalid redirecting frame version (%u)\n",
9507 (unsigned) ie_len);
9508 break;
9509 }
9510 frame_version = data[pos];
9511 break;
9512/* Redirecting-orig party id name */
9514 ast_free(redirecting->orig.name.str);
9515 redirecting->orig.name.str = ast_malloc(ie_len + 1);
9516 if (redirecting->orig.name.str) {
9517 memcpy(redirecting->orig.name.str, data + pos, ie_len);
9518 redirecting->orig.name.str[ie_len] = 0;
9519 }
9520 break;
9522 if (ie_len != 1) {
9523 ast_log(LOG_WARNING, "Invalid redirecting-orig name char set (%u)\n",
9524 (unsigned) ie_len);
9525 break;
9526 }
9527 redirecting->orig.name.char_set = data[pos];
9528 break;
9530 if (ie_len != 1) {
9531 ast_log(LOG_WARNING, "Invalid redirecting-orig name presentation (%u)\n",
9532 (unsigned) ie_len);
9533 break;
9534 }
9535 redirecting->orig.name.presentation = data[pos];
9536 break;
9538 if (ie_len != 1) {
9539 ast_log(LOG_WARNING, "Invalid redirecting-orig name valid (%u)\n",
9540 (unsigned) ie_len);
9541 break;
9542 }
9543 redirecting->orig.name.valid = data[pos];
9544 break;
9545/* Redirecting-orig party id number */
9547 ast_free(redirecting->orig.number.str);
9548 redirecting->orig.number.str = ast_malloc(ie_len + 1);
9549 if (redirecting->orig.number.str) {
9550 memcpy(redirecting->orig.number.str, data + pos, ie_len);
9551 redirecting->orig.number.str[ie_len] = 0;
9552 }
9553 break;
9555 if (ie_len != 1) {
9556 ast_log(LOG_WARNING, "Invalid redirecting-orig numbering plan (%u)\n",
9557 (unsigned) ie_len);
9558 break;
9559 }
9560 redirecting->orig.number.plan = data[pos];
9561 break;
9563 if (ie_len != 1) {
9564 ast_log(LOG_WARNING, "Invalid redirecting-orig number presentation (%u)\n",
9565 (unsigned) ie_len);
9566 break;
9567 }
9568 redirecting->orig.number.presentation = data[pos];
9569 break;
9571 if (ie_len != 1) {
9572 ast_log(LOG_WARNING, "Invalid redirecting-orig number valid (%u)\n",
9573 (unsigned) ie_len);
9574 break;
9575 }
9576 redirecting->orig.number.valid = data[pos];
9577 break;
9578/* Redirecting-orig party id subaddress */
9580 ast_free(redirecting->orig.subaddress.str);
9581 redirecting->orig.subaddress.str = ast_malloc(ie_len + 1);
9582 if (redirecting->orig.subaddress.str) {
9583 memcpy(redirecting->orig.subaddress.str, data + pos, ie_len);
9584 redirecting->orig.subaddress.str[ie_len] = 0;
9585 }
9586 break;
9588 if (ie_len != 1) {
9589 ast_log(LOG_WARNING, "Invalid redirecting-orig type of subaddress (%u)\n",
9590 (unsigned) ie_len);
9591 break;
9592 }
9593 redirecting->orig.subaddress.type = data[pos];
9594 break;
9596 if (ie_len != 1) {
9598 "Invalid redirecting-orig subaddress odd-even indicator (%u)\n",
9599 (unsigned) ie_len);
9600 break;
9601 }
9602 redirecting->orig.subaddress.odd_even_indicator = data[pos];
9603 break;
9605 if (ie_len != 1) {
9606 ast_log(LOG_WARNING, "Invalid redirecting-orig subaddress valid (%u)\n",
9607 (unsigned) ie_len);
9608 break;
9609 }
9610 redirecting->orig.subaddress.valid = data[pos];
9611 break;
9612/* Redirecting-orig party id tag */
9614 ast_free(redirecting->orig.tag);
9615 redirecting->orig.tag = ast_malloc(ie_len + 1);
9616 if (redirecting->orig.tag) {
9617 memcpy(redirecting->orig.tag, data + pos, ie_len);
9618 redirecting->orig.tag[ie_len] = 0;
9619 }
9620 break;
9621/* Redirecting-from party id name */
9623 ast_free(redirecting->from.name.str);
9624 redirecting->from.name.str = ast_malloc(ie_len + 1);
9625 if (redirecting->from.name.str) {
9626 memcpy(redirecting->from.name.str, data + pos, ie_len);
9627 redirecting->from.name.str[ie_len] = 0;
9628 }
9629 break;
9631 if (ie_len != 1) {
9632 ast_log(LOG_WARNING, "Invalid redirecting-from name char set (%u)\n",
9633 (unsigned) ie_len);
9634 break;
9635 }
9636 redirecting->from.name.char_set = data[pos];
9637 break;
9639 if (ie_len != 1) {
9640 ast_log(LOG_WARNING, "Invalid redirecting-from name presentation (%u)\n",
9641 (unsigned) ie_len);
9642 break;
9643 }
9644 redirecting->from.name.presentation = data[pos];
9645 break;
9647 if (ie_len != 1) {
9648 ast_log(LOG_WARNING, "Invalid redirecting-from name valid (%u)\n",
9649 (unsigned) ie_len);
9650 break;
9651 }
9652 redirecting->from.name.valid = data[pos];
9653 break;
9654/* Redirecting-from party id number */
9656 ast_free(redirecting->from.number.str);
9657 redirecting->from.number.str = ast_malloc(ie_len + 1);
9658 if (redirecting->from.number.str) {
9659 memcpy(redirecting->from.number.str, data + pos, ie_len);
9660 redirecting->from.number.str[ie_len] = 0;
9661 }
9662 break;
9664 if (ie_len != 1) {
9665 ast_log(LOG_WARNING, "Invalid redirecting-from numbering plan (%u)\n",
9666 (unsigned) ie_len);
9667 break;
9668 }
9669 redirecting->from.number.plan = data[pos];
9670 break;
9672 if (ie_len != 1) {
9673 ast_log(LOG_WARNING, "Invalid redirecting-from number presentation (%u)\n",
9674 (unsigned) ie_len);
9675 break;
9676 }
9677 redirecting->from.number.presentation = data[pos];
9678 break;
9680 if (ie_len != 1) {
9681 ast_log(LOG_WARNING, "Invalid redirecting-from number valid (%u)\n",
9682 (unsigned) ie_len);
9683 break;
9684 }
9685 redirecting->from.number.valid = data[pos];
9686 break;
9687/* Redirecting-from party id combined presentation */
9689 if (ie_len != 1) {
9690 ast_log(LOG_WARNING, "Invalid redirecting-from combined presentation (%u)\n",
9691 (unsigned) ie_len);
9692 break;
9693 }
9694 from_combined_presentation = data[pos];
9695 got_from_combined_presentation = 1;
9696 break;
9697/* Redirecting-from party id subaddress */
9699 ast_free(redirecting->from.subaddress.str);
9700 redirecting->from.subaddress.str = ast_malloc(ie_len + 1);
9701 if (redirecting->from.subaddress.str) {
9702 memcpy(redirecting->from.subaddress.str, data + pos, ie_len);
9703 redirecting->from.subaddress.str[ie_len] = 0;
9704 }
9705 break;
9707 if (ie_len != 1) {
9708 ast_log(LOG_WARNING, "Invalid redirecting-from type of subaddress (%u)\n",
9709 (unsigned) ie_len);
9710 break;
9711 }
9712 redirecting->from.subaddress.type = data[pos];
9713 break;
9715 if (ie_len != 1) {
9717 "Invalid redirecting-from subaddress odd-even indicator (%u)\n",
9718 (unsigned) ie_len);
9719 break;
9720 }
9721 redirecting->from.subaddress.odd_even_indicator = data[pos];
9722 break;
9724 if (ie_len != 1) {
9725 ast_log(LOG_WARNING, "Invalid redirecting-from subaddress valid (%u)\n",
9726 (unsigned) ie_len);
9727 break;
9728 }
9729 redirecting->from.subaddress.valid = data[pos];
9730 break;
9731/* Redirecting-from party id tag */
9733 ast_free(redirecting->from.tag);
9734 redirecting->from.tag = ast_malloc(ie_len + 1);
9735 if (redirecting->from.tag) {
9736 memcpy(redirecting->from.tag, data + pos, ie_len);
9737 redirecting->from.tag[ie_len] = 0;
9738 }
9739 break;
9740/* Redirecting-to party id name */
9742 ast_free(redirecting->to.name.str);
9743 redirecting->to.name.str = ast_malloc(ie_len + 1);
9744 if (redirecting->to.name.str) {
9745 memcpy(redirecting->to.name.str, data + pos, ie_len);
9746 redirecting->to.name.str[ie_len] = 0;
9747 }
9748 break;
9750 if (ie_len != 1) {
9751 ast_log(LOG_WARNING, "Invalid redirecting-to name char set (%u)\n",
9752 (unsigned) ie_len);
9753 break;
9754 }
9755 redirecting->to.name.char_set = data[pos];
9756 break;
9758 if (ie_len != 1) {
9759 ast_log(LOG_WARNING, "Invalid redirecting-to name presentation (%u)\n",
9760 (unsigned) ie_len);
9761 break;
9762 }
9763 redirecting->to.name.presentation = data[pos];
9764 break;
9766 if (ie_len != 1) {
9767 ast_log(LOG_WARNING, "Invalid redirecting-to name valid (%u)\n",
9768 (unsigned) ie_len);
9769 break;
9770 }
9771 redirecting->to.name.valid = data[pos];
9772 break;
9773/* Redirecting-to party id number */
9775 ast_free(redirecting->to.number.str);
9776 redirecting->to.number.str = ast_malloc(ie_len + 1);
9777 if (redirecting->to.number.str) {
9778 memcpy(redirecting->to.number.str, data + pos, ie_len);
9779 redirecting->to.number.str[ie_len] = 0;
9780 }
9781 break;
9783 if (ie_len != 1) {
9784 ast_log(LOG_WARNING, "Invalid redirecting-to numbering plan (%u)\n",
9785 (unsigned) ie_len);
9786 break;
9787 }
9788 redirecting->to.number.plan = data[pos];
9789 break;
9791 if (ie_len != 1) {
9792 ast_log(LOG_WARNING, "Invalid redirecting-to number presentation (%u)\n",
9793 (unsigned) ie_len);
9794 break;
9795 }
9796 redirecting->to.number.presentation = data[pos];
9797 break;
9799 if (ie_len != 1) {
9800 ast_log(LOG_WARNING, "Invalid redirecting-to number valid (%u)\n",
9801 (unsigned) ie_len);
9802 break;
9803 }
9804 redirecting->to.number.valid = data[pos];
9805 break;
9806/* Redirecting-to party id combined presentation */
9808 if (ie_len != 1) {
9809 ast_log(LOG_WARNING, "Invalid redirecting-to combined presentation (%u)\n",
9810 (unsigned) ie_len);
9811 break;
9812 }
9813 to_combined_presentation = data[pos];
9814 got_to_combined_presentation = 1;
9815 break;
9816/* Redirecting-to party id subaddress */
9818 ast_free(redirecting->to.subaddress.str);
9819 redirecting->to.subaddress.str = ast_malloc(ie_len + 1);
9820 if (redirecting->to.subaddress.str) {
9821 memcpy(redirecting->to.subaddress.str, data + pos, ie_len);
9822 redirecting->to.subaddress.str[ie_len] = 0;
9823 }
9824 break;
9826 if (ie_len != 1) {
9827 ast_log(LOG_WARNING, "Invalid redirecting-to type of subaddress (%u)\n",
9828 (unsigned) ie_len);
9829 break;
9830 }
9831 redirecting->to.subaddress.type = data[pos];
9832 break;
9834 if (ie_len != 1) {
9836 "Invalid redirecting-to subaddress odd-even indicator (%u)\n",
9837 (unsigned) ie_len);
9838 break;
9839 }
9840 redirecting->to.subaddress.odd_even_indicator = data[pos];
9841 break;
9843 if (ie_len != 1) {
9844 ast_log(LOG_WARNING, "Invalid redirecting-to subaddress valid (%u)\n",
9845 (unsigned) ie_len);
9846 break;
9847 }
9848 redirecting->to.subaddress.valid = data[pos];
9849 break;
9850/* Redirecting-to party id tag */
9852 ast_free(redirecting->to.tag);
9853 redirecting->to.tag = ast_malloc(ie_len + 1);
9854 if (redirecting->to.tag) {
9855 memcpy(redirecting->to.tag, data + pos, ie_len);
9856 redirecting->to.tag[ie_len] = 0;
9857 }
9858 break;
9859/* Private redirecting-orig party id name */
9861 ast_free(redirecting->priv_orig.name.str);
9862 redirecting->priv_orig.name.str = ast_malloc(ie_len + 1);
9863 if (redirecting->priv_orig.name.str) {
9864 memcpy(redirecting->priv_orig.name.str, data + pos, ie_len);
9865 redirecting->priv_orig.name.str[ie_len] = 0;
9866 }
9867 break;
9869 if (ie_len != 1) {
9870 ast_log(LOG_WARNING, "Invalid private redirecting-orig name char set (%u)\n",
9871 (unsigned) ie_len);
9872 break;
9873 }
9874 redirecting->priv_orig.name.char_set = data[pos];
9875 break;
9877 if (ie_len != 1) {
9878 ast_log(LOG_WARNING, "Invalid private redirecting-orig name presentation (%u)\n",
9879 (unsigned) ie_len);
9880 break;
9881 }
9882 redirecting->priv_orig.name.presentation = data[pos];
9883 break;
9885 if (ie_len != 1) {
9886 ast_log(LOG_WARNING, "Invalid private redirecting-orig name valid (%u)\n",
9887 (unsigned) ie_len);
9888 break;
9889 }
9890 redirecting->priv_orig.name.valid = data[pos];
9891 break;
9892/* Private redirecting-orig party id number */
9894 ast_free(redirecting->priv_orig.number.str);
9895 redirecting->priv_orig.number.str = ast_malloc(ie_len + 1);
9896 if (redirecting->priv_orig.number.str) {
9897 memcpy(redirecting->priv_orig.number.str, data + pos, ie_len);
9898 redirecting->priv_orig.number.str[ie_len] = 0;
9899 }
9900 break;
9902 if (ie_len != 1) {
9903 ast_log(LOG_WARNING, "Invalid private redirecting-orig numbering plan (%u)\n",
9904 (unsigned) ie_len);
9905 break;
9906 }
9907 redirecting->priv_orig.number.plan = data[pos];
9908 break;
9910 if (ie_len != 1) {
9911 ast_log(LOG_WARNING, "Invalid private redirecting-orig number presentation (%u)\n",
9912 (unsigned) ie_len);
9913 break;
9914 }
9915 redirecting->priv_orig.number.presentation = data[pos];
9916 break;
9918 if (ie_len != 1) {
9919 ast_log(LOG_WARNING, "Invalid private redirecting-orig number valid (%u)\n",
9920 (unsigned) ie_len);
9921 break;
9922 }
9923 redirecting->priv_orig.number.valid = data[pos];
9924 break;
9925/* Private redirecting-orig party id subaddress */
9927 ast_free(redirecting->priv_orig.subaddress.str);
9928 redirecting->priv_orig.subaddress.str = ast_malloc(ie_len + 1);
9929 if (redirecting->priv_orig.subaddress.str) {
9930 memcpy(redirecting->priv_orig.subaddress.str, data + pos, ie_len);
9931 redirecting->priv_orig.subaddress.str[ie_len] = 0;
9932 }
9933 break;
9935 if (ie_len != 1) {
9936 ast_log(LOG_WARNING, "Invalid private redirecting-orig type of subaddress (%u)\n",
9937 (unsigned) ie_len);
9938 break;
9939 }
9940 redirecting->priv_orig.subaddress.type = data[pos];
9941 break;
9943 if (ie_len != 1) {
9945 "Invalid private redirecting-orig subaddress odd-even indicator (%u)\n",
9946 (unsigned) ie_len);
9947 break;
9948 }
9949 redirecting->priv_orig.subaddress.odd_even_indicator = data[pos];
9950 break;
9952 if (ie_len != 1) {
9953 ast_log(LOG_WARNING, "Invalid private redirecting-orig subaddress valid (%u)\n",
9954 (unsigned) ie_len);
9955 break;
9956 }
9957 redirecting->priv_orig.subaddress.valid = data[pos];
9958 break;
9959/* Private redirecting-orig party id tag */
9961 ast_free(redirecting->priv_orig.tag);
9962 redirecting->priv_orig.tag = ast_malloc(ie_len + 1);
9963 if (redirecting->priv_orig.tag) {
9964 memcpy(redirecting->priv_orig.tag, data + pos, ie_len);
9965 redirecting->priv_orig.tag[ie_len] = 0;
9966 }
9967 break;
9968/* Private redirecting-from party id name */
9970 ast_free(redirecting->priv_from.name.str);
9971 redirecting->priv_from.name.str = ast_malloc(ie_len + 1);
9972 if (redirecting->priv_from.name.str) {
9973 memcpy(redirecting->priv_from.name.str, data + pos, ie_len);
9974 redirecting->priv_from.name.str[ie_len] = 0;
9975 }
9976 break;
9978 if (ie_len != 1) {
9979 ast_log(LOG_WARNING, "Invalid private redirecting-from name char set (%u)\n",
9980 (unsigned) ie_len);
9981 break;
9982 }
9983 redirecting->priv_from.name.char_set = data[pos];
9984 break;
9986 if (ie_len != 1) {
9987 ast_log(LOG_WARNING, "Invalid private redirecting-from name presentation (%u)\n",
9988 (unsigned) ie_len);
9989 break;
9990 }
9991 redirecting->priv_from.name.presentation = data[pos];
9992 break;
9994 if (ie_len != 1) {
9995 ast_log(LOG_WARNING, "Invalid private redirecting-from name valid (%u)\n",
9996 (unsigned) ie_len);
9997 break;
9998 }
9999 redirecting->priv_from.name.valid = data[pos];
10000 break;
10001/* Private redirecting-from party id number */
10003 ast_free(redirecting->priv_from.number.str);
10004 redirecting->priv_from.number.str = ast_malloc(ie_len + 1);
10005 if (redirecting->priv_from.number.str) {
10006 memcpy(redirecting->priv_from.number.str, data + pos, ie_len);
10007 redirecting->priv_from.number.str[ie_len] = 0;
10008 }
10009 break;
10011 if (ie_len != 1) {
10012 ast_log(LOG_WARNING, "Invalid private redirecting-from numbering plan (%u)\n",
10013 (unsigned) ie_len);
10014 break;
10015 }
10016 redirecting->priv_from.number.plan = data[pos];
10017 break;
10019 if (ie_len != 1) {
10020 ast_log(LOG_WARNING, "Invalid private redirecting-from number presentation (%u)\n",
10021 (unsigned) ie_len);
10022 break;
10023 }
10024 redirecting->priv_from.number.presentation = data[pos];
10025 break;
10027 if (ie_len != 1) {
10028 ast_log(LOG_WARNING, "Invalid private redirecting-from number valid (%u)\n",
10029 (unsigned) ie_len);
10030 break;
10031 }
10032 redirecting->priv_from.number.valid = data[pos];
10033 break;
10034/* Private redirecting-from party id subaddress */
10036 ast_free(redirecting->priv_from.subaddress.str);
10037 redirecting->priv_from.subaddress.str = ast_malloc(ie_len + 1);
10038 if (redirecting->priv_from.subaddress.str) {
10039 memcpy(redirecting->priv_from.subaddress.str, data + pos, ie_len);
10040 redirecting->priv_from.subaddress.str[ie_len] = 0;
10041 }
10042 break;
10044 if (ie_len != 1) {
10045 ast_log(LOG_WARNING, "Invalid private redirecting-from type of subaddress (%u)\n",
10046 (unsigned) ie_len);
10047 break;
10048 }
10049 redirecting->priv_from.subaddress.type = data[pos];
10050 break;
10052 if (ie_len != 1) {
10054 "Invalid private redirecting-from subaddress odd-even indicator (%u)\n",
10055 (unsigned) ie_len);
10056 break;
10057 }
10058 redirecting->priv_from.subaddress.odd_even_indicator = data[pos];
10059 break;
10061 if (ie_len != 1) {
10062 ast_log(LOG_WARNING, "Invalid private redirecting-from subaddress valid (%u)\n",
10063 (unsigned) ie_len);
10064 break;
10065 }
10066 redirecting->priv_from.subaddress.valid = data[pos];
10067 break;
10068/* Private redirecting-from party id tag */
10070 ast_free(redirecting->priv_from.tag);
10071 redirecting->priv_from.tag = ast_malloc(ie_len + 1);
10072 if (redirecting->priv_from.tag) {
10073 memcpy(redirecting->priv_from.tag, data + pos, ie_len);
10074 redirecting->priv_from.tag[ie_len] = 0;
10075 }
10076 break;
10077/* Private redirecting-to party id name */
10079 ast_free(redirecting->priv_to.name.str);
10080 redirecting->priv_to.name.str = ast_malloc(ie_len + 1);
10081 if (redirecting->priv_to.name.str) {
10082 memcpy(redirecting->priv_to.name.str, data + pos, ie_len);
10083 redirecting->priv_to.name.str[ie_len] = 0;
10084 }
10085 break;
10087 if (ie_len != 1) {
10088 ast_log(LOG_WARNING, "Invalid private redirecting-to name char set (%u)\n",
10089 (unsigned) ie_len);
10090 break;
10091 }
10092 redirecting->priv_to.name.char_set = data[pos];
10093 break;
10095 if (ie_len != 1) {
10096 ast_log(LOG_WARNING, "Invalid private redirecting-to name presentation (%u)\n",
10097 (unsigned) ie_len);
10098 break;
10099 }
10100 redirecting->priv_to.name.presentation = data[pos];
10101 break;
10103 if (ie_len != 1) {
10104 ast_log(LOG_WARNING, "Invalid private redirecting-to name valid (%u)\n",
10105 (unsigned) ie_len);
10106 break;
10107 }
10108 redirecting->priv_to.name.valid = data[pos];
10109 break;
10110/* Private redirecting-to party id number */
10112 ast_free(redirecting->priv_to.number.str);
10113 redirecting->priv_to.number.str = ast_malloc(ie_len + 1);
10114 if (redirecting->priv_to.number.str) {
10115 memcpy(redirecting->priv_to.number.str, data + pos, ie_len);
10116 redirecting->priv_to.number.str[ie_len] = 0;
10117 }
10118 break;
10120 if (ie_len != 1) {
10121 ast_log(LOG_WARNING, "Invalid private redirecting-to numbering plan (%u)\n",
10122 (unsigned) ie_len);
10123 break;
10124 }
10125 redirecting->priv_to.number.plan = data[pos];
10126 break;
10128 if (ie_len != 1) {
10129 ast_log(LOG_WARNING, "Invalid private redirecting-to number presentation (%u)\n",
10130 (unsigned) ie_len);
10131 break;
10132 }
10133 redirecting->priv_to.number.presentation = data[pos];
10134 break;
10136 if (ie_len != 1) {
10137 ast_log(LOG_WARNING, "Invalid private redirecting-to number valid (%u)\n",
10138 (unsigned) ie_len);
10139 break;
10140 }
10141 redirecting->priv_to.number.valid = data[pos];
10142 break;
10143/* Private redirecting-to party id subaddress */
10145 ast_free(redirecting->priv_to.subaddress.str);
10146 redirecting->priv_to.subaddress.str = ast_malloc(ie_len + 1);
10147 if (redirecting->priv_to.subaddress.str) {
10148 memcpy(redirecting->priv_to.subaddress.str, data + pos, ie_len);
10149 redirecting->priv_to.subaddress.str[ie_len] = 0;
10150 }
10151 break;
10153 if (ie_len != 1) {
10154 ast_log(LOG_WARNING, "Invalid private redirecting-to type of subaddress (%u)\n",
10155 (unsigned) ie_len);
10156 break;
10157 }
10158 redirecting->priv_to.subaddress.type = data[pos];
10159 break;
10161 if (ie_len != 1) {
10163 "Invalid private redirecting-to subaddress odd-even indicator (%u)\n",
10164 (unsigned) ie_len);
10165 break;
10166 }
10167 redirecting->priv_to.subaddress.odd_even_indicator = data[pos];
10168 break;
10170 if (ie_len != 1) {
10171 ast_log(LOG_WARNING, "Invalid private redirecting-to subaddress valid (%u)\n",
10172 (unsigned) ie_len);
10173 break;
10174 }
10175 redirecting->priv_to.subaddress.valid = data[pos];
10176 break;
10177/* Private redirecting-to party id tag */
10179 ast_free(redirecting->priv_to.tag);
10180 redirecting->priv_to.tag = ast_malloc(ie_len + 1);
10181 if (redirecting->priv_to.tag) {
10182 memcpy(redirecting->priv_to.tag, data + pos, ie_len);
10183 redirecting->priv_to.tag[ie_len] = 0;
10184 }
10185 break;
10186/* Redirecting reason code */
10188 if (ie_len != sizeof(value)) {
10189 ast_log(LOG_WARNING, "Invalid redirecting reason (%u)\n",
10190 (unsigned) ie_len);
10191 break;
10192 }
10193 memcpy(&value, data + pos, sizeof(value));
10194 redirecting->reason.code = ntohl(value);
10195 break;
10196/* Redirecting reason string */
10198 ast_free(redirecting->reason.str);
10199 redirecting->reason.str = ast_malloc(ie_len + 1);
10200 if (redirecting->reason.str) {
10201 memcpy(redirecting->reason.str, data + pos, ie_len);
10202 redirecting->reason.str[ie_len] = 0;
10203 }
10204 break;
10205/* Redirecting orig-reason code */
10207 if (ie_len != sizeof(value)) {
10208 ast_log(LOG_WARNING, "Invalid redirecting original reason (%u)\n",
10209 (unsigned) ie_len);
10210 break;
10211 }
10212 memcpy(&value, data + pos, sizeof(value));
10213 redirecting->orig_reason.code = ntohl(value);
10214 break;
10215/* Redirecting orig-reason string */
10217 ast_free(redirecting->orig_reason.str);
10218 redirecting->orig_reason.str = ast_malloc(ie_len + 1);
10219 if (redirecting->orig_reason.str) {
10220 memcpy(redirecting->orig_reason.str, data + pos, ie_len);
10221 redirecting->orig_reason.str[ie_len] = 0;
10222 }
10223 break;
10224/* Redirecting count */
10226 if (ie_len != sizeof(value)) {
10227 ast_log(LOG_WARNING, "Invalid redirecting count (%u)\n",
10228 (unsigned) ie_len);
10229 break;
10230 }
10231 memcpy(&value, data + pos, sizeof(value));
10232 redirecting->count = ntohl(value);
10233 break;
10234/* Redirecting unknown element */
10235 default:
10236 ast_debug(1, "Unknown redirecting element: %u (%u)\n",
10237 (unsigned) ie_id, (unsigned) ie_len);
10238 break;
10239 }
10240 }
10241
10242 switch (frame_version) {
10243 case 1:
10244 /*
10245 * The other end is an earlier version that we need to adjust
10246 * for compatibility.
10247 *
10248 * The earlier version did not have the orig party id or
10249 * orig_reason value.
10250 */
10251 redirecting->from.name.valid = 1;
10253 redirecting->from.number.valid = 1;
10254 if (got_from_combined_presentation) {
10255 redirecting->from.name.presentation = from_combined_presentation;
10256 redirecting->from.number.presentation = from_combined_presentation;
10257 }
10258
10259 redirecting->to.name.valid = 1;
10261 redirecting->to.number.valid = 1;
10262 if (got_to_combined_presentation) {
10263 redirecting->to.name.presentation = to_combined_presentation;
10264 redirecting->to.number.presentation = to_combined_presentation;
10265 }
10266 break;
10267 case 2:
10268 /* The other end is at the same level as we are. */
10269 break;
10270 default:
10271 /*
10272 * The other end is newer than we are.
10273 * We need to assume that they are compatible with us.
10274 */
10275 ast_debug(1, "Redirecting frame has newer version: %u\n",
10276 (unsigned) frame_version);
10277 break;
10278 }
10279
10280 return 0;
10281}
10282
10284{
10285 unsigned char data[1024]; /* This should be large enough */
10286 size_t datalen;
10287
10288 datalen = ast_redirecting_build_data(data, sizeof(data), redirecting, update);
10289 if (datalen == (size_t) -1) {
10290 return;
10291 }
10292
10293 ast_indicate_data(chan, AST_CONTROL_REDIRECTING, data, datalen);
10294}
10295
10297{
10298 unsigned char data[1024]; /* This should be large enough */
10299 size_t datalen;
10300
10301 datalen = ast_redirecting_build_data(data, sizeof(data), redirecting, update);
10302 if (datalen == (size_t) -1) {
10303 return;
10304 }
10305
10306 ast_queue_control_data(chan, AST_CONTROL_REDIRECTING, data, datalen);
10307}
10308
10309/*!
10310 * Storage to determine if the current thread is running an intercept dialplan routine.
10311 */
10312AST_THREADSTORAGE_RAW(in_intercept_routine);
10313
10314/*!
10315 * \internal
10316 * \brief Set the current intercept dialplan routine status mode.
10317 * \since 13.14.0
10318 *
10319 * \param in_intercept_mode New intercept mode. (Non-zero if in intercept mode)
10320 */
10321static void channel_set_intercept_mode(int in_intercept_mode)
10322{
10323 int status;
10324
10325 status = ast_threadstorage_set_ptr(&in_intercept_routine,
10326 in_intercept_mode ? &(int) { 1 } : NULL);
10327 if (status) {
10328 ast_log(LOG_ERROR, "Failed to set dialplan intercept mode\n");
10329 }
10330}
10331
10333{
10334 return ast_threadstorage_get_ptr(&in_intercept_routine) ? 1 : 0;
10335}
10336
10337int ast_channel_connected_line_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const void *connected_info, int is_frame)
10338{
10339 const char *sub;
10340 const char *sub_args;
10341 int retval;
10342
10343 ast_channel_lock(sub_chan);
10344 sub = pbx_builtin_getvar_helper(sub_chan, "CONNECTED_LINE_SEND_SUB");
10345 sub = ast_strdupa(S_OR(sub, ""));
10346 sub_args = pbx_builtin_getvar_helper(sub_chan, "CONNECTED_LINE_SEND_SUB_ARGS");
10347 sub_args = ast_strdupa(S_OR(sub_args, ""));
10348
10349 if (ast_strlen_zero(sub)) {
10350 ast_channel_unlock(sub_chan);
10351 return -1;
10352 }
10353
10354 if (is_frame) {
10355 const struct ast_frame *frame = connected_info;
10356
10358 } else {
10359 const struct ast_party_connected_line *connected = connected_info;
10360
10362 }
10363 ast_channel_unlock(sub_chan);
10364
10366 retval = ast_app_run_sub(autoservice_chan, sub_chan, sub, sub_args, 0);
10368 if (!retval) {
10369 struct ast_party_connected_line saved_connected;
10370
10371 ast_party_connected_line_init(&saved_connected);
10372 ast_channel_lock(sub_chan);
10373 ast_party_connected_line_copy(&saved_connected, ast_channel_connected(sub_chan));
10374 ast_channel_unlock(sub_chan);
10375 ast_channel_update_connected_line(sub_chan, &saved_connected, NULL);
10376 ast_party_connected_line_free(&saved_connected);
10377 }
10378
10379 return retval;
10380}
10381
10382int ast_channel_redirecting_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const void *redirecting_info, int is_frame)
10383{
10384 const char *sub;
10385 const char *sub_args;
10386 int retval;
10387
10388 ast_channel_lock(sub_chan);
10389 sub = pbx_builtin_getvar_helper(sub_chan, "REDIRECTING_SEND_SUB");
10390 sub = ast_strdupa(S_OR(sub, ""));
10391 sub_args = pbx_builtin_getvar_helper(sub_chan, "REDIRECTING_SEND_SUB_ARGS");
10392 sub_args = ast_strdupa(S_OR(sub_args, ""));
10393
10394 if (ast_strlen_zero(sub)) {
10395 ast_channel_unlock(sub_chan);
10396 return -1;
10397 }
10398
10399 if (is_frame) {
10400 const struct ast_frame *frame = redirecting_info;
10401
10403 } else {
10404 const struct ast_party_redirecting *redirecting = redirecting_info;
10405
10407 }
10408 ast_channel_unlock(sub_chan);
10409
10411 retval = ast_app_run_sub(autoservice_chan, sub_chan, sub, sub_args, 0);
10413 if (!retval) {
10414 struct ast_party_redirecting saved_redirecting;
10415
10416 ast_party_redirecting_init(&saved_redirecting);
10417 ast_channel_lock(sub_chan);
10418 ast_party_redirecting_copy(&saved_redirecting, ast_channel_redirecting(sub_chan));
10419 ast_channel_unlock(sub_chan);
10420 ast_channel_update_redirecting(sub_chan, &saved_redirecting, NULL);
10421 ast_party_redirecting_free(&saved_redirecting);
10422 }
10423
10424 return retval;
10425}
10426
10427static void *channel_cc_params_copy(void *data)
10428{
10429 const struct ast_cc_config_params *src = data;
10431 if (!dest) {
10432 return NULL;
10433 }
10434 ast_cc_copy_config_params(dest, src);
10435 return dest;
10436}
10437
10438static void channel_cc_params_destroy(void *data)
10439{
10440 struct ast_cc_config_params *cc_params = data;
10442}
10443
10445 .type = "Call Completion",
10446 .duplicate = channel_cc_params_copy,
10447 .destroy = channel_cc_params_destroy,
10448};
10449
10451 const struct ast_cc_config_params *base_params)
10452{
10453 struct ast_cc_config_params *cc_params;
10454 struct ast_datastore *cc_datastore;
10455
10456 if (!(cc_params = ast_cc_config_params_init())) {
10457 return -1;
10458 }
10459
10460 if (!(cc_datastore = ast_datastore_alloc(&cc_channel_datastore_info, NULL))) {
10462 return -1;
10463 }
10464
10465 if (base_params) {
10466 ast_cc_copy_config_params(cc_params, base_params);
10467 }
10468 cc_datastore->data = cc_params;
10469 ast_channel_datastore_add(chan, cc_datastore);
10470 return 0;
10471}
10472
10474{
10475 struct ast_datastore *cc_datastore;
10476
10477 if (!(cc_datastore = ast_channel_datastore_find(chan, &cc_channel_datastore_info, NULL))) {
10478 /* If we can't find the datastore, it almost definitely means that the channel type being
10479 * used has not had its driver modified to parse CC config parameters. The best action
10480 * to take here is to create the parameters on the spot with the defaults set.
10481 */
10482 if (ast_channel_cc_params_init(chan, NULL)) {
10483 return NULL;
10484 }
10485 if (!(cc_datastore = ast_channel_datastore_find(chan, &cc_channel_datastore_info, NULL))) {
10486 /* Should be impossible */
10487 return NULL;
10488 }
10489 }
10490
10491 ast_assert(cc_datastore->data != NULL);
10492 return cc_datastore->data;
10493}
10494
10495int ast_channel_get_device_name(struct ast_channel *chan, char *device_name, size_t name_buffer_length)
10496{
10497 int len = name_buffer_length;
10498 char *dash;
10499 if (!ast_channel_queryoption(chan, AST_OPTION_DEVICE_NAME, device_name, &len, 0)) {
10500 return 0;
10501 }
10502
10503 /* Dang. Do it the old-fashioned way */
10504 ast_copy_string(device_name, ast_channel_name(chan), name_buffer_length);
10505 if ((dash = strrchr(device_name, '-'))) {
10506 *dash = '\0';
10507 }
10508
10509 return 0;
10510}
10511
10512int ast_channel_get_cc_agent_type(struct ast_channel *chan, char *agent_type, size_t size)
10513{
10514 int len = size;
10515 char *slash;
10516
10518 return 0;
10519 }
10520
10522 if ((slash = strchr(agent_type, '/'))) {
10523 *slash = '\0';
10524 }
10525 return 0;
10526}
10527
10529{
10530 ao2_unlink(channels, chan);
10531}
10532
10534{
10535 struct ast_bridge *bridge;
10536
10537 bridge = ast_channel_internal_bridge(chan);
10538 if (bridge) {
10539 ao2_ref(bridge, +1);
10540 }
10541 return bridge;
10542}
10543
10545{
10546 return ast_channel_internal_bridge(chan) != NULL;
10547}
10548
10550{
10551 int hangup_flags = ast_channel_softhangup_internal_flag(chan);
10552 int hangup_test = hangup_flags & AST_SOFTHANGUP_ASYNCGOTO;
10553 int unbridge = ast_channel_unbridged(chan);
10554
10555 /* This function should only return true if either the unbridged flag or
10556 * the ASYNCGOTO soft hangup flag is set and when no other soft hangup
10557 * flags are set. Any other soft hangup flags being set should make it
10558 * return false.
10559 */
10560 return ((hangup_test || unbridge) && (hangup_test == hangup_flags));
10561}
10562
10564{
10565 struct ast_channel *peer;
10566 struct ast_bridge *bridge;
10567
10568 /* Get the bridge the channel is in. */
10569 ast_channel_lock(chan);
10570 bridge = ast_channel_get_bridge(chan);
10571 ast_channel_unlock(chan);
10572 if (!bridge) {
10573 return NULL;
10574 }
10575
10576 peer = ast_bridge_peer(bridge, chan);
10577 ao2_ref(bridge, -1);
10578 return peer;
10579}
10580
10582{
10583 struct ast_bridge_channel *bridge_channel;
10584
10585 bridge_channel = ast_channel_internal_bridge_channel(chan);
10586 if (bridge_channel) {
10587 ao2_ref(bridge_channel, +1);
10588 }
10589 return bridge_channel;
10590}
10591
10593{
10594 struct ast_channel *yanked_chan;
10595 struct {
10596 char *accountcode;
10597 char *exten;
10598 char *context;
10599 char *name;
10600 int amaflags;
10601 int priority;
10602 struct ast_format *readformat;
10603 struct ast_format *writeformat;
10604 } my_vars = { 0, };
10605
10606 ast_channel_lock(yankee);
10607 my_vars.accountcode = ast_strdupa(ast_channel_accountcode(yankee));
10608 my_vars.exten = ast_strdupa(ast_channel_exten(yankee));
10609 my_vars.context = ast_strdupa(ast_channel_context(yankee));
10610 my_vars.name = ast_strdupa(ast_channel_name(yankee));
10611 my_vars.amaflags = ast_channel_amaflags(yankee);
10612 my_vars.priority = ast_channel_priority(yankee);
10613 /* The priority as returned by ast_channel_yank is where the channel
10614 * should go if the dialplan is executed on it. If the channel is
10615 * already executing dialplan then the priority currently set is
10616 * where it is currently. We increment it so it becomes where it should
10617 * execute.
10618 */
10620 my_vars.priority++;
10621 }
10622 my_vars.writeformat = ao2_bump(ast_channel_writeformat(yankee));
10623 my_vars.readformat = ao2_bump(ast_channel_readformat(yankee));
10624 ast_channel_unlock(yankee);
10625
10626 /* Do not hold any channel locks while calling channel_alloc() since the function
10627 * locks the channel container when linking the new channel in. */
10628 if (!(yanked_chan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, my_vars.accountcode,
10629 my_vars.exten, my_vars.context, NULL, yankee, my_vars.amaflags,
10630 "Surrogate/%s", my_vars.name))) {
10631 ao2_cleanup(my_vars.writeformat);
10632 ao2_cleanup(my_vars.readformat);
10633 return NULL;
10634 }
10635
10636 /* Make formats okay */
10637 ast_channel_set_readformat(yanked_chan, my_vars.readformat);
10638 ast_channel_set_writeformat(yanked_chan, my_vars.writeformat);
10639 ao2_cleanup(my_vars.readformat);
10640 ao2_cleanup(my_vars.writeformat);
10641 ast_channel_priority_set(yanked_chan, my_vars.priority);
10642
10643 ast_channel_unlock(yanked_chan);
10644
10645 if (ast_channel_move(yanked_chan, yankee)) {
10646 ast_hangup(yanked_chan);
10647 return NULL;
10648 }
10649
10650 return yanked_chan;
10651}
10652
10653/*!
10654 * Mutex that prevents multiple ast_channel_move() operations
10655 * from occurring simultaneously. This is necessary since the
10656 * involved channels have to be locked and unlocked throughout
10657 * the move operation.
10658 *
10659 * The most important data being protected are the masq and masqr
10660 * data on channels. We don't want them getting criss-crossed due
10661 * to multiple moves mucking with them.
10662 */
10664
10665int ast_channel_move(struct ast_channel *dest, struct ast_channel *source)
10666{
10667 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
10669
10670 if (dest == source) {
10671 ast_log(LOG_WARNING, "Can't move channel '%s' into itself!\n",
10672 ast_channel_name(dest));
10673 return -1;
10674 }
10675
10676 ast_channel_lock_both(dest, source);
10677
10680 /* Zombies! Run! */
10682 "Can't move channel. One or both is dead (%s <-- %s)\n",
10683 ast_channel_name(dest), ast_channel_name(source));
10684 ast_channel_unlock(source);
10685 ast_channel_unlock(dest);
10686 return -1;
10687 }
10688
10689 ast_channel_masq_set(dest, source);
10690 ast_channel_masqr_set(source, dest);
10691
10692 blob = ast_json_pack("{s: s}",
10693 "newchanneluniqueid", ast_channel_uniqueid(dest));
10695
10696 ast_channel_unlock(dest);
10697 ast_channel_unlock(source);
10698
10699 channel_do_masquerade(dest, source);
10700 return 0;
10701}
10702
10703static void suppress_datastore_destroy_cb(void *data)
10704{
10705 ao2_cleanup(data);
10706}
10707
10709 .type = "suppressvoice",
10711};
10712
10713static void suppress_framehook_destroy_cb(void *data)
10714{
10715 ao2_cleanup(data);
10716}
10717
10720 unsigned int direction;
10722};
10723
10724static void suppress_framehook_fixup_cb(void *data, int framehook_id, struct ast_channel *old_chan, struct ast_channel *new_chan)
10725{
10726 struct suppress_data *suppress = data;
10727
10728 suppress->framehook_id = framehook_id;
10729}
10730
10731static struct ast_frame *suppress_framehook_event_cb(struct ast_channel *chan, struct ast_frame *frame, enum ast_framehook_event event, void *data)
10732{
10733 struct suppress_data *suppress = data;
10734 int suppress_frame = 0;
10735
10736 if (!frame) {
10737 return NULL;
10738 }
10739
10740 if (frame->frametype != suppress->frametype) {
10741 return frame;
10742 }
10743
10745 suppress_frame = 1;
10746 } else if (event == AST_FRAMEHOOK_EVENT_WRITE && (suppress->direction & AST_MUTE_DIRECTION_WRITE)) {
10747 suppress_frame = 1;
10748 }
10749
10750 if (suppress_frame) {
10751 switch (frame->frametype) {
10752 case AST_FRAME_VOICE:
10754 ast_frfree(frame);
10755 }
10756 frame = &ast_null_frame;
10757 break;
10758 default:
10759 break;
10760 }
10761 }
10762
10763 return frame;
10764}
10765
10767{
10768 switch (frametype) {
10769 case AST_FRAME_VOICE:
10771 default:
10772 return NULL;
10773 }
10774}
10775
10776int ast_channel_suppress(struct ast_channel *chan, unsigned int direction, enum ast_frame_type frametype)
10777{
10778 struct suppress_data *suppress;
10779 const struct ast_datastore_info *datastore_info = NULL;
10780 struct ast_datastore *datastore = NULL;
10781 struct ast_framehook_interface interface = {
10783 .event_cb = suppress_framehook_event_cb,
10784 .destroy_cb = suppress_framehook_destroy_cb,
10785 .chan_fixup_cb = suppress_framehook_fixup_cb,
10786 };
10787 int framehook_id;
10788
10789 if (!(datastore_info = suppress_get_datastore_information(frametype))) {
10790 ast_log(LOG_WARNING, "Attempted to suppress an unsupported frame type (%u).\n", frametype);
10791 return -1;
10792 }
10793
10794 if ((datastore = ast_channel_datastore_find(chan, datastore_info, NULL))) {
10795 suppress = datastore->data;
10796 suppress->direction |= direction;
10797 return 0;
10798 }
10799
10800 if (!(suppress = ao2_alloc(sizeof(*suppress), NULL))) {
10801 ast_log(LOG_WARNING, "Failed to allocate data while attempting to suppress a stream.\n");
10802 return -1;
10803 }
10804
10805 suppress->frametype = frametype;
10806 suppress->direction |= direction;
10807
10808 interface.data = suppress;
10809
10810 framehook_id = ast_framehook_attach(chan, &interface);
10811 if (framehook_id < 0) {
10812 /* Hook attach failed. Get rid of the evidence. */
10813 ast_log(LOG_WARNING, "Failed to attach framehook while attempting to suppress a stream.\n");
10814 ao2_ref(suppress, -1);
10815 return -1;
10816 }
10817
10818 /* One ref for the framehook */
10819 ao2_ref(suppress, +1);
10820
10821 suppress->framehook_id = framehook_id;
10822
10823 if (!(datastore = ast_datastore_alloc(datastore_info, NULL))) {
10824 ast_log(LOG_WARNING, "Failed to allocate datastore while attempting to suppress a stream.\n");
10825 ast_framehook_detach(chan, framehook_id);
10826 ao2_ref(suppress, -1);
10827 return -1;
10828 }
10829
10830 /* the ref provided by the allocation is taken by the datastore */
10831 datastore->data = suppress;
10832
10833 ast_channel_datastore_add(chan, datastore);
10834
10835 return 0;
10836}
10837
10838int ast_channel_unsuppress(struct ast_channel *chan, unsigned int direction, enum ast_frame_type frametype)
10839{
10840 const struct ast_datastore_info *datastore_info = NULL;
10841 struct ast_datastore *datastore = NULL;
10842 struct suppress_data *suppress;
10843
10844 if (!(datastore_info = suppress_get_datastore_information(frametype))) {
10845 ast_log(LOG_WARNING, "Attempted to unsuppress an unsupported frame type (%u).\n", frametype);
10846 return -1;
10847 }
10848
10849 if (!(datastore = ast_channel_datastore_find(chan, datastore_info, NULL))) {
10850 /* Nothing to do! */
10851 return 0;
10852 }
10853
10854 suppress = datastore->data;
10855
10856 suppress->direction &= ~(direction);
10857
10858 if (suppress->direction == 0) {
10859 /* Nothing left to suppress. Bye! */
10860 ast_framehook_detach(chan, suppress->framehook_id);
10861 ast_channel_datastore_remove(chan, datastore);
10862 ast_datastore_free(datastore);
10863 }
10864
10865 return 0;
10866}
10867
10868void ast_channel_end_dtmf(struct ast_channel *chan, char digit, struct timeval start, const char *why)
10869{
10870 int dead;
10871 long duration;
10872
10873 ast_channel_lock(chan);
10876 & ~AST_SOFTHANGUP_ASYNCGOTO);
10877 ast_channel_unlock(chan);
10878 if (dead) {
10879 /* Channel is a zombie or a real hangup. */
10880 return;
10881 }
10882
10883 duration = ast_tvdiff_ms(ast_tvnow(), start);
10884 if (duration < option_dtmfminduration) {
10885 duration = option_dtmfminduration;
10886 }
10887 ast_senddigit_end(chan, digit, duration);
10888 ast_log(LOG_DTMF, "DTMF end '%c' simulated on %s due to %s, duration %ld ms\n",
10889 digit, ast_channel_name(chan), why, duration);
10890}
10891
10892static void features_destroy(void *obj)
10893{
10895}
10896
10898 .type = "bridge-features",
10899 .destroy = features_destroy,
10900};
10901
10903{
10904 struct ast_datastore *datastore;
10905
10907 if (!datastore) {
10908 return NULL;
10909 }
10910 return datastore->data;
10911}
10912
10913static int channel_feature_hooks_set_full(struct ast_channel *chan, struct ast_bridge_features *features, int replace)
10914{
10915 struct ast_datastore *datastore;
10916 struct ast_bridge_features *ds_features;
10917
10919 if (datastore) {
10920 ds_features = datastore->data;
10921 if (replace) {
10922 ast_bridge_features_cleanup(ds_features);
10923 ast_bridge_features_init(ds_features);
10924 }
10925 if (features) {
10926 ast_bridge_features_merge(ds_features, features);
10927 }
10928 return 0;
10929 }
10930
10932 if (!datastore) {
10933 return -1;
10934 }
10935
10936 ds_features = ast_bridge_features_new();
10937 if (!ds_features) {
10938 ast_datastore_free(datastore);
10939 return -1;
10940 }
10941
10942 if (features) {
10943 ast_bridge_features_merge(ds_features, features);
10944 }
10945 datastore->data = ds_features;
10946 ast_channel_datastore_add(chan, datastore);
10947 return 0;
10948}
10949
10951{
10952 return channel_feature_hooks_set_full(chan, features, 0);
10953}
10954
10956{
10957 return channel_feature_hooks_set_full(chan, features, 1);
10958}
10959
10961{
10963}
10964
10966 struct ast_stream_topology *topology, void *change_source)
10967{
10968 int res;
10969
10970 ast_assert(chan != NULL);
10971 ast_assert(topology != NULL);
10972
10973 ast_channel_lock(chan);
10975 ast_channel_unlock(chan);
10976 return -1;
10977 }
10978
10980 ast_debug(2, "%s: Topologies already match. Current: %s Requested: %s\n",
10981 ast_channel_name(chan),
10983 ast_str_tmp(256, ast_stream_topology_to_str(topology, &STR_TMP)));
10984 ast_channel_unlock(chan);
10985 return 0;
10986 }
10987
10989
10990 res = ast_channel_tech(chan)->indicate(chan, AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE, topology, sizeof(topology));
10991 ast_channel_unlock(chan);
10992 return res;
10993}
10994
10996{
10997 ast_assert(chan != NULL);
10998 ast_assert(topology != NULL);
10999
11001 return -1;
11002 }
11003
11004 return ast_channel_tech(chan)->indicate(chan, AST_CONTROL_STREAM_TOPOLOGY_CHANGED, topology, sizeof(topology));
11005}
11006
11008{
11009 int res;
11010 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_STREAM_TOPOLOGY_CHANGED };
11011
11012 ast_assert(chan != NULL);
11013
11014 if (!ast_channel_is_multistream(chan)) {
11015 return -1;
11016 }
11017
11018 ast_channel_lock(chan);
11020 res = ast_queue_frame(chan, &f);
11021 ast_channel_unlock(chan);
11022
11023 return res;
11024}
11025
11026void ast_channel_set_flag(struct ast_channel *chan, unsigned int flag)
11027{
11028 ast_channel_lock(chan);
11030 ast_channel_unlock(chan);
11031}
11032
11033void ast_channel_clear_flag(struct ast_channel *chan, unsigned int flag)
11034{
11035 ast_channel_lock(chan);
11037 ast_channel_unlock(chan);
11038}
Prototypes for public functions only of internal interest,.
void ast_jb_destroy(struct ast_channel *chan)
Destroys jitterbuffer on a channel.
Definition: abstract_jb.c:502
@ AST_ALERT_READ_FATAL
Definition: alertpipe.h:28
static struct aco_type agent_type
char digit
static struct ast_generator gen
jack_status_t status
Definition: app_jack.c:146
const char * str
Definition: app_jack.c:147
char * text
Definition: app_queue.c:1639
enum queue_result id
Definition: app_queue.c:1638
struct sla_ringing_trunk * first
Definition: app_sla.c:332
ast_cond_t cond
Definition: app_sla.c:330
ast_mutex_t lock
Definition: app_sla.c:331
#define var
Definition: ast_expr2f.c:605
Asterisk main include file. File version handling, generic pbx functions.
int ast_register_cleanup(void(*func)(void))
Register a function to be executed before Asterisk gracefully exits.
Definition: clicompat.c:19
int ast_shutting_down(void)
Definition: asterisk.c:1872
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:288
#define ast_free(a)
Definition: astmm.h:180
#define ast_strndup(str, len)
A wrapper for strndup()
Definition: astmm.h:256
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
#define ast_log
Definition: astobj2.c:42
#define ao2_iterator_next(iter)
Definition: astobj2.h:1911
#define ao2_link(container, obj)
Add an object to a container.
Definition: astobj2.h:1532
@ CMP_MATCH
Definition: astobj2.h:1027
@ CMP_STOP
Definition: astobj2.h:1028
#define OBJ_KEY
Definition: astobj2.h:1151
#define OBJ_POINTER
Definition: astobj2.h:1150
@ AO2_ALLOC_OPT_LOCK_NOLOCK
Definition: astobj2.h:367
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition: astobj2.h:363
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container,...
Definition: astobj2.h:1693
void ao2_container_unregister(const char *name)
Unregister a container for CLI stats and integrity check.
int ao2_container_count(struct ao2_container *c)
Returns the number of elements in a container.
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_callback_data(container, flags, cb_fn, arg, data)
Definition: astobj2.h:1723
#define ao2_unlink(container, obj)
Remove an object from a container.
Definition: astobj2.h:1578
#define ao2_link_flags(container, obj, flags)
Add an object to a container.
Definition: astobj2.h:1554
#define ao2_find(container, arg, flags)
Definition: astobj2.h:1736
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
#define ao2_unlock(a)
Definition: astobj2.h:729
#define ao2_replace(dst, src)
Replace one object reference with another cleaning up the original.
Definition: astobj2.h:501
#define ao2_lock(a)
Definition: astobj2.h:717
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ao2_alloc_options(data_size, destructor_fn, options)
Definition: astobj2.h:404
int ao2_container_register(const char *name, struct ao2_container *self, ao2_prnt_obj_fn *prnt_obj)
Register a container for CLI stats and integrity check.
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition: astobj2.h:480
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
int() ao2_callback_data_fn(void *obj, void *arg, void *data, int flags)
Type of a generic callback function.
Definition: astobj2.h:1244
@ OBJ_NOLOCK
Assume that the ao2_container is already locked.
Definition: astobj2.h:1063
@ OBJ_NODATA
Definition: astobj2.h:1044
@ OBJ_MULTIPLE
Definition: astobj2.h:1049
@ OBJ_UNLINK
Definition: astobj2.h:1039
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition: astobj2.h:1303
void() ao2_prnt_fn(void *where, const char *fmt,...)
Print output.
Definition: astobj2.h:1435
Audiohooks Architecture.
struct ast_frame * ast_audiohook_write_list(struct ast_channel *chan, struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *frame)
Pass a frame off to be handled by the audiohook core.
Definition: audiohook.c:1079
@ AST_AUDIOHOOK_DIRECTION_READ
Definition: audiohook.h:49
@ AST_AUDIOHOOK_DIRECTION_WRITE
Definition: audiohook.h:50
int ast_audiohook_write_list_empty(struct ast_audiohook_list *audiohook_list)
Determine if a audiohook_list is empty or not.
Definition: audiohook.c:1071
void ast_audiohook_detach_list(struct ast_audiohook_list *audiohook_list)
Detach audiohooks from list and destroy said list.
Definition: audiohook.c:565
void ast_audiohook_move_all(struct ast_channel *old_chan, struct ast_channel *new_chan)
Move all audiohooks from one channel to another.
Definition: audiohook.c:672
"smart" channels that update automatically if a channel is masqueraded
void ast_autochan_new_channel(struct ast_channel *old_chan, struct ast_channel *new_chan)
Switch what channel autochans point to.
Definition: autochan.c:86
Bridging API.
struct ast_channel * ast_bridge_peer(struct ast_bridge *bridge, struct ast_channel *chan)
Get the channel's bridge peer only if the bridge is two-party.
Definition: bridge.c:4075
void ast_bridge_notify_masquerade(struct ast_channel *chan)
Notify bridging that this channel was just masqueraded.
Definition: bridge.c:1442
int ast_bridge_features_init(struct ast_bridge_features *features)
Initialize bridge features structure.
Definition: bridge.c:3620
struct ast_bridge_features * ast_bridge_features_new(void)
Allocate a new bridge features struct.
Definition: bridge.c:3683
void ast_bridge_features_merge(struct ast_bridge_features *into, const struct ast_bridge_features *from)
Merge one ast_bridge_features into another.
Definition: bridge.c:3595
void ast_bridge_features_cleanup(struct ast_bridge_features *features)
Clean up the contents of a bridge features structure.
Definition: bridge.c:3653
void ast_bridge_features_destroy(struct ast_bridge_features *features)
Destroy an allocated bridge features struct.
Definition: bridge.c:3674
static int tmp()
Definition: bt_open.c:389
CallerID (and other GR30) management and generation Includes code and algorithms from the Zapata libr...
#define AST_PRES_USER_NUMBER_UNSCREENED
Definition: callerid.h:412
#define AST_PRES_UNAVAILABLE
Definition: callerid.h:420
#define AST_PRES_RESTRICTED
Definition: callerid.h:419
#define AST_PRES_ALLOWED
Definition: callerid.h:418
@ AST_CONNECTED_LINE_UPDATE_SOURCE_UNKNOWN
Definition: callerid.h:538
#define AST_PRES_NUMBER_NOT_AVAILABLE
Definition: callerid.h:447
@ AST_REDIRECTING_REASON_UNKNOWN
Definition: callerid.h:485
#define AST_PRES_NUMBER_TYPE
Definition: callerid.h:411
#define AST_PRES_RESTRICTION
Definition: callerid.h:417
#define AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED
Definition: callerid.h:423
Internal Asterisk hangup causes.
#define AST_CAUSE_SWITCH_CONGESTION
Definition: causes.h:123
#define AST_CAUSE_NUMBER_PORTED_NOT_HERE
Definition: causes.h:105
#define AST_CAUSE_CONGESTION
Definition: causes.h:153
#define AST_CAUSE_INVALID_IE_CONTENTS
Definition: causes.h:141
#define AST_CAUSE_UNALLOCATED
Definition: causes.h:98
#define AST_CAUSE_INTERWORKING
Definition: causes.h:146
#define AST_CAUSE_PROTOCOL_ERROR
Definition: causes.h:145
#define AST_CAUSE_NUMBER_CHANGED
Definition: causes.h:112
#define AST_CAUSE_BEARERCAPABILITY_NOTAVAIL
Definition: causes.h:130
#define AST_CAUSE_CALL_AWARDED_DELIVERED
Definition: causes.h:103
#define AST_CAUSE_INVALID_NUMBER_FORMAT
Definition: causes.h:116
#define AST_CAUSE_OUTGOING_CALL_BARRED
Definition: causes.h:127
#define AST_CAUSE_CHAN_NOT_IMPLEMENTED
Definition: causes.h:132
#define AST_CAUSE_WRONG_MESSAGE
Definition: causes.h:139
#define AST_CAUSE_INCOMPATIBLE_DESTINATION
Definition: causes.h:135
#define AST_CAUSE_BEARERCAPABILITY_NOTAUTH
Definition: causes.h:129
#define AST_CAUSE_DESTINATION_OUT_OF_ORDER
Definition: causes.h:115
#define AST_CAUSE_NO_USER_RESPONSE
Definition: causes.h:108
#define AST_CAUSE_NORMAL_TEMPORARY_FAILURE
Definition: causes.h:122
#define AST_CAUSE_MESSAGE_TYPE_NONEXIST
Definition: causes.h:138
#define AST_CAUSE_MANDATORY_IE_LENGTH_ERROR
Definition: causes.h:144
#define AST_CAUSE_REDIRECTED_TO_NEW_DESTINATION
Definition: causes.h:113
#define AST_CAUSE_FACILITY_NOT_SUBSCRIBED
Definition: causes.h:126
#define AST_CAUSE_BEARERCAPABILITY_NOTIMPL
Definition: causes.h:131
#define AST_CAUSE_WRONG_CALL_STATE
Definition: causes.h:142
#define AST_CAUSE_PRE_EMPTED
Definition: causes.h:104
#define AST_CAUSE_REQUESTED_CHAN_UNAVAIL
Definition: causes.h:125
#define AST_CAUSE_NORMAL_CIRCUIT_CONGESTION
Definition: causes.h:120
#define AST_CAUSE_CHANNEL_UNACCEPTABLE
Definition: causes.h:102
#define AST_CAUSE_NOTDEFINED
Definition: causes.h:155
#define AST_CAUSE_CALL_REJECTED
Definition: causes.h:111
#define AST_CAUSE_SUBSCRIBER_ABSENT
Definition: causes.h:110
#define AST_CAUSE_NETWORK_OUT_OF_ORDER
Definition: causes.h:121
#define AST_CAUSE_INVALID_CALL_REFERENCE
Definition: causes.h:134
#define AST_CAUSE_FACILITY_REJECTED
Definition: causes.h:117
#define AST_CAUSE_ANSWERED_ELSEWHERE
Definition: causes.h:114
#define AST_CAUSE_NORMAL_UNSPECIFIED
Definition: causes.h:119
#define AST_CAUSE_FACILITY_NOT_IMPLEMENTED
Definition: causes.h:133
#define AST_CAUSE_INCOMING_CALL_BARRED
Definition: causes.h:128
#define AST_CAUSE_MANDATORY_IE_MISSING
Definition: causes.h:137
#define AST_CAUSE_NOSUCHDRIVER
Definition: causes.h:156
#define AST_CAUSE_ACCESS_INFO_DISCARDED
Definition: causes.h:124
#define AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE
Definition: causes.h:143
#define AST_CAUSE_NO_ROUTE_TRANSIT_NET
Definition: causes.h:99
#define AST_CAUSE_RESPONSE_TO_STATUS_ENQUIRY
Definition: causes.h:118
#define AST_CAUSE_NO_ROUTE_DESTINATION
Definition: causes.h:100
#define AST_CAUSE_BUSY
Definition: causes.h:149
#define AST_CAUSE_INVALID_MSG_UNSPECIFIED
Definition: causes.h:136
#define AST_CAUSE_NO_ANSWER
Definition: causes.h:109
#define AST_CAUSE_NORMAL_CLEARING
Definition: causes.h:106
#define AST_CAUSE_MISDIALLED_TRUNK_PREFIX
Definition: causes.h:101
#define AST_CAUSE_IE_NONEXIST
Definition: causes.h:140
#define AST_CAUSE_USER_BUSY
Definition: causes.h:107
enum cc_state state
Definition: ccss.c:393
#define ast_cc_config_params_init()
Allocate and initialize an ast_cc_config_params structure.
Definition: ccss.h:135
void ast_cc_config_params_destroy(struct ast_cc_config_params *params)
Free memory from CCSS configuration params.
Definition: ccss.c:692
int ast_cc_offer(struct ast_channel *caller_chan)
Offer CC to a caller.
Definition: ccss.c:3716
void ast_cc_copy_config_params(struct ast_cc_config_params *dest, const struct ast_cc_config_params *src)
copy CCSS configuration parameters from one structure to another
Definition: ccss.c:854
void ast_cdr_free(struct ast_cdr *cdr)
Free a CDR record.
Definition: cdr.c:3473
static PGresult * result
Definition: cel_pgsql.c:84
static int match(struct ast_sockaddr *addr, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
Definition: chan_iax2.c:2365
static struct ast_timer * timer
Definition: chan_iax2.c:367
static char language[MAX_LANGUAGE]
Definition: chan_iax2.c:327
unsigned int cos
Definition: chan_iax2.c:359
static const char type[]
Definition: chan_ooh323.c:109
static int indicate(void *data)
Definition: chan_pjsip.c:1334
static int transfer(void *data)
Definition: chan_pjsip.c:2129
static int hangup(void *data)
Definition: chan_pjsip.c:2516
static int answer(void *data)
Definition: chan_pjsip.c:683
static int call(void *data)
Definition: chan_pjsip.c:2391
static void send_text(unsigned char pos, unsigned char inverse, struct unistimsession *pte, const char *text)
void ast_party_subaddress_copy(struct ast_party_subaddress *dest, const struct ast_party_subaddress *src)
Copy the source party subaddress information to the destination party subaddress.
Definition: channel.c:1705
static void channels_shutdown(void)
Definition: channel.c:7992
static void channel_do_masquerade(struct ast_channel *original, struct ast_channel *clonechan)
Masquerade a channel.
Definition: channel.c:6856
int ast_say_number(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options)
says a number
Definition: channel.c:8234
struct varshead * ast_channel_get_manager_vars(struct ast_channel *chan)
Gets the variables for a given channel, as specified by ast_channel_set_manager_vars().
Definition: channel.c:7982
int ast_senddigit_mf_begin(struct ast_channel *chan, char digit)
Send an MF digit to a channel.
Definition: channel.c:4834
int ast_waitfordigit(struct ast_channel *c, int ms)
Waits for a digit.
Definition: channel.c:3175
static int kill_write(struct ast_channel *chan, struct ast_frame *frame)
Definition: channel.c:407
void ast_softhangup_all(void)
Soft hangup all active channels.
Definition: channel.c:493
int ast_channel_request_stream_topology_change(struct ast_channel *chan, struct ast_stream_topology *topology, void *change_source)
Request that the stream topology of a channel change.
Definition: channel.c:10965
void ast_channel_end_dtmf(struct ast_channel *chan, char digit, struct timeval start, const char *why)
Simulate a DTMF end on a broken bridge channel.
Definition: channel.c:10868
void ast_party_redirecting_reason_copy(struct ast_party_redirecting_reason *dest, const struct ast_party_redirecting_reason *src)
Copy the source redirecting reason information to the destination redirecting reason.
Definition: channel.c:2085
struct ast_channel * ast_channel_get_by_exten(const char *exten, const char *context)
Find a channel by extension and context.
Definition: channel.c:1459
static void channel_req_accountcodes(struct ast_channel *chan, const struct ast_channel *requestor, enum ast_channel_requestor_relationship relationship, int precious)
Definition: channel.c:6375
static int indicate_connected_line(struct ast_channel *chan, const void *data, size_t datalen)
Definition: channel.c:4400
void ast_party_name_init(struct ast_party_name *init)
Initialize the given name structure.
Definition: channel.c:1591
char * ast_recvtext(struct ast_channel *chan, int timeout)
Receives a text string from a channel Read a string of text from a channel.
Definition: channel.c:4716
static void generator_write_format_change(struct ast_channel *chan)
Definition: channel.c:2904
enum ast_channel_error ast_channel_errno(void)
Get error code for latest channel operation.
Definition: channel.c:10960
int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params)
Definition: channel.c:2951
struct ast_channel * ast_channel_callback(ao2_callback_data_fn *cb_fn, void *arg, void *data, int ao2_flags)
Call a function with every active channel.
Definition: channel.c:1278
void ast_party_dialed_set_init(struct ast_party_dialed *init, const struct ast_party_dialed *guide)
Initialize the given dialed structure using the given guide for a set update operation.
Definition: channel.c:1950
int ast_channel_get_device_name(struct ast_channel *chan, char *device_name, size_t name_buffer_length)
Get a device name given its channel structure.
Definition: channel.c:10495
struct ast_channel * ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds, int *exception, int *outfd, int *ms)
Wait for x amount of time on a file descriptor to have input.
Definition: channel.c:2988
static int set_format(struct ast_channel *chan, struct ast_format_cap *cap_set, const int direction, int interleaved_stereo)
Definition: channel.c:5592
int ast_auto_answer(struct ast_channel *chan)
Answer a channel, if it's not already answered.
Definition: channel.c:2811
static int silence_generator_generate(struct ast_channel *chan, void *data, int len, int samples)
Definition: channel.c:8134
void ast_party_redirecting_init(struct ast_party_redirecting *init)
Initialize the given redirecting structure.
Definition: channel.c:2122
int ast_write(struct ast_channel *chan, struct ast_frame *fr)
Write a frame to a channel This function writes the given frame to the indicated channel.
Definition: channel.c:5143
int ast_call(struct ast_channel *chan, const char *addr, int timeout)
Make a call.
Definition: channel.c:6460
void ast_channel_set_redirecting(struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update)
Set the redirecting id information in the Asterisk channel.
Definition: channel.c:9118
static void handle_cause(int cause, int *outstate)
Definition: channel.c:5848
void ast_channel_clear_flag(struct ast_channel *chan, unsigned int flag)
Clear a flag on a channel.
Definition: channel.c:11033
int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
Add a datastore to a channel.
Definition: channel.c:2385
static void send_dtmf_begin_event(struct ast_channel *chan, enum DtmfDirection direction, const char digit)
Definition: channel.c:3369
struct ast_channel * ast_call_forward(struct ast_channel *caller, struct ast_channel *orig, int *timeout, struct ast_format_cap *cap, struct outgoing_helper *oh, int *outstate)
Forwards a call to a new channel specified by the original channel's call_forward str....
Definition: channel.c:5897
int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
Remove a datastore from a channel.
Definition: channel.c:2394
void ast_party_id_init(struct ast_party_id *init)
Initialize the given party id structure.
Definition: channel.c:1757
int ast_set_read_format_path(struct ast_channel *chan, struct ast_format *raw_format, struct ast_format *core_format)
Set specific read path on channel.
Definition: channel.c:5487
#define AST_MIN_DTMF_GAP
Definition: channel.c:112
void ast_channel_clear_softhangup(struct ast_channel *chan, int flag)
Clear a set of softhangup flags from a channel.
Definition: channel.c:2432
static void clone_variables(struct ast_channel *original, struct ast_channel *clonechan)
Clone channel variables from 'clone' channel into 'original' channel.
Definition: channel.c:6821
static char * handle_cli_core_show_channeltype(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Show details about a channel driver - CLI command.
Definition: channel.c:326
struct ast_channel_iterator * ast_channel_iterator_by_name_new(const char *name, size_t name_len)
Create a new channel iterator based on name.
Definition: channel.c:1388
int ast_say_digit_str(struct ast_channel *chan, const char *str, const char *ints, const char *lang)
says digits of a string
Definition: channel.c:8258
struct varshead * ast_channel_get_vars(struct ast_channel *chan)
Gets the variables for a given channel, as set using pbx_builtin_setvar_helper().
Definition: channel.c:7910
int ast_prod(struct ast_channel *chan)
Send empty audio to prime a channel driver.
Definition: channel.c:4999
int __ast_answer(struct ast_channel *chan, unsigned int delay)
Answer a channel, with a selectable delay before returning.
Definition: channel.c:2695
static int calc_monitor_jump(int samples, int sample_rate, int seek_rate)
calculates the number of samples to jump forward with in a monitor stream.
Definition: channel.c:3511
static struct ast_frame * kill_exception(struct ast_channel *chan)
Definition: channel.c:401
static int ast_channel_make_compatible_helper(struct ast_channel *from, struct ast_channel *to)
Set up translation from one channel to another.
Definition: channel.c:6640
void ast_party_number_init(struct ast_party_number *init)
Initialize the given number structure.
Definition: channel.c:1644
static void suppress_framehook_fixup_cb(void *data, int framehook_id, struct ast_channel *old_chan, struct ast_channel *new_chan)
Definition: channel.c:10724
void ast_hangup(struct ast_channel *chan)
Hangup a channel.
Definition: channel.c:2541
void ast_channel_set_caller(struct ast_channel *chan, const struct ast_party_caller *caller, const struct ast_set_party_caller *update)
Set the caller id information in the Asterisk channel.
Definition: channel.c:7358
static int tonepair_generator(struct ast_channel *chan, void *data, int len, int samples)
Definition: channel.c:7528
int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
Turn on music on hold on a given channel.
Definition: channel.c:7765
void ast_moh_cleanup(struct ast_channel *chan)
Definition: channel.c:7781
int ast_raw_answer_with_stream_topology(struct ast_channel *chan, struct ast_stream_topology *topology)
Answer a channel passing in a stream topology.
Definition: channel.c:2639
int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
Reads multiple digits.
Definition: channel.c:6557
int ast_channel_sendurl(struct ast_channel *chan, const char *url)
Sends a URL on a given link Send URL on link.
Definition: channel.c:6634
struct ast_channel_iterator * ast_channel_iterator_destroy(struct ast_channel_iterator *i)
Destroy a channel iterator.
Definition: channel.c:1360
int ast_queue_hangup(struct ast_channel *chan)
Queue a hangup frame for channel.
Definition: channel.c:1150
static int ast_channel_by_exten_cb(void *obj, void *arg, void *data, int flags)
Definition: channel.c:1306
struct ast_channel * ast_channel_bridge_peer(struct ast_channel *chan)
Get the channel's bridge peer only if the bridge is two-party.
Definition: channel.c:10563
int ast_transfer_protocol(struct ast_channel *chan, char *dest, int *protocol)
Transfer a call to dest, if the channel supports transfer.
Definition: channel.c:6497
static int indicate_redirecting(struct ast_channel *chan, const void *data, size_t datalen)
Definition: channel.c:4455
static void(* ast_moh_cleanup_ptr)(struct ast_channel *)
Definition: channel.c:7747
static int set_security_requirements(const struct ast_channel *requestor, struct ast_channel *out)
Definition: channel.c:6178
static int does_id_conflict(const char *uniqueid)
Definition: channel.c:711
static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
Definition: channel.c:3412
void ast_party_subaddress_set_init(struct ast_party_subaddress *init, const struct ast_party_subaddress *guide)
Initialize the given party subaddress structure using the given guide for a set update operation.
Definition: channel.c:1719
void ast_channel_set_connected_line(struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update)
Set the connected line information in the Asterisk channel.
Definition: channel.c:8307
int ast_senddigit_begin(struct ast_channel *chan, char digit)
Send a DTMF digit to a channel.
Definition: channel.c:4873
static int channel_has_external_vars(struct external_vars *channelvars)
Definition: channel.c:7843
int ast_party_id_presentation(const struct ast_party_id *id)
Determine the overall presentation value for the given party.
Definition: channel.c:1821
static int party_subaddress_build_data(unsigned char *data, size_t datalen, const struct ast_party_subaddress *subaddress, const char *label, const struct ast_party_subaddress_ies *ies)
Definition: channel.c:8495
void ast_party_number_copy(struct ast_party_number *dest, const struct ast_party_number *src)
Copy the source party number information to the destination party number.
Definition: channel.c:1652
static int namedgroup_cmp_cb(void *obj, void *arg, int flags)
Comparison function used for named group container.
Definition: channel.c:7658
void ast_channel_unlink(struct ast_channel *chan)
Remove a channel from the global channels container.
Definition: channel.c:10528
int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
Queue one or more frames to a channel's frame queue.
Definition: channel.c:1139
void ast_party_number_set(struct ast_party_number *dest, const struct ast_party_number *src)
Set the source party number information into the destination party number.
Definition: channel.c:1674
void ast_party_subaddress_init(struct ast_party_subaddress *init)
Initialize the given subaddress structure.
Definition: channel.c:1697
int ast_channel_has_hook_requiring_audio(struct ast_channel *chan)
Check if the channel has any active hooks that require audio.
Definition: channel.c:2524
int ast_readstring_full(struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
Definition: channel.c:6562
static const struct ast_datastore_info suppress_datastore_voice
Definition: channel.c:10708
void ast_party_connected_line_free(struct ast_party_connected_line *doomed)
Destroy the connected line information contents.
Definition: channel.c:2072
static const struct ast_datastore_info plc_ds_info
Definition: channel.c:5047
int64_t ast_channel_get_up_time_ms(struct ast_channel *chan)
Obtain how long it has been since the channel was answered in ms.
Definition: channel.c:2835
void ast_channel_set_manager_vars(size_t varc, char **vars)
Sets the variables to be stored in the manager_vars field of all snapshots.
Definition: channel.c:7886
int ast_sendtext_data(struct ast_channel *chan, struct ast_msg_data *msg)
Sends text to a channel in an ast_msg_data structure wrapper with ast_sendtext as fallback.
Definition: channel.c:4750
static int party_name_build_data(unsigned char *data, size_t datalen, const struct ast_party_name *name, const char *label, const struct ast_party_name_ies *ies)
Definition: channel.c:8347
DtmfDirection
Definition: channel.c:3352
@ DTMF_SENT
Definition: channel.c:3354
@ DTMF_RECEIVED
Definition: channel.c:3353
int ast_set_read_format_from_cap(struct ast_channel *chan, struct ast_format_cap *cap)
Sets read format on channel chan from capabilities Set read format for channel to whichever component...
Definition: channel.c:5779
int ast_tonepair_start(struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
Definition: channel.c:7581
void ast_channel_set_caller_event(struct ast_channel *chan, const struct ast_party_caller *caller, const struct ast_set_party_caller *update)
Set the caller id information in the Asterisk channel and generate an AMI event if the caller id name...
Definition: channel.c:7371
static char * handle_cli_core_show_channeltypes(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Show channel types - CLI command.
Definition: channel.c:261
int ast_senddigit(struct ast_channel *chan, char digit, unsigned int duration)
Send a DTMF digit to a channel.
Definition: channel.c:4973
#define AST_DEFAULT_EMULATE_DTMF_DURATION
Definition: channel.c:102
void ast_party_redirecting_set(struct ast_party_redirecting *dest, const struct ast_party_redirecting *src, const struct ast_set_party_redirecting *update)
Set the redirecting information based on another redirecting source.
Definition: channel.c:2166
const struct ast_channel_tech ast_kill_tech
Kill the channel channel driver technology descriptor.
Definition: channel.c:434
int ast_channel_make_compatible(struct ast_channel *chan, struct ast_channel *peer)
Make the frame formats of two channels compatible.
Definition: channel.c:6719
int ast_channel_queryoption(struct ast_channel *chan, int option, void *data, int *datalen, int block)
Checks the value of an option.
Definition: channel.c:7441
AST_THREADSTORAGE_RAW(in_intercept_routine)
struct varshead * ast_channel_get_ari_vars(struct ast_channel *chan)
Gets the variables for a given channel, as specified by ast_channel_set_ari_vars().
Definition: channel.c:7987
static void queue_dtmf_readq(struct ast_channel *chan, struct ast_frame *f)
Definition: channel.c:3466
static int ast_channel_hash_cb(const void *obj, const int flags)
Definition: channel.c:7787
static void * channel_cc_params_copy(void *data)
Definition: channel.c:10427
static int deactivate_silence_generator(struct ast_channel *chan)
Definition: channel.c:8186
static void tonepair_release(struct ast_channel *chan, void *params)
Definition: channel.c:7486
static struct varshead * channel_get_external_vars(struct external_vars *channelvars, struct ast_channel *chan)
Definition: channel.c:7935
int ast_channel_setoption(struct ast_channel *chan, int option, void *data, int datalen, int block)
Sets an option on a channel.
Definition: channel.c:7421
void ast_moh_stop(struct ast_channel *chan)
Turn off music on hold on a given channel.
Definition: channel.c:7775
void ast_party_id_free(struct ast_party_id *doomed)
Destroy the party id contents.
Definition: channel.c:1811
void ast_channel_unregister(const struct ast_channel_tech *tech)
Unregister channel driver.
Definition: channel.c:570
static const struct ast_datastore_info * suppress_get_datastore_information(enum ast_frame_type frametype)
Definition: channel.c:10766
void ast_party_subaddress_set(struct ast_party_subaddress *dest, const struct ast_party_subaddress *src)
Set the source party subaddress information into the destination party subaddress.
Definition: channel.c:1727
int ast_waitfor_n_fd(int *fds, int n, int *ms, int *exception)
Wait for x amount of time on a file descriptor to have input.
Definition: channel.c:2980
int ast_channel_stream_topology_changed(struct ast_channel *chan, struct ast_stream_topology *topology)
Provide notice to a channel that the stream topology has changed.
Definition: channel.c:10995
int ast_set_write_format_from_cap(struct ast_channel *chan, struct ast_format_cap *cap)
Sets write format on channel chan Set write format for channel to whichever component of "format" is ...
Definition: channel.c:5820
void ast_party_id_set(struct ast_party_id *dest, const struct ast_party_id *src, const struct ast_set_party_id *update)
Set the source party id information into the destination party id.
Definition: channel.c:1788
struct ast_channel * ast_channel_iterator_next(struct ast_channel_iterator *i)
Get the next channel for a channel iterator.
Definition: channel.c:1422
void ast_set_variables(struct ast_channel *chan, struct ast_variable *vars)
adds a list of channel variables to a channel
Definition: channel.c:8114
struct ast_namedgroups * ast_ref_namedgroups(struct ast_namedgroups *groups)
Definition: channel.c:7737
static const struct ast_channel_tech null_tech
Definition: channel.c:702
int ast_channel_feature_hooks_replace(struct ast_channel *chan, struct ast_bridge_features *features)
Sets the channel-attached features a channel has access to upon being bridged.
Definition: channel.c:10955
static void silence_generator_release(struct ast_channel *chan, void *data)
Definition: channel.c:8129
static int namedgroup_hash_cb(const void *obj, const int flags)
Hashing function used for named group container.
Definition: channel.c:7667
struct ast_silence_generator * ast_channel_start_silence_generator(struct ast_channel *chan)
Starts a silence generator on the given channel.
Definition: channel.c:8163
static int chancount
Definition: channel.c:93
static void(* ast_moh_stop_ptr)(struct ast_channel *)
Definition: channel.c:7746
void ast_party_connected_line_copy(struct ast_party_connected_line *dest, const struct ast_party_connected_line *src)
Copy the source connected line information to the destination connected line.
Definition: channel.c:2031
int ast_recvchar(struct ast_channel *chan, int timeout)
Receives a text character from a channel.
Definition: channel.c:4705
static struct external_vars ari_vars
Definition: channel.c:7831
struct ast_channel * ast_channel_yank(struct ast_channel *yankee)
Gain control of a channel in the system.
Definition: channel.c:10592
int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
Queue a control frame.
Definition: channel.c:1231
int ast_channel_cc_params_init(struct ast_channel *chan, const struct ast_cc_config_params *base_params)
Set up datastore with CCSS parameters for a channel.
Definition: channel.c:10450
int ast_say_ordinal(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options)
says an ordinal number
Definition: channel.c:8240
int ast_channel_get_intercept_mode(void)
Am I currently running an intercept dialplan routine.
Definition: channel.c:10332
void ast_party_connected_line_set(struct ast_party_connected_line *dest, const struct ast_party_connected_line *src, const struct ast_set_party_connected_line *update)
Set the connected line information based on another connected line source.
Definition: channel.c:2054
int ast_write_stream(struct ast_channel *chan, int stream_num, struct ast_frame *fr)
Write a frame to a stream This function writes the given frame to the indicated stream on the channel...
Definition: channel.c:5148
void ast_channel_stop_silence_generator(struct ast_channel *chan, struct ast_silence_generator *state)
Stops a previously-started silence generator on the given channel.
Definition: channel.c:8209
int ast_settimeout_full(struct ast_channel *c, unsigned int rate, int(*func)(const void *data), void *data, unsigned int is_ao2_obj)
Definition: channel.c:3185
static int should_skip_dtmf(struct ast_channel *chan)
Determine whether or not we should ignore DTMF in the readq.
Definition: channel.c:3484
void ast_party_dialed_init(struct ast_party_dialed *init)
Initialize the given dialed structure.
Definition: channel.c:1928
void ast_party_caller_copy(struct ast_party_caller *dest, const struct ast_party_caller *src)
Copy the source caller information to the destination caller.
Definition: channel.c:1986
int ast_setstate(struct ast_channel *chan, enum ast_channel_state state)
Change the state of a channel.
Definition: channel.c:7385
void ast_party_redirecting_reason_set(struct ast_party_redirecting_reason *dest, const struct ast_party_redirecting_reason *src)
Set the redirecting reason information based on another redirecting reason source.
Definition: channel.c:2102
int ast_namedgroups_intersect(struct ast_namedgroups *a, struct ast_namedgroups *b)
Return TRUE if group a and b contain at least one common groupname.
Definition: channel.c:8089
int ast_channel_datastore_inherit(struct ast_channel *from, struct ast_channel *to)
Inherit datastores from a parent to a child.
Definition: channel.c:2368
char * ast_transfercapability2str(int transfercapability)
Gives the string form of a given transfer capability.
Definition: channel.c:672
void ast_channel_undefer_dtmf(struct ast_channel *chan)
Unset defer DTMF flag on channel.
Definition: channel.c:1271
static void deactivate_generator_nolock(struct ast_channel *chan)
Definition: channel.c:2877
void ast_channel_req_accountcodes(struct ast_channel *chan, const struct ast_channel *requestor, enum ast_channel_requestor_relationship relationship)
Setup new channel accountcodes from the requestor channel after ast_request().
Definition: channel.c:6433
void ast_deactivate_generator(struct ast_channel *chan)
Definition: channel.c:2893
static void channel_cc_params_destroy(void *data)
Definition: channel.c:10438
void ast_party_id_merge_copy(struct ast_party_id *dest, struct ast_party_id *base, struct ast_party_id *overlay)
Copy a merge of a given party id into another given party id to a given destination party id.
Definition: channel.c:1920
struct ast_channel_iterator * ast_channel_iterator_by_exten_new(const char *exten, const char *context)
Create a new channel iterator based on extension.
Definition: channel.c:1368
int ast_check_hangup_locked(struct ast_channel *chan)
Definition: channel.c:459
static const struct causes_map causes[]
Definition: channel.c:136
static void plc_ds_destroy(void *data)
Definition: channel.c:5040
int ast_channel_cmpwhentohangup_tv(struct ast_channel *chan, struct timeval offset)
Compare a offset with when to hangup channel.
Definition: channel.c:523
unsigned long global_fin
Definition: channel.c:95
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 struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, enum ama_flags amaflag, struct ast_endpoint *endpoint, const char *file, int line, const char *function, const char *name_fmt,...)
Create a channel structure.
Definition: channel.c:954
void ast_install_music_functions(int(*start_ptr)(struct ast_channel *, const char *, const char *), void(*stop_ptr)(struct ast_channel *), void(*cleanup_ptr)(struct ast_channel *))
Definition: channel.c:7749
char * ast_print_group(char *buf, int buflen, ast_group_t group)
Print call group and pickup group —.
Definition: channel.c:8030
static void varshead_dtor(void *obj)
Destructor for lists of variables.
Definition: channel.c:7900
struct ast_channel * ast_channel_get_by_name_prefix(const char *name, size_t name_len)
Find a channel by a name prefix.
Definition: channel.c:1434
void ast_party_redirecting_reason_set_init(struct ast_party_redirecting_reason *init, const struct ast_party_redirecting_reason *guide)
Initialize the given redirecting reason structure using the given guide for a set update operation.
Definition: channel.c:2096
int ast_set_write_format_interleaved_stereo(struct ast_channel *chan, struct ast_format *format)
Sets write format for a channel. All internal data will than be handled in an interleaved format....
Definition: channel.c:5784
void ast_party_caller_set(struct ast_party_caller *dest, const struct ast_party_caller *src, const struct ast_set_party_caller *update)
Set the caller information based on another caller source.
Definition: channel.c:2007
int ast_channel_suppress(struct ast_channel *chan, unsigned int direction, enum ast_frame_type frametype)
Suppress passing of a frame type on a channel.
Definition: channel.c:10776
int ast_channel_feature_hooks_append(struct ast_channel *chan, struct ast_bridge_features *features)
Appends to the channel-attached features a channel has access to upon being bridged.
Definition: channel.c:10950
static int safe_sleep_conditional(struct ast_channel *chan, int timeout_ms, int(*cond)(void *), void *data, unsigned int generate_silence)
Wait, look for hangups and condition arg.
Definition: channel.c:1498
static void __ast_change_name_nolink(struct ast_channel *chan, const char *newname)
this function simply changes the name of the channel and issues a manager_event with out unlinking an...
Definition: channel.c:6741
void ast_channel_softhangup_withcause_locked(struct ast_channel *chan, int causecode)
Lock the given channel, then request softhangup on the channel with the given causecode.
Definition: channel.c:468
int ast_say_digits(struct ast_channel *chan, int num, const char *ints, const char *lang)
says digits
Definition: channel.c:8252
int ast_undestroyed_channels(void)
Definition: channel.c:504
struct ast_frame * ast_read(struct ast_channel *chan)
Reads a frame.
Definition: channel.c:4256
void ast_party_connected_line_collect_caller(struct ast_party_connected_line *connected, struct ast_party_caller *caller)
Collect the caller party information into a connected line structure.
Definition: channel.c:2063
int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control, const void *data, size_t datalen)
Queue a control frame with payload.
Definition: channel.c:1238
struct ast_bridge_features * ast_channel_feature_hooks_get(struct ast_channel *chan)
Gets the channel-attached features a channel has access to upon being bridged.
Definition: channel.c:10902
void ast_channel_update_connected_line(struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update)
Indicate that the connected line information has changed.
Definition: channel.c:9092
int ast_senddigit_mf_end(struct ast_channel *chan)
End sending an MF digit to a channel.
Definition: channel.c:4942
int ast_channel_move(struct ast_channel *dest, struct ast_channel *source)
Move a channel from its current location to a new location.
Definition: channel.c:10665
void ast_channel_queue_redirecting_update(struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update)
Queue a redirecting update frame on a channel.
Definition: channel.c:10296
void ast_party_redirecting_reason_init(struct ast_party_redirecting_reason *init)
Initialize the given redirecting reason structure.
Definition: channel.c:2079
int ast_senddigit_external(struct ast_channel *chan, char digit, unsigned int duration)
Send a DTMF digit to a channel from an external thread.
Definition: channel.c:4986
int ast_sendtext(struct ast_channel *chan, const char *text)
Sends text to a channel.
Definition: channel.c:4808
struct ast_channel * ast_request_and_dial(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int timeout, int *outstate, const char *cidnum, const char *cidname)
Request a channel of a given type, with data as optional information used by the low level module and...
Definition: channel.c:6173
struct ast_frame * ast_read_stream(struct ast_channel *chan)
Reads a frame, but does not filter to just the default streams.
Definition: channel.c:4261
void ast_party_caller_set_init(struct ast_party_caller *init, const struct ast_party_caller *guide)
Initialize the given caller structure using the given guide for a set update operation.
Definition: channel.c:1999
void ast_party_id_set_init(struct ast_party_id *init, const struct ast_party_id *guide)
Initialize the given party id structure using the given guide for a set update operation.
Definition: channel.c:1780
void ast_party_name_free(struct ast_party_name *doomed)
Destroy the party name contents.
Definition: channel.c:1638
@ AST_CONNECTED_LINE_NUMBER_VALID
Definition: channel.c:8679
@ AST_CONNECTED_LINE_SOURCE
Definition: channel.c:8665
@ AST_CONNECTED_LINE_PRIV_SUBADDRESS_VALID
Definition: channel.c:8692
@ AST_CONNECTED_LINE_PRIV_SUBADDRESS_ODD_EVEN
Definition: channel.c:8691
@ AST_CONNECTED_LINE_PRIV_NAME_VALID
Definition: channel.c:8686
@ AST_CONNECTED_LINE_PRIV_SUBADDRESS_TYPE
Definition: channel.c:8690
@ AST_CONNECTED_LINE_PRIV_NUMBER_PRESENTATION
Definition: channel.c:8684
@ AST_CONNECTED_LINE_NAME_CHAR_SET
Definition: channel.c:8677
@ AST_CONNECTED_LINE_SUBADDRESS_VALID
Definition: channel.c:8669
@ AST_CONNECTED_LINE_SUBADDRESS_ODD_EVEN
Definition: channel.c:8668
@ AST_CONNECTED_LINE_SUBADDRESS
Definition: channel.c:8666
@ AST_CONNECTED_LINE_PRIV_NUMBER_PLAN
Definition: channel.c:8682
@ AST_CONNECTED_LINE_NUMBER
Definition: channel.c:8661
@ AST_CONNECTED_LINE_ID_PRESENTATION
Definition: channel.c:8664
@ AST_CONNECTED_LINE_PRIV_NAME_PRESENTATION
Definition: channel.c:8688
@ AST_CONNECTED_LINE_PRIV_NAME
Definition: channel.c:8685
@ AST_CONNECTED_LINE_TAG
Definition: channel.c:8670
@ AST_CONNECTED_LINE_PRIV_NUMBER_VALID
Definition: channel.c:8683
@ AST_CONNECTED_LINE_NUMBER_PRESENTATION
Definition: channel.c:8680
@ AST_CONNECTED_LINE_PRIV_NAME_CHAR_SET
Definition: channel.c:8687
@ AST_CONNECTED_LINE_NAME
Definition: channel.c:8662
@ AST_CONNECTED_LINE_NAME_PRESENTATION
Definition: channel.c:8678
@ AST_CONNECTED_LINE_SUBADDRESS_TYPE
Definition: channel.c:8667
@ AST_CONNECTED_LINE_PRIV_SUBADDRESS
Definition: channel.c:8689
@ AST_CONNECTED_LINE_PRIV_TAG
Definition: channel.c:8693
@ AST_CONNECTED_LINE_NAME_VALID
Definition: channel.c:8676
@ AST_CONNECTED_LINE_PRIV_NUMBER
Definition: channel.c:8681
@ AST_CONNECTED_LINE_NUMBER_PLAN
Definition: channel.c:8663
@ AST_CONNECTED_LINE_VERSION
Definition: channel.c:8671
void ast_channel_set_ari_vars(size_t varc, char **vars)
Sets the variables to be stored in the ari_vars field of all snapshots.
Definition: channel.c:7891
void ast_party_dialed_free(struct ast_party_dialed *doomed)
Destroy the dialed party contents.
Definition: channel.c:1971
int ast_say_money_str(struct ast_channel *chan, const char *str, const char *ints, const char *lang)
function to pronounce monetary amounts
Definition: channel.c:8264
void ast_set_callerid(struct ast_channel *chan, const char *cid_num, const char *cid_name, const char *cid_ani)
Set caller ID number, name and ANI and generate AMI event.
Definition: channel.c:7333
int ast_channel_redirecting_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const void *redirecting_info, int is_frame)
Run a redirecting interception subroutine and update a channel's redirecting information.
Definition: channel.c:10382
void ast_channel_inherit_variables(const struct ast_channel *parent, struct ast_channel *child)
Inherits channel variable from parent to child channel.
Definition: channel.c:6770
static ast_mutex_t channel_move_lock
Definition: channel.c:10663
static int namedgroup_match(void *obj, void *arg, int flags)
Definition: channel.c:8079
int ast_queue_frame_head(struct ast_channel *chan, struct ast_frame *fin)
Queue one or more frames to the head of a channel's frame queue.
Definition: channel.c:1144
static const struct ast_datastore_info cc_channel_datastore_info
Definition: channel.c:10444
static int channel_feature_hooks_set_full(struct ast_channel *chan, struct ast_bridge_features *features, int replace)
Definition: channel.c:10913
struct ast_frame * ast_read_stream_noaudio(struct ast_channel *chan)
Reads a frame, but does not filter to just the default streams, returning AST_FRAME_NULL frame if aud...
Definition: channel.c:4271
int ast_channel_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen)
Sends HTML on given channel Send HTML or URL on link.
Definition: channel.c:6627
struct ast_channel * __ast_request_and_dial(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int timeout, int *outstate, const char *cid_num, const char *cid_name, struct outgoing_helper *oh)
Request a channel of a given type, with data as optional information used by the low level module and...
Definition: channel.c:5975
void ast_party_redirecting_set_init(struct ast_party_redirecting *init, const struct ast_party_redirecting *guide)
Initialize the given redirecting id structure using the given guide for a set update operation.
Definition: channel.c:2153
int ast_set_read_format(struct ast_channel *chan, struct ast_format *format)
Sets read format on channel chan.
Definition: channel.c:5761
static void free_external_channelvars(struct external_vars *channelvars)
Definition: channel.c:7833
void ast_party_name_set_init(struct ast_party_name *init, const struct ast_party_name *guide)
Initialize the given party name structure using the given guide for a set update operation.
Definition: channel.c:1613
int ast_say_enumeration(struct ast_channel *chan, int num, const char *ints, const char *language, const char *options)
says an enumeration
Definition: channel.c:8246
int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
Queue a hangup frame for channel.
Definition: channel.c:1166
int ast_connected_line_parse_data(const unsigned char *data, size_t datalen, struct ast_party_connected_line *connected)
Parse connected line indication frame data.
Definition: channel.c:8784
void ast_party_caller_free(struct ast_party_caller *doomed)
Destroy the caller party contents.
Definition: channel.c:2015
struct ast_channel * __ast_dummy_channel_alloc(const char *file, int line, const char *function)
Definition: channel.c:975
const char * ast_cause2str(int cause)
Gives the string form of a given hangup cause.
Definition: channel.c:612
const char * ast_channel_amaflags2string(enum ama_flags flag)
Convert the enum representation of an AMA flag to a string representation.
Definition: channel.c:4372
void ast_party_dialed_copy(struct ast_party_dialed *dest, const struct ast_party_dialed *src)
Copy the source dialed party information to the destination dialed party.
Definition: channel.c:1936
int ast_active_channels(void)
returns number of active/allocated channels
Definition: channel.c:499
static struct ast_frame * kill_read(struct ast_channel *chan)
Definition: channel.c:395
struct ast_channel * ast_request_with_stream_topology(const char *type, struct ast_stream_topology *topology, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int *cause)
Requests a channel (specifying stream topology)
Definition: channel.c:6358
static const struct set_format_access set_format_access_write
Definition: channel.c:5581
struct ast_namedgroups * ast_get_namedgroups(const char *s)
Create an ast_namedgroups set with group names from comma separated string.
Definition: channel.c:7674
static struct ast_generator tonepair
Definition: channel.c:7575
static int generator_force(const void *data)
Definition: channel.c:2916
static void call_forward_inherit(struct ast_channel *new_chan, struct ast_channel *parent, struct ast_channel *orig)
Definition: channel.c:5869
static void adjust_frame_for_plc(struct ast_channel *chan, struct ast_frame *frame, struct ast_datastore *datastore)
Definition: channel.c:5052
void ast_uninstall_music_functions(void)
Definition: channel.c:7758
static void channel_set_intercept_mode(int in_intercept_mode)
Definition: channel.c:10321
int ast_channels_init(void)
Definition: channel.c:8006
int ast_waitfordigit_full(struct ast_channel *c, int timeout_ms, const char *breakon, int audiofd, int cmdfd)
Wait for a digit Same as ast_waitfordigit() with audio fd for outputting read audio and ctrlfd to mon...
Definition: channel.c:3239
int ast_check_hangup(struct ast_channel *chan)
Checks to see if a channel is needing hang up.
Definition: channel.c:445
static void prnt_channel_key(void *v_obj, void *where, ao2_prnt_fn *prnt)
Definition: channel.c:7809
int ast_say_character_str(struct ast_channel *chan, const char *str, const char *ints, const char *lang, enum ast_say_case_sensitivity sensitivity)
function to pronounce character and phonetic strings
Definition: channel.c:8270
static struct external_vars ami_vars
Definition: channel.c:7830
void ast_party_name_set(struct ast_party_name *dest, const struct ast_party_name *src)
Set the source party name information into the destination party name.
Definition: channel.c:1621
static void features_destroy(void *obj)
Definition: channel.c:10892
void ast_set_party_id_all(struct ast_set_party_id *update_id)
Set the update marker to update all information of a corresponding party id.
Definition: channel.c:1750
int ast_channel_is_bridged(const struct ast_channel *chan)
Determine if a channel is in a bridge.
Definition: channel.c:10544
static int kill_hangup(struct ast_channel *chan)
Definition: channel.c:419
void ast_party_dialed_set(struct ast_party_dialed *dest, const struct ast_party_dialed *src)
Set the dialed information based on another dialed source.
Definition: channel.c:1958
const char * ast_channel_reason2str(int reason)
return an english explanation of the code returned thru __ast_request_and_dial's 'outstate' argument
Definition: channel.c:5825
struct ast_frame * ast_read_noaudio(struct ast_channel *chan)
Reads a frame, returning AST_FRAME_NULL frame if audio.
Definition: channel.c:4266
int64_t ast_channel_get_duration_ms(struct ast_channel *chan)
Obtain how long it's been, in milliseconds, since the channel was created.
Definition: channel.c:2820
struct ast_bridge * ast_channel_get_bridge(const struct ast_channel *chan)
Get the bridge associated with a channel.
Definition: channel.c:10533
static void suppress_datastore_destroy_cb(void *data)
Definition: channel.c:10703
static struct ast_channel * __ast_channel_alloc_ap(int needqueue, int state, const char *cid_num, const char *cid_name, const char *acctcode, const char *exten, const char *context, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, enum ama_flags amaflag, struct ast_endpoint *endpoint, const char *file, int line, const char *function, const char *name_fmt, va_list ap)
Create a new channel structure.
Definition: channel.c:733
struct ast_channel * ast_channel_release(struct ast_channel *chan)
Unlink and release reference to a channel.
Definition: channel.c:1584
static int ast_channel_softhangup_cb(void *obj, void *arg, int flags)
Definition: channel.c:484
int ast_redirecting_build_data(unsigned char *data, size_t datalen, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update)
Build the redirecting id data frame.
Definition: channel.c:9267
void ast_set_hangupsource(struct ast_channel *chan, const char *source, int force)
Set the source of the hangup in this channel and it's bridge.
Definition: channel.c:2499
void ast_channel_set_flag(struct ast_channel *chan, unsigned int flag)
Set a flag on a channel.
Definition: channel.c:11026
int ast_softhangup(struct ast_channel *chan, int cause)
Softly hangup a channel, lock.
Definition: channel.c:2471
static void send_flash_event(struct ast_channel *chan)
Definition: channel.c:3402
int ast_write_video(struct ast_channel *chan, struct ast_frame *fr)
Write video frame to a channel This function writes the given frame to the indicated channel.
Definition: channel.c:5016
static void send_dtmf_end_event(struct ast_channel *chan, enum DtmfDirection direction, const char digit, long duration_ms)
Definition: channel.c:3385
void ast_channel_name_to_dial_string(char *channel_name)
Removes the trailing identifiers from a channel name string.
Definition: channel.c:6838
void ast_channel_hangupcause_hash_set(struct ast_channel *chan, const struct ast_control_pvt_cause_code *cause_code, int datalen)
Sets the HANGUPCAUSE hash and optionally the SIP_CAUSE hash on the given channel.
Definition: channel.c:4345
int ast_queue_unhold(struct ast_channel *chan)
Queue an unhold frame.
Definition: channel.c:1216
static void destroy_hooks(struct ast_channel *chan)
Definition: channel.c:2530
int ast_channel_connected_line_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const void *connected_info, int is_frame)
Run a connected line interception subroutine and update a channel's connected line information.
Definition: channel.c:10337
void ast_channel_update_redirecting(struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update)
Indicate that the redirecting id has changed.
Definition: channel.c:10283
int ast_channel_has_manager_vars(void)
Return whether or not any manager variables have been set.
Definition: channel.c:7854
void ast_party_id_reset(struct ast_party_id *id)
Destroy and initialize the given party id structure.
Definition: channel.c:1896
void ast_party_id_invalidate(struct ast_party_id *id)
Invalidate all components of the given party id.
Definition: channel.c:1889
int ast_queue_hold(struct ast_channel *chan, const char *musicclass)
Queue a hold frame.
Definition: channel.c:1191
int ast_connected_line_build_data(unsigned char *data, size_t datalen, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update)
Build the connected line information data frame.
Definition: channel.c:8696
int ast_senddigit_end(struct ast_channel *chan, char digit, unsigned int duration)
Send a DTMF digit to a channel.
Definition: channel.c:4923
int ast_channel_has_ari_vars(void)
Return whether or not any ARI variables have been set.
Definition: channel.c:7859
int ast_channel_register(const struct ast_channel_tech *tech)
Register a new telephony channel in Asterisk.
Definition: channel.c:539
int ast_say_phonetic_str(struct ast_channel *chan, const char *str, const char *ints, const char *lang)
Definition: channel.c:8276
struct ast_party_id ast_party_id_merge(struct ast_party_id *base, struct ast_party_id *overlay)
Merge a given party id into another given party id.
Definition: channel.c:1902
int ast_channel_stream_topology_changed_externally(struct ast_channel *chan)
Provide notice from a channel that the topology has changed on it as a result of the remote party ren...
Definition: channel.c:11007
#define DEFAULT_EMULATE_MF_DURATION
Definition: channel.c:106
void ast_party_number_set_init(struct ast_party_number *init, const struct ast_party_number *guide)
Initialize the given party number structure using the given guide for a set update operation.
Definition: channel.c:1666
int ast_settimeout(struct ast_channel *c, unsigned int rate, int(*func)(const void *data), void *data)
Enable or disable timer ticks for a channel.
Definition: channel.c:3180
static const struct ast_channel_tech surrogate_tech
Channel technology used to extract a channel from a running application. The channel created with thi...
Definition: channel.c:696
int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
Sets write format on channel chan.
Definition: channel.c:5802
void ast_party_id_copy(struct ast_party_id *dest, const struct ast_party_id *src)
Copy the source party id information to the destination party id.
Definition: channel.c:1765
void ast_party_number_free(struct ast_party_number *doomed)
Destroy the party number contents.
Definition: channel.c:1691
void ast_party_connected_line_init(struct ast_party_connected_line *init)
Initialize the given connected line structure.
Definition: channel.c:2022
int ast_channel_get_up_time(struct ast_channel *chan)
Obtain how long it has been since the channel was answered.
Definition: channel.c:2845
static char * complete_channeltypes(struct ast_cli_args *a)
Definition: channel.c:303
int ast_channel_is_leaving_bridge(struct ast_channel *chan)
Determine if a channel is leaving a bridge, but not hung up.
Definition: channel.c:10549
void ast_channel_setwhentohangup_tv(struct ast_channel *chan, struct timeval offset)
Set when to hangup channel.
Definition: channel.c:510
int ast_redirecting_parse_data(const unsigned char *data, size_t datalen, struct ast_party_redirecting *redirecting)
Parse redirecting indication frame data.
Definition: channel.c:9478
static int indicate_data_internal(struct ast_channel *chan, int _condition, const void *data, size_t datalen)
Definition: channel.c:4469
struct ast_variable * ast_channeltype_list(void)
return an ast_variable list of channeltypes
Definition: channel.c:188
int ast_say_digits_full(struct ast_channel *chan, int num, const char *ints, const char *lang, int audiofd, int ctrlfd)
Same as ast_say_digits() with audiofd for received audio and returns 1 on ctrlfd being readable.
Definition: channel.c:8282
struct ast_bridge_channel * ast_channel_get_bridge_channel(struct ast_channel *chan)
Get a reference to the channel's bridge pointer.
Definition: channel.c:10581
int ast_senddigit_mf(struct ast_channel *chan, char digit, unsigned int duration, unsigned int durationkp, unsigned int durationst, int is_external)
Send an MF digit to a channel.
Definition: channel.c:4951
static struct ast_generator silence_generator
Definition: channel.c:8153
int ast_safe_sleep_conditional(struct ast_channel *chan, int timeout_ms, int(*cond)(void *), void *data)
Wait for a specified amount of time, looking for hangups and a condition argument.
Definition: channel.c:1568
static void suppress_framehook_destroy_cb(void *data)
Definition: channel.c:10713
static void channel_set_external_vars(struct external_vars *channelvars, size_t varc, char **vars)
Definition: channel.c:7864
int ast_transfer(struct ast_channel *chan, char *dest)
Transfer a call to dest, if the channel supports transfer.
Definition: channel.c:6484
static int ast_channel_by_uniqueid_cb(void *obj, void *arg, void *data, int flags)
Definition: channel.c:1329
static int party_id_build_data(unsigned char *data, size_t datalen, const struct ast_party_id *id, const char *label, const struct ast_party_id_ies *ies, const struct ast_set_party_id *update)
Definition: channel.c:8576
int ast_channel_unsuppress(struct ast_channel *chan, unsigned int direction, enum ast_frame_type frametype)
Stop suppressing of a frame type on a channel.
Definition: channel.c:10838
void ast_party_redirecting_free(struct ast_party_redirecting *doomed)
Destroy the redirecting information contents.
Definition: channel.c:2179
#define FORMAT
static void free_translation(struct ast_channel *clonechan)
Definition: channel.c:2487
void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
Definition: channel.c:2426
const char * ast_state2str(enum ast_channel_state state)
Gives the string form of a given channel state.
Definition: channel.c:636
static int tech_write(struct ast_channel *chan, struct ast_stream *stream, struct ast_stream *default_stream, struct ast_frame *frame)
Definition: channel.c:5131
void ast_connected_line_copy_from_caller(struct ast_party_connected_line *dest, const struct ast_party_caller *src)
Copy the caller information to the connected line information.
Definition: channel.c:8292
int ast_softhangup_nolock(struct ast_channel *chan, int cause)
Softly hangup a channel, don't lock.
Definition: channel.c:2458
enum ama_flags ast_channel_string2amaflag(const char *flag)
Convert a string to a detail record AMA flag.
Definition: channel.c:4359
static int redirecting_reason_build_data(unsigned char *data, size_t datalen, const struct ast_party_redirecting_reason *reason, const char *label, const struct ast_party_redirecting_reason_ies *ies)
Definition: channel.c:9234
int ast_indicate_data(struct ast_channel *chan, int _condition, const void *data, size_t datalen)
Indicates condition of channel, with payload.
Definition: channel.c:4652
static struct ast_frame * suppress_framehook_event_cb(struct ast_channel *chan, struct ast_frame *frame, enum ast_framehook_event event, void *data)
Definition: channel.c:10731
static int attribute_const is_visible_indication(enum ast_control_frame_type condition)
Definition: channel.c:4281
static void ast_channel_destructor(void *obj)
Free a channel structure.
Definition: channel.c:2192
void ast_channel_req_accountcodes_precious(struct ast_channel *chan, const struct ast_channel *requestor, enum ast_channel_requestor_relationship relationship)
Setup new channel accountcodes from the requestor channel after ast_request().
Definition: channel.c:6438
static int party_number_build_data(unsigned char *data, size_t datalen, const struct ast_party_number *number, const char *label, const struct ast_party_number_ies *ies)
Definition: channel.c:8421
int ast_set_write_format_path(struct ast_channel *chan, struct ast_format *core_format, struct ast_format *raw_format)
Set specific write path on channel.
Definition: channel.c:5523
static void apply_plc(struct ast_channel *chan, struct ast_frame *frame)
Definition: channel.c:5105
static struct ast_cli_entry cli_channel[]
Definition: channel.c:390
int ast_pre_call(struct ast_channel *chan, const char *sub_args)
Execute a Gosub call on the channel before a call is placed.
Definition: channel.c:6443
int ast_channel_supports_html(struct ast_channel *chan)
Checks for HTML support on a channel.
Definition: channel.c:6622
static int ast_channel_by_name_cb(void *obj, void *arg, void *data, int flags)
Definition: channel.c:1284
int ast_queue_answer(struct ast_channel *chan, const struct ast_stream_topology *topology)
Queue an ANSWER control frame with topology.
Definition: channel.c:1246
int ast_str2cause(const char *name)
Convert a symbolic hangup cause to number.
Definition: channel.c:625
static void * tonepair_alloc(struct ast_channel *chan, void *params)
Definition: channel.c:7497
struct ast_namedgroups * ast_unref_namedgroups(struct ast_namedgroups *groups)
Definition: channel.c:7731
void ast_party_subaddress_free(struct ast_party_subaddress *doomed)
Destroy the party subaddress contents.
Definition: channel.c:1744
static void set_channel_answer_time(struct ast_channel *chan)
Definition: channel.c:2628
static struct ao2_container * channels
All active channels on the system.
Definition: channel.c:124
static void * silence_generator_alloc(struct ast_channel *chan, void *data)
Definition: channel.c:8123
int ast_channel_get_duration(struct ast_channel *chan)
Obtain how long the channel since the channel was created.
Definition: channel.c:2830
void ast_channel_queue_connected_line_update(struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update)
Queue a connected line update frame on a channel.
Definition: channel.c:9105
void ast_party_connected_line_set_init(struct ast_party_connected_line *init, const struct ast_party_connected_line *guide)
Initialize the given connected line structure using the given guide for a set update operation.
Definition: channel.c:2045
unsigned long global_fout
Definition: channel.c:95
static struct ast_frame * __ast_read(struct ast_channel *chan, int dropaudio, int dropnondefault)
Definition: channel.c:3524
static struct ast_channel * request_channel(const char *type, struct ast_format_cap *request_cap, struct ast_stream_topology *topology, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int *cause)
Definition: channel.c:6218
static int should_trigger_dtmf_emulating(struct ast_channel *chan)
Determine whether or not we have to trigger dtmf emulating using 50 fps timer events especially when ...
Definition: channel.c:2855
static int kill_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
Definition: channel.c:413
static struct ast_threadstorage state2str_threadbuf
Definition: channel.c:97
int ast_safe_sleep_without_silence(struct ast_channel *chan, int ms)
Wait for a specified amount of time, looking for hangups, and do not generate silence.
Definition: channel.c:1579
static int __ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin, int head, struct ast_frame *after)
Definition: channel.c:1009
void ast_connected_line_copy_to_caller(struct ast_party_caller *dest, const struct ast_party_connected_line *src)
Copy the connected line information to the caller information.
Definition: channel.c:8299
const struct ast_channel_tech * ast_get_channel_tech(const char *name)
Get handle to channel driver based on name.
Definition: channel.c:592
struct ast_channel * ast_channel_get_by_name(const char *name)
Find a channel by name.
Definition: channel.c:1454
int ast_channel_defer_dtmf(struct ast_channel *chan)
Set defer DTMF flag on channel.
Definition: channel.c:1257
static const struct ast_datastore_info bridge_features_info
Definition: channel.c:10897
int ast_tonepair(struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
Definition: channel.c:7599
int ast_answer(struct ast_channel *chan)
Answer a channel.
Definition: channel.c:2805
void ast_change_name(struct ast_channel *chan, const char *newname)
Change channel name.
Definition: channel.c:6758
int ast_waitfor(struct ast_channel *c, int ms)
Wait for input on a channel.
Definition: channel.c:3162
static int ast_channel_cmp_cb(void *obj, void *arg, int flags)
Definition: channel.c:1428
ast_group_t ast_get_group(const char *s)
Definition: channel.c:7617
static const struct set_format_access set_format_access_read
Definition: channel.c:5570
int ast_channel_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
Bridge two channels together (early)
Definition: channel.c:7411
int ast_indicate(struct ast_channel *chan, int condition)
Indicates condition of channel.
Definition: channel.c:4276
static const char * dtmf_direction_to_string(enum DtmfDirection direction)
Definition: channel.c:3357
int ast_is_deferrable_frame(const struct ast_frame *frame)
Should we keep this frame for later?
Definition: channel.c:1467
struct ast_channel_iterator * ast_channel_iterator_all_new(void)
Create a new channel iterator.
Definition: channel.c:1408
int ast_safe_sleep(struct ast_channel *chan, int ms)
Wait, look for hangups.
Definition: channel.c:1574
struct ast_channel * ast_request(const char *type, struct ast_format_cap *request_cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int *cause)
Requests a channel.
Definition: channel.c:6353
static void send_wink_event(struct ast_channel *chan)
Definition: channel.c:3407
static int(* ast_moh_start_ptr)(struct ast_channel *, const char *, const char *)
Definition: channel.c:7745
struct ast_cc_config_params * ast_channel_get_cc_config_params(struct ast_channel *chan)
Get the CCSS parameters from a channel.
Definition: channel.c:10473
#define DEFAULT_AMA_FLAGS
Definition: channel.c:108
int ast_raw_answer(struct ast_channel *chan)
Answer a channel.
Definition: channel.c:2690
void ast_party_redirecting_copy(struct ast_party_redirecting *dest, const struct ast_party_redirecting *src)
Copy the source redirecting information to the destination redirecting.
Definition: channel.c:2135
@ AST_REDIRECTING_FROM_NAME_PRESENTATION
Definition: channel.c:9164
@ AST_REDIRECTING_TO_NAME
Definition: channel.c:9142
@ AST_REDIRECTING_VERSION
Definition: channel.c:9157
@ AST_REDIRECTING_PRIV_FROM_NAME_VALID
Definition: channel.c:9204
@ AST_REDIRECTING_PRIV_FROM_SUBADDRESS_ODD_EVEN
Definition: channel.c:9209
@ AST_REDIRECTING_TO_TAG
Definition: channel.c:9156
@ AST_REDIRECTING_FROM_NUMBER_PLAN
Definition: channel.c:9139
@ AST_REDIRECTING_PRIV_TO_NAME_VALID
Definition: channel.c:9191
@ AST_REDIRECTING_ORIG_TAG
Definition: channel.c:9184
@ AST_REDIRECTING_PRIV_ORIG_SUBADDRESS_ODD_EVEN
Definition: channel.c:9222
@ AST_REDIRECTING_REASON_CODE
Definition: channel.c:9145
@ AST_REDIRECTING_PRIV_TO_NUMBER_VALID
Definition: channel.c:9188
@ AST_REDIRECTING_PRIV_TO_NUMBER_PRESENTATION
Definition: channel.c:9189
@ AST_REDIRECTING_ORIG_REASON_CODE
Definition: channel.c:9185
@ AST_REDIRECTING_TO_NAME_PRESENTATION
Definition: channel.c:9169
@ AST_REDIRECTING_PRIV_TO_NAME
Definition: channel.c:9190
@ AST_REDIRECTING_PRIV_ORIG_NAME_VALID
Definition: channel.c:9217
@ AST_REDIRECTING_ORIG_NUMBER_VALID
Definition: channel.c:9173
@ AST_REDIRECTING_FROM_NUMBER_PRESENTATION
Definition: channel.c:9166
@ AST_REDIRECTING_ORIG_SUBADDRESS_VALID
Definition: channel.c:9183
@ AST_REDIRECTING_FROM_NUMBER_VALID
Definition: channel.c:9165
@ AST_REDIRECTING_TO_NAME_VALID
Definition: channel.c:9167
@ AST_REDIRECTING_PRIV_FROM_NAME
Definition: channel.c:9203
@ AST_REDIRECTING_TO_SUBADDRESS_ODD_EVEN
Definition: channel.c:9153
@ AST_REDIRECTING_ORIG_SUBADDRESS_ODD_EVEN
Definition: channel.c:9182
@ AST_REDIRECTING_PRIV_FROM_SUBADDRESS_TYPE
Definition: channel.c:9208
@ AST_REDIRECTING_PRIV_TO_SUBADDRESS_VALID
Definition: channel.c:9197
@ AST_REDIRECTING_PRIV_TO_SUBADDRESS_ODD_EVEN
Definition: channel.c:9196
@ AST_REDIRECTING_ORIG_NAME_CHAR_SET
Definition: channel.c:9178
@ AST_REDIRECTING_PRIV_FROM_SUBADDRESS
Definition: channel.c:9207
@ AST_REDIRECTING_TO_NUMBER_PLAN
Definition: channel.c:9143
@ AST_REDIRECTING_PRIV_TO_NUMBER
Definition: channel.c:9186
@ AST_REDIRECTING_PRIV_FROM_NUMBER_VALID
Definition: channel.c:9201
@ AST_REDIRECTING_ORIG_NAME
Definition: channel.c:9176
@ AST_REDIRECTING_ORIG_SUBADDRESS
Definition: channel.c:9180
@ AST_REDIRECTING_FROM_TAG
Definition: channel.c:9155
@ AST_REDIRECTING_PRIV_ORIG_NUMBER_PLAN
Definition: channel.c:9214
@ AST_REDIRECTING_TO_NUMBER
Definition: channel.c:9141
@ AST_REDIRECTING_ORIG_SUBADDRESS_TYPE
Definition: channel.c:9181
@ AST_REDIRECTING_FROM_NAME_CHAR_SET
Definition: channel.c:9163
@ AST_REDIRECTING_PRIV_FROM_TAG
Definition: channel.c:9211
@ AST_REDIRECTING_FROM_ID_PRESENTATION
Definition: channel.c:9140
@ AST_REDIRECTING_PRIV_FROM_NUMBER
Definition: channel.c:9199
@ AST_REDIRECTING_PRIV_TO_NUMBER_PLAN
Definition: channel.c:9187
@ AST_REDIRECTING_TO_NUMBER_VALID
Definition: channel.c:9170
@ AST_REDIRECTING_FROM_SUBADDRESS_VALID
Definition: channel.c:9150
@ AST_REDIRECTING_FROM_NAME_VALID
Definition: channel.c:9162
@ AST_REDIRECTING_PRIV_TO_NAME_CHAR_SET
Definition: channel.c:9192
@ AST_REDIRECTING_PRIV_ORIG_TAG
Definition: channel.c:9224
@ AST_REDIRECTING_FROM_SUBADDRESS_TYPE
Definition: channel.c:9148
@ AST_REDIRECTING_PRIV_TO_TAG
Definition: channel.c:9198
@ AST_REDIRECTING_COUNT
Definition: channel.c:9146
@ AST_REDIRECTING_FROM_SUBADDRESS
Definition: channel.c:9147
@ AST_REDIRECTING_PRIV_ORIG_NAME_CHAR_SET
Definition: channel.c:9218
@ AST_REDIRECTING_ORIG_NAME_VALID
Definition: channel.c:9177
@ AST_REDIRECTING_TO_ID_PRESENTATION
Definition: channel.c:9144
@ AST_REDIRECTING_PRIV_FROM_NUMBER_PLAN
Definition: channel.c:9200
@ AST_REDIRECTING_PRIV_TO_NAME_PRESENTATION
Definition: channel.c:9193
@ AST_REDIRECTING_PRIV_FROM_NUMBER_PRESENTATION
Definition: channel.c:9202
@ AST_REDIRECTING_PRIV_FROM_NAME_PRESENTATION
Definition: channel.c:9206
@ AST_REDIRECTING_PRIV_ORIG_SUBADDRESS_TYPE
Definition: channel.c:9221
@ AST_REDIRECTING_ORIG_REASON_STR
Definition: channel.c:9226
@ AST_REDIRECTING_ORIG_NAME_PRESENTATION
Definition: channel.c:9179
@ AST_REDIRECTING_PRIV_FROM_NAME_CHAR_SET
Definition: channel.c:9205
@ AST_REDIRECTING_ORIG_NUMBER
Definition: channel.c:9172
@ AST_REDIRECTING_PRIV_ORIG_NAME
Definition: channel.c:9216
@ AST_REDIRECTING_PRIV_TO_SUBADDRESS_TYPE
Definition: channel.c:9195
@ AST_REDIRECTING_PRIV_ORIG_NUMBER_VALID
Definition: channel.c:9213
@ AST_REDIRECTING_PRIV_ORIG_NUMBER_PRESENTATION
Definition: channel.c:9215
@ AST_REDIRECTING_TO_SUBADDRESS_VALID
Definition: channel.c:9154
@ AST_REDIRECTING_PRIV_ORIG_SUBADDRESS_VALID
Definition: channel.c:9223
@ AST_REDIRECTING_TO_SUBADDRESS_TYPE
Definition: channel.c:9152
@ AST_REDIRECTING_REASON_STR
Definition: channel.c:9225
@ AST_REDIRECTING_FROM_NAME
Definition: channel.c:9138
@ AST_REDIRECTING_PRIV_ORIG_NUMBER
Definition: channel.c:9212
@ AST_REDIRECTING_PRIV_FROM_SUBADDRESS_VALID
Definition: channel.c:9210
@ AST_REDIRECTING_ORIG_NUMBER_PRESENTATION
Definition: channel.c:9175
@ AST_REDIRECTING_PRIV_TO_SUBADDRESS
Definition: channel.c:9194
@ AST_REDIRECTING_PRIV_ORIG_NAME_PRESENTATION
Definition: channel.c:9219
@ AST_REDIRECTING_TO_NUMBER_PRESENTATION
Definition: channel.c:9171
@ AST_REDIRECTING_FROM_NUMBER
Definition: channel.c:9137
@ AST_REDIRECTING_ORIG_NUMBER_PLAN
Definition: channel.c:9174
@ AST_REDIRECTING_FROM_SUBADDRESS_ODD_EVEN
Definition: channel.c:9149
@ AST_REDIRECTING_PRIV_ORIG_SUBADDRESS
Definition: channel.c:9220
@ AST_REDIRECTING_TO_SUBADDRESS
Definition: channel.c:9151
@ AST_REDIRECTING_TO_NAME_CHAR_SET
Definition: channel.c:9168
char * ast_print_namedgroups(struct ast_str **buf, struct ast_namedgroups *group)
Print named call groups and named pickup groups.
Definition: channel.c:8055
void ast_party_name_copy(struct ast_party_name *dest, const struct ast_party_name *src)
Copy the source party name information to the destination party name.
Definition: channel.c:1599
int ast_channel_get_cc_agent_type(struct ast_channel *chan, char *agent_type, size_t size)
Find the appropriate CC agent type to use given a channel.
Definition: channel.c:10512
struct ast_datastore * ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
Find a datastore on a channel.
Definition: channel.c:2399
void ast_party_redirecting_reason_free(struct ast_party_redirecting_reason *doomed)
Destroy the redirecting reason contents.
Definition: channel.c:2116
#define STATE2STR_BUFSIZE
Definition: channel.c:98
void ast_party_caller_init(struct ast_party_caller *init)
Initialize the given caller structure.
Definition: channel.c:1978
void ast_tonepair_stop(struct ast_channel *chan)
Definition: channel.c:7594
struct ast_channel * ast_waitfor_n(struct ast_channel **c, int n, int *ms)
Waits for input on a group of channels Wait for input on an array of channels for a given # of millis...
Definition: channel.c:3157
int ast_channel_has_audio_frame_or_monitor(struct ast_channel *chan)
Check if the channel has active audiohooks, active framehooks, or a monitor.
Definition: channel.c:2518
static void ast_dummy_channel_destructor(void *obj)
Free a dummy channel structure.
Definition: channel.c:2333
General Asterisk PBX channel definitions.
void ast_channel_internal_alertpipe_swap(struct ast_channel *chan1, struct ast_channel *chan2)
Swap the interal alertpipe between two channels.
void ast_channel_exten_set(struct ast_channel *chan, const char *value)
const char * ast_channel_name(const struct ast_channel *chan)
int ast_autoservice_stop(struct ast_channel *chan)
Stop servicing a channel for us...
Definition: autoservice.c:266
struct ast_bridge * ast_channel_internal_bridge(const struct ast_channel *chan)
struct timeval ast_channel_answertime(struct ast_channel *chan)
void ast_channel_named_pickupgroups_set(struct ast_channel *chan, struct ast_namedgroups *value)
int(* ast_timing_func_t)(const void *data)
Definition: channel.h:899
struct ast_channel * ast_channel_masq(const struct ast_channel *chan)
int ast_channel_blocker_tid(const struct ast_channel *chan)
void ast_channel_stream_set(struct ast_channel *chan, struct ast_filestream *value)
void ast_channel_visible_indication_set(struct ast_channel *chan, int value)
const char * ast_channel_blockproc(const struct ast_channel *chan)
void ast_channel_caller_set(struct ast_channel *chan, struct ast_party_caller *value)
@ AST_CHAN_TP_INTERNAL
Channels with this particular technology are an implementation detail of Asterisk and should generall...
Definition: channel.h:971
@ AST_CHAN_TP_SEND_TEXT_DATA
Channels have this property if they implement send_text_data.
Definition: channel.h:975
void * ast_channel_tech_pvt(const struct ast_channel *chan)
void ast_channel_dialed_set(struct ast_channel *chan, struct ast_party_dialed *value)
struct ast_format * ast_channel_rawreadformat(struct ast_channel *chan)
#define DEBUGCHAN_FLAG
Definition: channel.h:857
void * ast_channel_music_state(const struct ast_channel *chan)
unsigned int ast_channel_fin(const struct ast_channel *chan)
const char * ast_channel_latest_musicclass(const struct ast_channel *chan)
void ast_channel_callid_cleanup(struct ast_channel *chan)
void ast_channel_set_oldwriteformat(struct ast_channel *chan, struct ast_format *format)
void ast_channel_softhangup_internal_flag_clear(struct ast_channel *chan, int value)
struct varshead * ast_channel_varshead(struct ast_channel *chan)
void ast_channel_generator_set(struct ast_channel *chan, struct ast_generator *value)
#define ast_channel_alloc(needqueue, state, cid_num, cid_name, acctcode, exten, context, assignedids, requestor, amaflag,...)
Create a channel structure.
Definition: channel.h:1258
void ast_channel_sending_dtmf_digit_set(struct ast_channel *chan, char value)
void * ast_channel_timingdata(const struct ast_channel *chan)
int ast_channel_internal_alert_readfd(struct ast_channel *chan)
ast_channel_requestor_relationship
Definition: channel.h:1475
@ AST_CHANNEL_REQUESTOR_BRIDGE_PEER
Definition: channel.h:1477
@ AST_CHANNEL_REQUESTOR_REPLACEMENT
Definition: channel.h:1479
#define AST_GENERATOR_FD
Definition: channel.h:203
void ast_channel_dtmf_tv_set(struct ast_channel *chan, struct timeval *value)
struct ast_flags * ast_channel_snapshot_segment_flags(struct ast_channel *chan)
#define DATASTORE_INHERIT_FOREVER
Definition: channel.h:192
#define CHECK_BLOCKING(c)
Set the blocking indication on the channel.
Definition: channel.h:2871
void ast_channel_internal_swap_endpoint_forward(struct ast_channel *a, struct ast_channel *b)
Swap endpoint_forward between two channels.
void ast_channel_nativeformats_set(struct ast_channel *chan, struct ast_format_cap *value)
const char * ast_channel_musicclass(const struct ast_channel *chan)
int ast_channel_fdno(const struct ast_channel *chan)
void ast_channel_internal_fd_clear_all(struct ast_channel *chan)
void ast_channel_internal_alertpipe_close(struct ast_channel *chan)
void ast_channel_answertime_set(struct ast_channel *chan, struct timeval *value)
void ast_channel_hold_state_set(struct ast_channel *chan, int value)
#define ast_channel_lock(chan)
Definition: channel.h:2922
struct ast_trans_pvt * ast_channel_readtrans(const struct ast_channel *chan)
struct ast_format_cap * ast_channel_nativeformats(const struct ast_channel *chan)
struct timeval ast_channel_sending_dtmf_tv(const struct ast_channel *chan)
struct ast_party_redirecting * ast_channel_redirecting(struct ast_channel *chan)
struct ast_trans_pvt * ast_channel_writetrans(const struct ast_channel *chan)
void ast_channel_vstreamid_set(struct ast_channel *chan, int value)
static const char ast_stream_topology_changed_external[]
Set as the change source reason when a channel stream topology has been changed externally as a resul...
Definition: channel.h:221
void ast_channel_timingdata_set(struct ast_channel *chan, void *value)
struct ast_cdr * ast_channel_cdr(const struct ast_channel *chan)
struct ast_flags * ast_channel_flags(struct ast_channel *chan)
void ast_channel_redirecting_set(struct ast_channel *chan, struct ast_party_redirecting *value)
unsigned long long ast_group_t
Definition: channel.h:213
ast_channel_error
Definition: channel.h:4793
@ AST_CHANNEL_ERROR_ID_EXISTS
Definition: channel.h:4797
int ast_channel_priority(const struct ast_channel *chan)
void ast_channel_writetrans_set(struct ast_channel *chan, struct ast_trans_pvt *value)
void ast_channel_streamid_set(struct ast_channel *chan, int value)
#define ast_channel_ref(c)
Increase channel reference count.
Definition: channel.h:2947
void ast_channel_generatordata_set(struct ast_channel *chan, void *value)
#define ast_channel_lock_both(chan1, chan2)
Lock two channels.
Definition: channel.h:2929
struct ast_party_connected_line * ast_channel_connected(struct ast_channel *chan)
void ast_channel_softhangup_internal_flag_set(struct ast_channel *chan, int value)
ast_callid ast_channel_callid(const struct ast_channel *chan)
const char * ast_channel_uniqueid(const struct ast_channel *chan)
const char * ast_channel_accountcode(const struct ast_channel *chan)
const char * ast_channel_context(const struct ast_channel *chan)
char ast_channel_dtmf_digit_to_emulate(const struct ast_channel *chan)
void ast_channel_timingfd_set(struct ast_channel *chan, int value)
#define AST_MUTE_DIRECTION_READ
Definition: channel.h:4712
pthread_t ast_channel_blocker(const struct ast_channel *chan)
ama_flags
Channel AMA Flags.
Definition: channel.h:1177
@ AST_AMA_DOCUMENTATION
Definition: channel.h:1181
@ AST_AMA_OMIT
Definition: channel.h:1179
@ AST_AMA_NONE
Definition: channel.h:1178
@ AST_AMA_BILLING
Definition: channel.h:1180
void ast_channel_sending_dtmf_tv_set(struct ast_channel *chan, struct timeval value)
#define ast_channel_trylock(chan)
Definition: channel.h:2924
const char * ast_channel_parkinglot(const struct ast_channel *chan)
ast_channel_adsicpe
Definition: channel.h:868
void ast_channel_internal_swap_topics(struct ast_channel *a, struct ast_channel *b)
Swap topics beteween two channels.
#define AST_ALERT_FD
Definition: channel.h:200
const char * ast_channel_peeraccount(const struct ast_channel *chan)
struct timeval ast_channel_creationtime(struct ast_channel *chan)
struct ast_bridge_channel * ast_channel_internal_bridge_channel(const struct ast_channel *chan)
struct ast_framehook_list * ast_channel_framehooks(const struct ast_channel *chan)
void ast_channel_audiohooks_set(struct ast_channel *chan, struct ast_audiohook_list *value)
int ast_channel_fd(const struct ast_channel *chan, int which)
void ast_channel_timer_set(struct ast_channel *chan, struct ast_timer *value)
void ast_channel_internal_fd_set(struct ast_channel *chan, int which, int value)
void ast_channel_fin_set(struct ast_channel *chan, unsigned int value)
void ast_channel_set_rawreadformat(struct ast_channel *chan, struct ast_format *format)
struct ast_audiohook_list * ast_channel_audiohooks(const struct ast_channel *chan)
void ast_channel_tech_pvt_set(struct ast_channel *chan, void *value)
enum ama_flags ast_channel_amaflags(const struct ast_channel *chan)
void ast_channel_readtrans_set(struct ast_channel *chan, struct ast_trans_pvt *value)
void * ast_channel_generatordata(const struct ast_channel *chan)
struct ast_format * ast_channel_rawwriteformat(struct ast_channel *chan)
void ast_channel_set_is_t38_active_nolock(struct ast_channel *chan, int is_t38_active)
Variant of ast_channel_set_is_t38_active. Use this if the channel is already locked prior to calling.
const char * ast_channel_hangupsource(const struct ast_channel *chan)
unsigned int ast_channel_fout(const struct ast_channel *chan)
struct ast_stream_topology * ast_channel_get_stream_topology(const struct ast_channel *chan)
Retrieve the topology of streams on a channel.
#define AST_NUM_CHANNEL_BUCKETS
Definition: channel.h:155
int ast_channel_hangupcause(const struct ast_channel *chan)
int ast_channel_timingfd(const struct ast_channel *chan)
void ast_channel_fdno_set(struct ast_channel *chan, int value)
#define AST_TIMING_FD
Definition: channel.h:201
void ast_channel_set_rawwriteformat(struct ast_channel *chan, struct ast_format *format)
struct ast_party_dialed * ast_channel_dialed(struct ast_channel *chan)
@ AST_PARTY_CHAR_SET_ISO8859_1
Definition: channel.h:244
void ast_channel_creationtime_set(struct ast_channel *chan, struct timeval *value)
struct ast_tone_zone * ast_channel_zone(const struct ast_channel *chan)
int ast_channel_dialed_causes_add(const struct ast_channel *chan, const struct ast_control_pvt_cause_code *cause_code, int datalen)
Add cause code information to the channel.
void ast_channel_named_callgroups_set(struct ast_channel *chan, struct ast_namedgroups *value)
int ast_channel_alert_write(struct ast_channel *chan)
struct ast_readq_list * ast_channel_readq(struct ast_channel *chan)
ast_timing_func_t ast_channel_timingfunc(const struct ast_channel *chan)
void ast_channel_set_readformat(struct ast_channel *chan, struct ast_format *format)
void ast_channel_dtmf_digit_to_emulate_set(struct ast_channel *chan, char value)
#define AST_CHANNEL_NAME
Definition: channel.h:171
void ast_channel_softhangup_internal_flag_add(struct ast_channel *chan, int value)
struct timeval * ast_channel_whentohangup(struct ast_channel *chan)
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:2958
struct ast_stream * ast_channel_get_default_stream(struct ast_channel *chan, enum ast_media_type type)
Retrieve the default stream of a specific media type on a channel.
struct ast_filestream * ast_channel_vstream(const struct ast_channel *chan)
ast_alert_status_t ast_channel_internal_alert_read(struct ast_channel *chan)
struct ast_format * ast_channel_writeformat(struct ast_channel *chan)
@ AST_SOFTHANGUP_ASYNCGOTO
Definition: channel.h:1126
@ AST_SOFTHANGUP_EXPLICIT
Definition: channel.h:1148
@ AST_SOFTHANGUP_DEV
Definition: channel.h:1121
@ AST_SOFTHANGUP_TIMEOUT
Definition: channel.h:1138
@ AST_SOFTHANGUP_SHUTDOWN
Definition: channel.h:1131
void ast_channel_internal_swap_uniqueid_and_linkedid(struct ast_channel *a, struct ast_channel *b)
Swap uniqueid and linkedid beteween two channels.
struct ast_generator * ast_channel_generator(const struct ast_channel *chan)
int ast_channel_unbridged(struct ast_channel *chan)
This function will check if the bridge needs to be re-evaluated due to external changes.
int ast_channel_hold_state(const struct ast_channel *chan)
void ast_channel_emulate_dtmf_duration_set(struct ast_channel *chan, unsigned int value)
void ast_channel_amaflags_set(struct ast_channel *chan, enum ama_flags value)
const char * ast_channel_language(const struct ast_channel *chan)
struct ast_party_connected_line * ast_channel_connected_indicated(struct ast_channel *chan)
void ast_channel_cdr_set(struct ast_channel *chan, struct ast_cdr *value)
void ast_channel_context_set(struct ast_channel *chan, const char *value)
void ast_channel_connected_set(struct ast_channel *chan, struct ast_party_connected_line *value)
void ast_channel_timingfunc_set(struct ast_channel *chan, ast_timing_func_t value)
struct ast_sched_context * ast_channel_sched(const struct ast_channel *chan)
void ast_channel_state_set(struct ast_channel *chan, enum ast_channel_state)
int ast_channel_fd_count(const struct ast_channel *chan)
Retrieve the number of file decriptor positions present on the channel.
#define AST_MUTE_DIRECTION_WRITE
Definition: channel.h:4713
struct ast_frame * ast_channel_dtmff(struct ast_channel *chan)
void ast_channel_internal_swap_snapshots(struct ast_channel *a, struct ast_channel *b)
Swap snapshots beteween two channels.
unsigned int ast_channel_emulate_dtmf_duration(const struct ast_channel *chan)
static int ast_add_fd(struct pollfd *pfd, int fd)
if fd is a valid descriptor, set *pfd with the descriptor
Definition: channel.h:2819
const char * ast_channel_call_forward(const struct ast_channel *chan)
@ AST_FLAG_ZOMBIE
Definition: channel.h:987
@ AST_FLAG_DISABLE_DEVSTATE_CACHE
Definition: channel.h:1029
@ AST_FLAG_SNAPSHOT_STAGE
Definition: channel.h:1050
@ AST_FLAG_OUTGOING
Definition: channel.h:999
@ AST_FLAG_IN_AUTOLOOP
Definition: channel.h:997
@ AST_FLAG_END_DTMF_ONLY
Definition: channel.h:1007
@ AST_FLAG_DEAD
Definition: channel.h:1045
@ AST_FLAG_EXCEPTION
Definition: channel.h:989
@ AST_FLAG_EMULATE_DTMF
Definition: channel.h:1004
@ AST_FLAG_IN_DTMF
Definition: channel.h:1001
@ AST_FLAG_WRITE_INT
Definition: channel.h:983
@ AST_FLAG_DEFER_DTMF
Definition: channel.h:981
@ AST_FLAG_BLOCKING
Definition: channel.h:985
@ AST_FLAG_ORIGINATED
Definition: channel.h:1039
@ AST_FLAG_TIMINGDATA_IS_AO2_OBJ
Definition: channel.h:1054
@ AST_FLAG_MOH
Definition: channel.h:991
#define AST_JITTERBUFFER_FD
Definition: channel.h:204
struct ast_filestream * ast_channel_stream(const struct ast_channel *chan)
struct ast_pbx * ast_channel_pbx(const struct ast_channel *chan)
void ast_channel_fout_set(struct ast_channel *chan, unsigned int value)
struct ast_autochan_list * ast_channel_autochans(struct ast_channel *chan)
const struct ast_channel_tech * ast_channel_tech(const struct ast_channel *chan)
void ast_channel_zone_set(struct ast_channel *chan, struct ast_tone_zone *value)
struct ast_channel * ast_channel_masqr(const struct ast_channel *chan)
int ast_channel_softhangup_internal_flag(struct ast_channel *chan)
struct timeval * ast_channel_dtmf_tv(struct ast_channel *chan)
struct ast_party_caller * ast_channel_caller(struct ast_channel *chan)
char ast_channel_sending_dtmf_digit(const struct ast_channel *chan)
int ast_channel_visible_indication(const struct ast_channel *chan)
#define FRAMECOUNT_INC(x)
Definition: channel.h:860
struct ast_timer * ast_channel_timer(const struct ast_channel *chan)
struct ast_hangup_handler_list * ast_channel_hangup_handlers(struct ast_channel *chan)
void ast_channel_masqr_set(struct ast_channel *chan, struct ast_channel *value)
void ast_channel_callid_set(struct ast_channel *chan, ast_callid value)
void ast_channel_internal_alertpipe_clear(struct ast_channel *chan)
void ast_channel_priority_set(struct ast_channel *chan, int value)
void ast_channel_hangupcause_set(struct ast_channel *chan, int value)
void ast_channel_whentohangup_set(struct ast_channel *chan, struct timeval *value)
#define ast_channel_cleanup(c)
Cleanup a channel reference.
Definition: channel.h:2969
int ast_channel_fd_isset(const struct ast_channel *chan, int which)
void ast_channel_adsicpe_set(struct ast_channel *chan, enum ast_channel_adsicpe value)
int ast_channel_is_multistream(struct ast_channel *chan)
Determine if a channel is multi-stream capable.
int ast_channel_internal_alertpipe_init(struct ast_channel *chan)
void ast_channel_sched_set(struct ast_channel *chan, struct ast_sched_context *value)
void ast_channel_tech_set(struct ast_channel *chan, const struct ast_channel_tech *value)
const char * ast_channel_exten(const struct ast_channel *chan)
struct ast_datastore_list * ast_channel_datastores(struct ast_channel *chan)
#define ast_channel_unlock(chan)
Definition: channel.h:2923
void ast_channel_masq_set(struct ast_channel *chan, struct ast_channel *value)
void ast_channel_set_writeformat(struct ast_channel *chan, struct ast_format *format)
void ast_channel_vstream_set(struct ast_channel *chan, struct ast_filestream *value)
struct ast_format * ast_channel_readformat(struct ast_channel *chan)
int ast_channel_alert_writable(struct ast_channel *chan)
Internal channel functions for channel.c to use.
void ast_channel_internal_set_stream_topology_change_source(struct ast_channel *chan, void *change_source)
void ast_channel_internal_set_stream_topology(struct ast_channel *chan, struct ast_stream_topology *topology)
int ast_channel_internal_is_finalized(struct ast_channel *chan)
enum ast_channel_error ast_channel_internal_errno(void)
void ast_channel_internal_swap_stream_topology(struct ast_channel *chan1, struct ast_channel *chan2)
void ast_channel_internal_cleanup(struct ast_channel *chan)
struct ast_channel * __ast_channel_internal_alloc(void(*destructor)(void *obj), const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *file, int line, const char *function)
int ast_channel_internal_setup_topics(struct ast_channel *chan)
void ast_channel_internal_finalize(struct ast_channel *chan)
void ast_channel_internal_errno_set(enum ast_channel_error error)
ast_channel_state
ast_channel states
Definition: channelstate.h:35
@ AST_STATE_MUTE
Definition: channelstate.h:47
@ AST_STATE_RING
Definition: channelstate.h:40
@ AST_STATE_DIALING_OFFHOOK
Definition: channelstate.h:44
@ AST_STATE_RINGING
Definition: channelstate.h:41
@ AST_STATE_PRERING
Definition: channelstate.h:45
@ AST_STATE_DOWN
Definition: channelstate.h:36
@ AST_STATE_OFFHOOK
Definition: channelstate.h:38
@ AST_STATE_BUSY
Definition: channelstate.h:43
@ AST_STATE_DIALING
Definition: channelstate.h:39
@ AST_STATE_UP
Definition: channelstate.h:42
@ AST_STATE_RESERVED
Definition: channelstate.h:37
Channel Variables.
const char * ast_var_name(const struct ast_var_t *var)
Definition: chanvars.c:60
#define ast_var_assign(name, value)
Definition: chanvars.h:40
const char * ast_var_full_name(const struct ast_var_t *var)
Definition: chanvars.c:75
const char * ast_var_value(const struct ast_var_t *var)
Definition: chanvars.c:80
void ast_var_delete(struct ast_var_t *var)
Definition: extconf.c:2471
Standard Command Line Interface.
#define CLI_SHOWUSAGE
Definition: cli.h:45
#define CLI_SUCCESS
Definition: cli.h:44
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
Definition: clicompat.c:30
#define AST_CLI_DEFINE(fn, txt,...)
Definition: cli.h:197
int ast_cli_completion_add(char *value)
Add a result to a request for completion options.
Definition: main/cli.c:2758
void ast_cli(int fd, const char *fmt,...)
Definition: clicompat.c:6
#define ESS(x)
Definition: cli.h:59
@ CLI_INIT
Definition: cli.h:152
@ CLI_GENERATE
Definition: cli.h:153
#define CLI_FAILURE
Definition: cli.h:46
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition: cli.h:265
ast_media_type
Types of media.
Definition: codec.h:30
@ AST_MEDIA_TYPE_AUDIO
Definition: codec.h:32
@ AST_MEDIA_TYPE_UNKNOWN
Definition: codec.h:31
@ AST_MEDIA_TYPE_IMAGE
Definition: codec.h:34
@ AST_MEDIA_TYPE_TEXT
Definition: codec.h:35
static void update(int code_size, int y, int wi, int fi, int dq, int sr, int dqsez, struct g726_state *state_ptr)
Definition: codec_g726.c:367
#define attribute_const
Definition: compiler.h:41
#define ast_datastore_alloc(info, uid)
Definition: datastore.h:85
int ast_datastore_free(struct ast_datastore *datastore)
Free a data store object.
Definition: datastore.c:68
int int32_t
Definition: db.h:60
short int16_t
Definition: db.h:59
Device state management.
@ AST_DEVSTATE_CACHABLE
Definition: devicestate.h:70
@ AST_DEVSTATE_NOT_CACHABLE
Definition: devicestate.h:69
int ast_devstate_changed_literal(enum ast_device_state state, enum ast_devstate_cache cachable, const char *device)
Tells Asterisk the State for Device is changed.
Definition: devicestate.c:471
@ AST_DEVICE_UNKNOWN
Definition: devicestate.h:53
static const float mf_tones[]
Definition: dsp.c:325
char connected
Definition: eagi_proxy.c:82
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
int ast_endpoint_add_channel(struct ast_endpoint *endpoint, struct ast_channel *chan)
Adds a channel to the given endpoint.
long int flag
Definition: f2c.h:83
#define max(a, b)
Definition: f2c.h:198
Call Parking and Pickup API Includes code and algorithms from the Zapata library.
Generic File Format Support. Should be included by clients of the file handling routines....
int ast_waitstream_full(struct ast_channel *c, const char *breakon, int audiofd, int monfd)
Definition: file.c:1848
int ast_stopstream(struct ast_channel *c)
Stops a stream.
Definition: file.c:222
int ast_closestream(struct ast_filestream *f)
Closes a stream.
Definition: file.c:1111
#define AST_DIGIT_ANY
Definition: file.h:48
enum ast_media_type ast_format_get_type(const struct ast_format *format)
Get the media type of a format.
Definition: format.c:354
unsigned int ast_format_get_sample_rate(const struct ast_format *format)
Get the sample rate of a media format.
Definition: format.c:379
enum ast_format_cmp_res ast_format_cmp(const struct ast_format *format1, const struct ast_format *format2)
Compare two formats.
Definition: format.c:201
@ AST_FORMAT_CMP_EQUAL
Definition: format.h:36
@ AST_FORMAT_CMP_NOT_EQUAL
Definition: format.h:38
const char * ast_format_get_name(const struct ast_format *format)
Get the name associated with a format.
Definition: format.c:334
int ast_format_cache_is_slinear(struct ast_format *format)
Determines if a format is one of the cached slin formats.
Definition: format_cache.c:534
struct ast_format * ast_format_slin
Built-in cached signed linear 8kHz format.
Definition: format_cache.c:41
struct ast_format * ast_format_none
Built-in "null" format.
Definition: format_cache.c:246
struct ast_format * ast_format_cache_get_slin_by_rate(unsigned int rate)
Retrieve the best signed linear format given a sample rate.
Definition: format_cache.c:512
struct ast_format * ast_format_t140
Built-in cached t140 format.
Definition: format_cache.c:231
#define AST_FORMAT_CAP_NAMES_LEN
Definition: format_cap.h:324
int ast_format_cap_empty(const struct ast_format_cap *cap)
Determine if a format cap has no formats in it.
Definition: format_cap.c:744
struct ast_format * ast_format_cap_get_best_by_type(const struct ast_format_cap *cap, enum ast_media_type type)
Get the most preferred format for a particular media type.
Definition: format_cap.c:417
void ast_format_cap_remove_by_type(struct ast_format_cap *cap, enum ast_media_type type)
Remove all formats matching a specific format type.
Definition: format_cap.c:523
@ AST_FORMAT_CAP_FLAG_DEFAULT
Definition: format_cap.h:38
int ast_format_cap_append_from_cap(struct ast_format_cap *dst, const struct ast_format_cap *src, enum ast_media_type type)
Append the formats of provided type in src to dst.
Definition: format_cap.c:269
const char * ast_format_cap_get_names(const struct ast_format_cap *cap, struct ast_str **buf)
Get the names of codecs of a set of formats.
Definition: format_cap.c:734
int ast_format_cap_has_type(const struct ast_format_cap *cap, enum ast_media_type type)
Find out if the capabilities structure has any formats of a specific type.
Definition: format_cap.c:613
#define ast_format_cap_append(cap, format, framing)
Add format capability to capabilities structure.
Definition: format_cap.h:99
#define ast_format_cap_alloc(flags)
Allocate a new ast_format_cap structure.
Definition: format_cap.h:49
static const char name[]
Definition: format_mp3.c:68
static void write_stream(struct ogg_vorbis_desc *s, FILE *f)
Write out any pending encoded data.
FrameHook Architecture.
int ast_framehook_list_contains_no_active_of_type(struct ast_framehook_list *framehooks, enum ast_frame_type type)
Determine if a framehook list is free of active framehooks consuming a specific type of frame.
Definition: framehook.c:287
int ast_framehook_attach(struct ast_channel *chan, struct ast_framehook_interface *i)
Attach an framehook onto a channel for frame interception.
Definition: framehook.c:132
ast_framehook_event
These are the types of events that the framehook's event callback can receive.
Definition: framehook.h:151
@ AST_FRAMEHOOK_EVENT_WRITE
Definition: framehook.h:153
@ AST_FRAMEHOOK_EVENT_READ
Definition: framehook.h:152
struct ast_frame * ast_framehook_list_read_event(struct ast_framehook_list *framehooks, struct ast_frame *frame)
This is used by the channel API push a frame read event to a channel's framehook list.
Definition: framehook.c:318
int ast_framehook_detach(struct ast_channel *chan, int framehook_id)
Detach an framehook from a channel.
Definition: framehook.c:177
int ast_framehook_list_destroy(struct ast_channel *chan)
This is used by the channel API to detach and destroy all framehooks on a channel during channel dest...
Definition: framehook.c:206
void ast_framehook_list_fixup(struct ast_channel *old_chan, struct ast_channel *new_chan)
This is used by the channel API during a masquerade operation to move all mobile framehooks from the ...
Definition: framehook.c:223
int ast_framehook_list_contains_no_active(struct ast_framehook_list *framehooks)
Determine if a framehook list is free of active framehooks or not.
Definition: framehook.c:282
int ast_framehook_list_is_empty(struct ast_framehook_list *framehooks)
Determine if an framehook list is empty or not.
Definition: framehook.c:274
struct ast_frame * ast_framehook_list_write_event(struct ast_framehook_list *framehooks, struct ast_frame *frame)
This is used by the channel API push a frame write event to a channel's framehook list.
Definition: framehook.c:313
#define AST_FRAMEHOOK_INTERFACE_VERSION
Definition: framehook.h:227
direction
static int replace(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
Definition: func_strings.c:888
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
globally accessible channel datastores
const struct ast_datastore_info secure_call_info
#define SCOPE_TRACE(__level,...)
struct stasis_message_type * ast_channel_masquerade_type(void)
Message type for when a channel is being masqueraded.
void ast_channel_publish_varset(struct ast_channel *chan, const char *variable, const char *value)
Publish a ast_channel_publish_varset for a channel.
struct stasis_message_type * ast_channel_hold_type(void)
Message type for when a channel is placed on hold.
struct stasis_message_type * ast_channel_dtmf_begin_type(void)
Message type for when DTMF begins on a channel.
void ast_channel_snapshot_invalidate_segment(struct ast_channel *chan, enum ast_channel_snapshot_segment_invalidation segment)
Invalidate a channel snapshot segment from being reused.
void ast_channel_publish_final_snapshot(struct ast_channel *chan)
Send the final channel snapshot for a channel, thus removing it from cache.
void ast_channel_stage_snapshot_done(struct ast_channel *chan)
Clear flag to indicate channel snapshot is being staged, and publish snapshot.
struct stasis_message_type * ast_channel_unhold_type(void)
Message type for when a channel is removed from hold.
struct stasis_message_type * ast_channel_hangup_request_type(void)
Message type for when a hangup is requested on a channel.
struct stasis_message_type * ast_channel_flash_type(void)
Message type for when a hook flash occurs on a channel.
struct stasis_message_type * ast_channel_dtmf_end_type(void)
Message type for when DTMF ends on a channel.
struct stasis_message_type * ast_channel_wink_type(void)
Message type for when a wink occurs on a channel.
void ast_channel_publish_snapshot(struct ast_channel *chan)
Publish a ast_channel_snapshot for a channel.
void ast_channel_publish_blob(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
Publish a channel blob message.
void ast_channel_stage_snapshot(struct ast_channel *chan)
Set flag to indicate channel snapshot is being staged.
@ AST_CHANNEL_SNAPSHOT_INVALIDATE_CALLER
@ AST_CHANNEL_SNAPSHOT_INVALIDATE_CONNECTED
const char * ast_msg_data_get_attribute(struct ast_msg_data *msg, enum ast_msg_data_attribute_type attribute_type)
Get attribute from ast_msg_data.
struct ast_msg_data * ast_msg_data_alloc(enum ast_msg_data_source_type source, struct ast_msg_data_attribute attributes[], size_t count)
Allocates an ast_msg_data structure.
@ AST_MSG_DATA_ATTR_BODY
Definition: message.h:458
@ AST_MSG_DATA_ATTR_TO
Definition: message.h:455
@ AST_MSG_DATA_ATTR_FROM
Definition: message.h:456
@ AST_MSG_DATA_ATTR_CONTENT_TYPE
Definition: message.h:457
@ AST_MSG_DATA_SOURCE_TYPE_UNKNOWN
Definition: message.h:447
unsigned int option_dtmfminduration
Definition: options.c:83
static ENTRY retval
Definition: hsearch.c:50
Application convenience functions, designed to give consistent look and feel to Asterisk apps.
@ AST_GETDATA_FAILED
@ AST_GETDATA_INTERRUPTED
@ AST_GETDATA_COMPLETE
@ AST_GETDATA_TIMEOUT
@ AST_GETDATA_EMPTY_END_TERMINATED
int ast_app_run_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const char *sub_location, const char *sub_args, int ignore_hangup)
Run a subroutine on a channel, placing an optional second channel into autoservice.
Definition: main/app.c:328
int ast_app_group_update(struct ast_channel *oldchan, struct ast_channel *newchan)
Update all group counting for a channel to a new one.
Definition: main/app.c:2290
int ast_app_group_discard(struct ast_channel *chan)
Discard all group counting for a channel.
Definition: main/app.c:2309
int ast_app_exec_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const char *sub_args, int ignore_hangup)
Run a subroutine on a channel, placing an optional second channel into autoservice.
Definition: main/app.c:297
char * strsep(char **str, const char *delims)
#define ast_variable_new(name, value, filename)
Asterisk internal frame definitions.
@ AST_FRFLAG_REQUEUED
@ AST_T38_TERMINATED
@ AST_T38_REFUSED
@ AST_T38_REQUEST_TERMINATE
@ AST_T38_NEGOTIATED
@ AST_T38_REQUEST_NEGOTIATE
@ AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO
@ AST_FRAME_READ_ACTION_SEND_TEXT
@ AST_FRAME_READ_ACTION_SEND_TEXT_DATA
#define AST_OPTION_DEVICE_NAME
#define ast_frisolate(fr)
Makes a frame independent of any static storage.
void ast_frame_dump(const char *name, struct ast_frame *f, char *prefix)
Definition: main/frame.c:731
#define ast_frdup(fr)
Copies a frame.
ast_control_transfer
@ AST_TRANSFER_SUCCESS
#define AST_OPTION_FORMAT_WRITE
#define ast_frfree(fr)
#define AST_HTML_URL
#define AST_MALLOCD_DATA
#define AST_OPTION_CC_AGENT_TYPE
#define AST_OPTION_SECURE_MEDIA
#define AST_FRIENDLY_OFFSET
Offset into a frame's data buffer.
#define AST_OPTION_FORMAT_READ
#define AST_OPTION_SECURE_SIGNALING
ast_frame_type
Frame types.
@ AST_FRAME_VIDEO
@ AST_FRAME_NULL
@ AST_FRAME_HTML
@ AST_FRAME_IMAGE
@ AST_FRAME_DTMF_END
@ AST_FRAME_DTMF_BEGIN
@ AST_FRAME_BRIDGE_ACTION_SYNC
@ AST_FRAME_VOICE
@ AST_FRAME_RTCP
@ AST_FRAME_MODEM
@ AST_FRAME_TEXT_DATA
@ AST_FRAME_CONTROL
@ AST_FRAME_BRIDGE_ACTION
@ AST_FRAME_TEXT
ast_control_frame_type
Internal control frame subtype field values.
@ AST_CONTROL_RING
@ AST_CONTROL_SRCUPDATE
@ AST_CONTROL_RECORD_CANCEL
@ AST_CONTROL_WINK
@ AST_CONTROL_PROGRESS
@ AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED
@ AST_CONTROL_OFFHOOK
@ AST_CONTROL_STREAM_RESTART
@ AST_CONTROL_STREAM_SUSPEND
@ AST_CONTROL_RADIO_UNKEY
@ AST_CONTROL_BUSY
@ AST_CONTROL_UNHOLD
@ AST_CONTROL_VIDUPDATE
@ AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE
@ AST_CONTROL_STREAM_REVERSE
@ AST_CONTROL_PROCEEDING
@ AST_CONTROL_REDIRECTING
@ AST_CONTROL_TAKEOFFHOOK
@ AST_CONTROL_MCID
@ AST_CONTROL_T38_PARAMETERS
@ AST_CONTROL_READ_ACTION
@ AST_CONTROL_RECORD_STOP
@ AST_CONTROL_CONGESTION
@ AST_CONTROL_CC
@ AST_CONTROL_ANSWER
@ AST_CONTROL_RECORD_MUTE
@ AST_CONTROL_RINGING
@ AST_CONTROL_HANGUP
@ AST_CONTROL_STREAM_STOP
@ AST_CONTROL_RADIO_KEY
@ AST_CONTROL_HOLD
@ AST_CONTROL_OPTION
@ AST_CONTROL_STREAM_TOPOLOGY_CHANGED
@ AST_CONTROL_CONNECTED_LINE
@ AST_CONTROL_END_OF_Q
@ AST_CONTROL_TRANSFER
@ AST_CONTROL_STREAM_FORWARD
@ AST_CONTROL_FLASH
@ AST_CONTROL_RECORD_SUSPEND
@ AST_CONTROL_AOC
@ AST_CONTROL_SRCCHANGE
@ AST_CONTROL_INCOMPLETE
@ _XXX_AST_CONTROL_T38
@ AST_CONTROL_MASQUERADE_NOTIFY
@ AST_CONTROL_PVT_CAUSE_CODE
@ AST_CONTROL_UPDATE_RTP_PEER
struct ast_frame ast_null_frame
Definition: main/frame.c:79
#define ast_debug(level,...)
Log a DEBUG message.
unsigned int ast_callid
void ast_log_callid(int level, const char *file, int line, const char *function, ast_callid callid, const char *fmt,...)
Used for sending a log message with a known call_id This is a modified logger function which is funct...
Definition: logger.c:2489
#define LOG_ERROR
#define ast_verb(level,...)
#define LOG_NOTICE
#define LOG_WARNING
#define LOG_DTMF
Tone Indication Support.
static struct ast_tone_zone_sound * ast_tone_zone_sound_unref(struct ast_tone_zone_sound *ts)
Release a reference to an ast_tone_zone_sound.
Definition: indications.h:227
int ast_playtones_start(struct ast_channel *chan, int vol, const char *tonelist, int interruptible)
Start playing a list of tones on a channel.
Definition: indications.c:302
void ast_playtones_stop(struct ast_channel *chan)
Stop playing tones on a channel.
Definition: indications.c:393
struct ast_tone_zone_sound * ast_get_indication_tone(const struct ast_tone_zone *zone, const char *indication)
Locate a tone zone sound.
Definition: indications.c:461
static struct ast_tone_zone * ast_tone_zone_unref(struct ast_tone_zone *tz)
Release a reference to an ast_tone_zone.
Definition: indications.h:205
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
Definition: json.c:612
AST_JSON_INT_T ast_json_int_t
Primarily used to cast when packing to an "I" type.
Definition: json.h:87
A set of macros to manage forward-linked lists.
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition: linkedlists.h:78
#define AST_LIST_HEAD_INIT_NOLOCK(head)
Initializes a list head structure.
Definition: linkedlists.h:681
#define AST_LIST_HEAD_NOLOCK(name, type)
Defines a structure to be used to hold a list of specified type (with no lock).
Definition: linkedlists.h:225
#define AST_LIST_LAST(head)
Returns the last entry contained in a list.
Definition: linkedlists.h:429
#define AST_RWLIST_TRAVERSE_SAFE_BEGIN
Definition: linkedlists.h:545
#define AST_LIST_INSERT_LIST_AFTER(head, list, elm, field)
Inserts a whole list after a specific entry in a list.
Definition: linkedlists.h:812
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition: linkedlists.h:52
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
Definition: linkedlists.h:151
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
#define AST_RWLIST_HEAD_INIT(head)
Initializes an rwlist head structure.
Definition: linkedlists.h:639
#define AST_RWLIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a read/write list of specified type, statically initialized.
Definition: linkedlists.h:333
#define AST_RWLIST_REMOVE_HEAD
Definition: linkedlists.h:844
#define AST_LIST_EMPTY(head)
Checks whether the specified list contains any entries.
Definition: linkedlists.h:450
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
Definition: linkedlists.h:410
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
Definition: linkedlists.h:615
#define AST_RWLIST_HEAD(name, type)
Defines a structure to be used to hold a read/write list of specified type.
Definition: linkedlists.h:199
#define AST_RWLIST_TRAVERSE
Definition: linkedlists.h:494
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.
Definition: linkedlists.h:711
#define AST_LIST_REMOVE(head, elm, field)
Removes a specific entry from a list.
Definition: linkedlists.h:856
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
Definition: linkedlists.h:529
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.
Definition: linkedlists.h:557
#define AST_RWLIST_INSERT_HEAD
Definition: linkedlists.h:718
#define AST_RWLIST_INSERT_TAIL
Definition: linkedlists.h:741
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833
#define AST_LIST_APPEND_LIST(head, list, field)
Appends a whole list to the tail of a list.
Definition: linkedlists.h:783
#define AST_LIST_FIRST(head)
Returns the first entry contained in a list.
Definition: linkedlists.h:421
#define AST_LIST_NEXT(elm, field)
Returns the next entry in the list after the given entry.
Definition: linkedlists.h:439
Asterisk locking-related definitions:
#define CHANNEL_DEADLOCK_AVOIDANCE(chan)
Definition: lock.h:474
int ast_atomic_fetchadd_int(volatile int *p, int v)
Atomically add v to *p and return the previous value of *p.
Definition: lock.h:757
#define SCOPED_LOCK(varname, lock, lockfunc, unlockfunc)
Scoped Locks.
Definition: lock.h:583
#define SCOPED_MUTEX(varname, lock)
scoped lock specialization for mutexes
Definition: lock.h:589
#define AST_MUTEX_DEFINE_STATIC(mutex)
Definition: lock.h:520
static struct groups groups
size_t current
Definition: main/cli.c:113
int errno
The AMI - Asterisk Manager Interface - is a TCP protocol created to manage Asterisk with third-party ...
#define EVENT_FLAG_CALL
Definition: manager.h:76
#define ast_manager_event(chan, category, event, contents,...)
Definition: manager.h:255
int ast_max_forwards_decrement(struct ast_channel *chan)
Decrement the max forwards count for a particular channel.
Definition: max_forwards.c:135
Out-of-call text message support.
Header for providers of file and format handling routines. Clients of these routines should include "...
Music on hold handling.
def info(msg)
#define ast_opt_transcode_via_slin
Definition: options.h:118
#define ast_opt_generic_plc_on_equal_codecs
Definition: options.h:136
#define ast_opt_generic_plc
Definition: options.h:134
char ast_defaultlanguage[]
Definition: options.c:98
#define ast_opt_transmit_silence
Definition: options.h:124
static int frames
Definition: parser.c:51
Asterisk file paths, configured in asterisk.conf.
Core PBX routines and definitions.
void ast_pbx_hangup_handler_destroy(struct ast_channel *chan)
Destroy the hangup handler container on a channel.
const char * pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name)
Return a pointer to the value of the corresponding channel variable.
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name.
int ast_func_read2(struct ast_channel *chan, const char *function, struct ast_str **str, ssize_t maxlen)
executes a read operation on a function
void ast_pbx_hangup_handler_init(struct ast_channel *chan)
Init the hangup handler container on a channel.
int ast_pbx_hangup_handler_run(struct ast_channel *chan)
Run all hangup handlers on the channel.
int ast_func_write(struct ast_channel *chan, const char *function, const char *value)
executes a write operation on a function
int plc_fillin(plc_state_t *s, int16_t amp[], int len)
Fill-in a block of missing audio samples.
Definition: plc.c:175
int plc_rx(plc_state_t *s, int16_t amp[], int len)
Process a block of received audio samples.
Definition: plc.c:132
#define ast_poll(a, b, c)
Definition: poll-compat.h:88
static char url[512]
struct stasis_forward * sub
Definition: res_corosync.c:240
#define NULL
Definition: resample.c:96
#define M_PI
Definition: resample.c:83
Say numbers and dates (maybe words one day too)
SAY_EXTERN int(* ast_say_money_str_full)(struct ast_channel *chan, const char *num, const char *ints, const char *lang, int audiofd, int ctrlfd) SAY_INIT(ast_say_money_str_full)
Definition: say.h:170
SAY_EXTERN int(* ast_say_number_full)(struct ast_channel *chan, int num, const char *ints, const char *lang, const char *options, int audiofd, int ctrlfd) SAY_INIT(ast_say_number_full)
Same as ast_say_number() with audiofd for received audio and returns 1 on ctrlfd being readable.
Definition: say.h:86
SAY_EXTERN int(* ast_say_enumeration_full)(struct ast_channel *chan, int num, const char *ints, const char *lang, const char *options, int audiofd, int ctrlfd) SAY_INIT(ast_say_enumeration_full)
Same as ast_say_enumeration() with audiofd for received audio and returns 1 on ctrlfd being readable.
Definition: say.h:125
SAY_EXTERN int(* ast_say_ordinal_full)(struct ast_channel *chan, int num, const char *ints, const char *lang, const char *options, int audiofd, int ctrlfd) SAY_INIT(ast_say_ordinal_full)
Same as ast_say_number() with audiofd for received audio and returns 1 on ctrlfd being readable.
Definition: say.h:105
SAY_EXTERN int(* ast_say_character_str_full)(struct ast_channel *chan, const char *num, const char *ints, const char *lang, enum ast_say_case_sensitivity sensitivity, int audiofd, int ctrlfd) SAY_INIT(ast_say_character_str_full)
Definition: say.h:194
SAY_EXTERN int(* ast_say_digit_str_full)(struct ast_channel *chan, const char *num, const char *ints, const char *lang, int audiofd, int ctrlfd) SAY_INIT(ast_say_digit_str_full)
Same as ast_say_digit_str() with audiofd for received audio and returns 1 on ctrlfd being readable.
Definition: say.h:162
ast_say_case_sensitivity
Controls how ast_say_character_str denotes the case of characters in a string.
Definition: say.h:181
SAY_EXTERN int(* ast_say_phonetic_str_full)(struct ast_channel *chan, const char *num, const char *ints, const char *lang, int audiofd, int ctrlfd) SAY_INIT(ast_say_phonetic_str_full)
Definition: say.h:199
Scheduler Routines (derived from cheops)
void ast_sched_context_destroy(struct ast_sched_context *c)
destroys a schedule context
Definition: sched.c:271
struct ast_sched_context * ast_sched_context_create(void)
Create a scheduler context.
Definition: sched.c:238
A machine to gather up arbitrary frames and convert them to raw slinear on demand.
int ast_stasis_channels_init(void)
Initialize the stasis channel topic and message types.
Media Stream API.
struct ast_stream_topology * ast_stream_topology_alloc(void)
Create a stream topology.
Definition: stream.c:650
int ast_stream_get_position(const struct ast_stream *stream)
Get the position of the stream in the topology.
Definition: stream.c:500
const char * ast_stream_topology_to_str(const struct ast_stream_topology *topology, struct ast_str **buf)
Get a string representing the topology for debugging/display purposes.
Definition: stream.c:936
struct ast_stream * ast_stream_topology_get_stream(const struct ast_stream_topology *topology, unsigned int position)
Get a specific stream from the topology.
Definition: stream.c:788
int ast_stream_topology_get_count(const struct ast_stream_topology *topology)
Get the number of streams in a topology.
Definition: stream.c:765
enum ast_media_type ast_stream_get_type(const struct ast_stream *stream)
Get the media type of a stream.
Definition: stream.c:316
void ast_stream_topology_free(struct ast_stream_topology *topology)
Unreference and destroy a stream topology.
Definition: stream.c:743
struct ast_stream_topology * ast_stream_topology_create_from_format_cap(struct ast_format_cap *cap)
A helper function that, given a format capabilities structure, creates a topology and separates the m...
Definition: stream.c:848
struct ast_format_cap * ast_stream_topology_get_formats(struct ast_stream_topology *topology)
Create a format capabilities structure representing the topology.
Definition: stream.c:930
int ast_stream_topology_equal(const struct ast_stream_topology *left, const struct ast_stream_topology *right)
Compare two stream topologies to see if they are equal.
Definition: stream.c:696
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition: strings.h:1139
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition: strings.h:761
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
Definition: strings.h:80
static force_inline int attribute_pure ast_str_hash(const char *str)
Compute a hash value on a string.
Definition: strings.h:1259
#define S_COR(a, b, c)
returns the equivalent of logic or for strings, with an additional boolean check: second one if not e...
Definition: strings.h:87
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
#define ast_str_tmp(init_len, __expr)
Provides a temporary ast_str and returns a copy of its buffer.
Definition: strings.h:1189
#define ast_str_alloca(init_len)
Definition: strings.h:848
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
Definition: strings.h:659
static force_inline int attribute_pure ast_str_case_hash(const char *str)
Compute a hash value on a case-insensitive string.
Definition: strings.h:1303
char * ast_trim_blanks(char *str)
Trims trailing whitespace characters from a string.
Definition: strings.h:186
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
static int force_inline attribute_pure ast_begins_with(const char *str, const char *prefix)
Checks whether a string begins with another.
Definition: strings.h:97
char * ast_strip(char *s)
Strip leading/trailing whitespace from a string.
Definition: strings.h:223
char * ast_skip_blanks(const char *str)
Gets a pointer to the first non-whitespace character in a string.
Definition: strings.h:161
Generic container type.
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition: astobj2.h:1821
Structure to pass both assignedid values to channel drivers.
Definition: channel.h:604
Structure that contains information regarding a channel in a bridge.
struct ast_channel * chan
Structure that contains features information.
Structure that contains information about a bridge.
Definition: bridge.h:349
struct ao2_iterator simple_iterator
Definition: channel.c:1353
struct ao2_iterator * active_iterator
Definition: channel.c:1357
Structure to describe a channel "technology", ie a channel driver See for examples:
Definition: channel.h:628
int(*const write)(struct ast_channel *chan, struct ast_frame *frame)
Write a frame, in standard format (see frame.h)
Definition: channel.h:750
struct ast_frame *(*const read)(struct ast_channel *chan)
Read a frame (or chain of frames from the same stream), in standard format (see frame....
Definition: channel.h:734
int(*const write_stream)(struct ast_channel *chan, int stream_num, struct ast_frame *frame)
Write a frame on a specific stream, in standard format (see frame.h)
Definition: channel.h:753
struct ast_frame *(*const read_stream)(struct ast_channel *chan)
Read a frame (or chain of frames from the same stream), in standard format (see frame....
Definition: channel.h:747
int(*const indicate)(struct ast_channel *c, int condition, const void *data, size_t datalen)
Indicate a particular condition (e.g. AST_CONTROL_BUSY or AST_CONTROL_RINGING or AST_CONTROL_CONGESTI...
Definition: channel.h:771
int(*const send_text)(struct ast_channel *chan, const char *text)
Display or transmit text.
Definition: channel.h:756
int(*const write_text)(struct ast_channel *chan, struct ast_frame *frame)
Write a text frame, in standard format.
Definition: channel.h:789
int(*const call)(struct ast_channel *chan, const char *addr, int timeout)
Make a call.
Definition: channel.h:701
enum ast_bridge_result(*const early_bridge)(struct ast_channel *c0, struct ast_channel *c1)
Bridge two channels of the same type together (early)
Definition: channel.h:768
int(*const send_text_data)(struct ast_channel *chan, struct ast_msg_data *data)
Display or transmit text with data.
Definition: channel.h:844
int(*const hangup)(struct ast_channel *chan)
Hangup (and possibly destroy) the channel.
Definition: channel.h:704
const char *const type
Definition: channel.h:629
int(*const queryoption)(struct ast_channel *chan, int option, void *data, int *datalen)
Query a given option. Called with chan locked.
Definition: channel.h:780
int(*const setoption)(struct ast_channel *chan, int option, void *data, int datalen)
Set a given option. Called with chan locked.
Definition: channel.h:777
int(*const answer)(struct ast_channel *chan)
Answer the channel.
Definition: channel.h:707
const char *const description
Definition: channel.h:630
int(* pre_call)(struct ast_channel *chan, const char *sub_args)
Execute a Gosub call on the channel in a technology specific way before a call is placed.
Definition: channel.h:841
int(*const send_digit_end)(struct ast_channel *chan, char digit, unsigned int duration)
Stop sending a literal DTMF digit.
Definition: channel.h:690
int(*const transfer)(struct ast_channel *chan, const char *newdest)
Blind transfer other side (see app_transfer.c and ast_transfer()
Definition: channel.h:783
int(*const write_video)(struct ast_channel *chan, struct ast_frame *frame)
Write a frame, in standard format.
Definition: channel.h:786
struct ast_frame *(*const exception)(struct ast_channel *chan)
Handle an exception, reading a frame.
Definition: channel.h:765
int(*const send_html)(struct ast_channel *chan, int subclass, const char *data, int len)
Send HTML data.
Definition: channel.h:762
int(*const answer_with_stream_topology)(struct ast_channel *chan, struct ast_stream_topology *topology)
Answer the channel with topology.
Definition: channel.h:720
Main Channel structure associated with a channel.
struct ast_channel_id uniqueid
struct ast_party_connected_line connected
Channel Connected Line ID information.
const ast_string_field accountcode
struct ast_channel::@331 fds
char exten[AST_MAX_EXTENSION]
const char * data
const struct ast_channel_tech * tech
struct ast_format * writeformat
struct ast_party_redirecting redirecting
Redirecting/Diversion information.
struct ast_party_dialed dialed
Dialed/Called information.
char context[AST_MAX_CONTEXT]
const ast_string_field name
struct ast_format * readformat
struct ast_flags flags
struct ast_party_caller caller
Channel Caller ID information.
descriptor for a cli entry.
Definition: cli.h:171
char * command
Definition: cli.h:186
const char * usage
Definition: cli.h:177
char chan_name[AST_CHANNEL_NAME]
enum ast_frame_read_action action
enum ast_control_t38 request_response
Structure for a data store type.
Definition: datastore.h:31
void *(* duplicate)(void *data)
Definition: datastore.h:33
void(* chan_fixup)(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
Fix up channel references on the masquerading channel.
Definition: datastore.h:48
const char * type
Definition: datastore.h:32
void(* chan_breakdown)(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
Fix up channel references on the channel being masqueraded into.
Definition: datastore.h:60
Structure for a data store object.
Definition: datastore.h:64
const struct ast_datastore_info * info
Definition: datastore.h:67
const char * uid
Definition: datastore.h:65
void * data
Definition: datastore.h:66
unsigned int inheritance
Definition: datastore.h:69
Format capabilities structure, holds formats + preference order + etc.
Definition: format_cap.c:54
Definition of a media format.
Definition: format.c:43
struct ast_format * format
Data structure associated with a single frame of data.
struct ast_frame_subclass subclass
union ast_frame::@226 data
enum ast_frame_type frametype
struct ast_frame * next
const char * src
void(* digit)(struct ast_channel *chan, char digit)
Definition: channel.h:235
int(* generate)(struct ast_channel *chan, void *data, int len, int samples)
Definition: channel.h:233
void *(* alloc)(struct ast_channel *chan, void *params)
Definition: channel.h:226
void(* release)(struct ast_channel *chan, void *data)
Definition: channel.h:228
void(* write_format_change)(struct ast_channel *chan, void *data)
Definition: channel.h:238
Abstract JSON element (object, array, string, int, ...).
enum ast_msg_data_attribute_type type
Definition: message.h:463
Structure used to transport a message through the frame core.
Caller Party information.
Definition: channel.h:418
struct ast_party_id priv
Private caller party ID.
Definition: channel.h:430
struct ast_party_id id
Caller party ID.
Definition: channel.h:420
int ani2
Automatic Number Identification 2 (Info Digits)
Definition: channel.h:433
struct ast_party_id ani
Automatic Number Identification (ANI)
Definition: channel.h:427
Connected Line/Party information.
Definition: channel.h:456
int source
Information about the source of an update.
Definition: channel.h:482
struct ast_party_id priv
Private connected party ID.
Definition: channel.h:468
struct ast_party_id id
Connected party ID.
Definition: channel.h:458
int ani2
Automatic Number Identification 2 (Info Digits)
Definition: channel.h:475
struct ast_party_id ani
Automatic Number Identification (ANI)
Definition: channel.h:465
Dialed/Called Party information.
Definition: channel.h:378
struct ast_party_dialed::@208 number
Dialed/Called number.
struct ast_party_subaddress subaddress
Dialed/Called subaddress.
Definition: channel.h:391
char * str
Subscriber phone number (Malloced)
Definition: channel.h:386
int plan
Q.931 Type-Of-Number and Numbering-Plan encoded fields.
Definition: channel.h:388
int transit_network_select
Transit Network Select.
Definition: channel.h:397
struct ast_party_subaddress_ies subaddress
Subscriber subaddress ies.
Definition: channel.c:8551
struct ast_party_name_ies name
Subscriber name ies.
Definition: channel.c:8547
int combined_presentation
Combined name and number presentation ie.
Definition: channel.c:8558
struct ast_party_number_ies number
Subscriber phone number ies.
Definition: channel.c:8549
int tag
User party id tag ie.
Definition: channel.c:8553
Information needed to identify an endpoint in a call.
Definition: channel.h:338
struct ast_party_subaddress subaddress
Subscriber subaddress.
Definition: channel.h:344
char * tag
User-set "tag".
Definition: channel.h:354
struct ast_party_name name
Subscriber name.
Definition: channel.h:340
struct ast_party_number number
Subscriber phone number.
Definition: channel.h:342
int char_set
Character set ie.
Definition: channel.c:8326
int presentation
presentation-indicator ie
Definition: channel.c:8328
int str
Subscriber name ie.
Definition: channel.c:8324
int valid
valid/present ie
Definition: channel.c:8330
Information needed to specify a name in a call.
Definition: channel.h:262
int char_set
Character set the name is using.
Definition: channel.h:272
int presentation
Q.931 encoded presentation-indicator encoded field.
Definition: channel.h:277
unsigned char valid
TRUE if the name information is valid/present.
Definition: channel.h:279
char * str
Subscriber name (Malloced)
Definition: channel.h:264
int presentation
presentation-indicator ie
Definition: channel.c:8402
int str
Subscriber phone number ie.
Definition: channel.c:8398
int valid
valid/present ie
Definition: channel.c:8404
int plan
Type-Of-Number and Numbering-Plan ie.
Definition: channel.c:8400
Information needed to specify a number in a call.
Definition: channel.h:289
int presentation
Q.931 presentation-indicator and screening-indicator encoded fields.
Definition: channel.h:295
unsigned char valid
TRUE if the number information is valid/present.
Definition: channel.h:297
char * str
Subscriber phone number (Malloced)
Definition: channel.h:291
int plan
Q.931 Type-Of-Number and Numbering-Plan encoded fields.
Definition: channel.h:293
Redirecting reason information.
Definition: channel.h:501
int code
enum AST_REDIRECTING_REASON value for redirection
Definition: channel.h:510
char * str
a string value for the redirecting reason
Definition: channel.h:507
Redirecting Line information. RDNIS (Redirecting Directory Number Information Service) Where a call d...
Definition: channel.h:522
struct ast_party_id priv_to
Call is redirecting to a new party (Sent to the caller) - private representation.
Definition: channel.h:539
struct ast_party_redirecting_reason orig_reason
Reason for the redirection by the original party.
Definition: channel.h:545
struct ast_party_redirecting_reason reason
Reason for the redirection.
Definition: channel.h:542
struct ast_party_id priv_from
Who is redirecting the call (Sent to the party the call is redirected toward) - private representatio...
Definition: channel.h:536
struct ast_party_id from
Who is redirecting the call (Sent to the party the call is redirected toward)
Definition: channel.h:527
int count
Number of times the call was redirected.
Definition: channel.h:548
struct ast_party_id to
Call is redirecting to a new party (Sent to the caller)
Definition: channel.h:530
struct ast_party_id orig
Who originally redirected the call (Sent to the party the call is redirected toward)
Definition: channel.h:524
struct ast_party_id priv_orig
Who originally redirected the call (Sent to the party the call is redirected toward) - private repres...
Definition: channel.h:533
int str
subaddress ie.
Definition: channel.c:8472
int odd_even_indicator
odd/even indicator ie
Definition: channel.c:8476
int valid
valid/present ie
Definition: channel.c:8478
int type
subaddress type ie
Definition: channel.c:8474
Information needed to specify a subaddress in a call.
Definition: channel.h:307
unsigned char odd_even_indicator
TRUE if odd number of address signals.
Definition: channel.h:326
unsigned char valid
TRUE if the subaddress information is valid/present.
Definition: channel.h:328
char * str
Malloced subaddress string.
Definition: channel.h:313
int type
Q.931 subaddress type.
Definition: channel.h:320
Indicate what information in ast_party_caller should be set.
Definition: channel.h:440
Indicate what information in ast_party_connected_line should be set.
Definition: channel.h:489
Indicate what information in ast_party_id should be set.
Definition: channel.h:361
unsigned char subaddress
Definition: channel.h:367
unsigned char number
Definition: channel.h:365
unsigned char name
Definition: channel.h:363
Indicate what information in ast_party_redirecting should be set.
Definition: channel.h:555
struct ast_format * old_write_format
Definition: channel.c:8160
Support for dynamic strings.
Definition: strings.h:623
Description of a tone.
Definition: indications.h:35
const char * data
Description of a tone.
Definition: indications.h:52
Default structure for translators, with the basic fields and buffers, all allocated as part of the sa...
Definition: translate.h:213
int interleaved_stereo
Definition: translate.h:238
struct ast_var_t::@211 entries
Structure for variables, used for configurations and for channel variables.
struct ast_variable * next
the list of registered channel types
Definition: channel.c:121
map AST_CAUSE's to readable string representations
Definition: channel.c:130
const char * desc
Definition: channel.c:133
const char * name
Definition: channel.c:132
int cause
Definition: channel.c:131
List of channel drivers.
Definition: app_dial.c:797
struct ast_channel * chan
Definition: app_dial.c:799
const struct ast_channel_tech * tech
Definition: channel.c:116
const char * tech
Definition: app_dial.c:803
struct chanlist::@329 list
Definition: search.h:40
Definition: astman.c:222
List of channel variables to append to all channel-related events.
Definition: channel.c:7822
struct manager_channel_variable::@330 entry
unsigned int isfunc
Definition: channel.c:7824
Named group member structure.
Definition: channel.c:7650
unsigned int hash
Definition: channel.c:7652
Number structure.
Definition: app_followme.c:154
const char * cid_num
Definition: channel.h:1109
struct ast_variable * vars
Definition: channel.h:1112
int connect_on_early_media
Definition: channel.h:1108
const char * account
Definition: channel.h:1111
const char * cid_name
Definition: channel.h:1110
const char * exten
Definition: channel.h:1106
const char * context
Definition: channel.h:1105
struct ast_channel * parent_channel
Definition: channel.h:1113
int16_t * samples_buf
Definition: channel.c:5032
size_t num_samples
Definition: channel.c:5036
plc_state_t plc_state
Definition: channel.c:5037
struct ast_format *(* get_format)(struct ast_channel *chan)
Definition: channel.c:5563
void(* set_trans)(struct ast_channel *chan, struct ast_trans_pvt *value)
Definition: channel.c:5562
void(* set_rawformat)(struct ast_channel *chan, struct ast_format *format)
Definition: channel.c:5566
struct ast_trans_pvt *(* get_trans)(const struct ast_channel *chan)
Definition: channel.c:5561
void(* set_format)(struct ast_channel *chan, struct ast_format *format)
Definition: channel.c:5564
const char * direction
Definition: channel.c:5560
struct ast_format *(* get_rawformat)(struct ast_channel *chan)
Definition: channel.c:5565
int framehook_id
Definition: channel.c:10721
enum ast_frame_type frametype
Definition: channel.c:10719
unsigned int direction
Definition: channel.c:10720
int duration
Definition: channel.c:7464
unsigned char offset[AST_FRIENDLY_OFFSET]
Definition: channel.c:7482
struct ast_format * origwfmt
Definition: channel.c:7477
struct ast_frame f
Definition: channel.c:7481
short data[4000]
Definition: channel.c:7483
Definition: ast_expr2.c:325
int value
Definition: syslog.c:37
Test Framework API.
#define ast_test_suite_event_notify(s, f,...)
Definition: test.h:189
static const struct ast_aeap_message_handler handlers[]
Definition: test_aeap.c:135
int done
Definition: test_amihooks.c:48
static struct test_options options
static struct test_val b
static struct test_val a
static struct test_val d
static struct test_val c
Definitions to aid in the use of thread local storage.
int ast_threadstorage_set_ptr(struct ast_threadstorage *ts, void *ptr)
Set a raw pointer from threadstorage.
void * ast_threadstorage_get_ptr(struct ast_threadstorage *ts)
Retrieve a raw pointer from threadstorage.
void * ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size)
Retrieve thread storage.
#define AST_THREADSTORAGE(name)
Define a thread storage variable.
Definition: threadstorage.h:86
int ast_tvzero(const struct timeval t)
Returns true if the argument is 0,0.
Definition: time.h:117
int ast_tvcmp(struct timeval _a, struct timeval _b)
Compress two struct timeval instances returning -1, 0, 1 if the first arg is smaller,...
Definition: time.h:137
int ast_remaining_ms(struct timeval start, int max_ms)
Calculate remaining milliseconds given a starting timestamp and upper bound.
Definition: utils.c:2281
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
Definition: extconf.c:2282
struct timeval ast_tvsub(struct timeval a, struct timeval b)
Returns the difference of two timevals a - b.
Definition: extconf.c:2297
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition: time.h:107
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
Timing source management.
unsigned int ast_timer_get_max_rate(const struct ast_timer *handle)
Get maximum rate supported for a timer.
Definition: timing.c:191
void ast_timer_close(struct ast_timer *handle)
Close an opened timing handle.
Definition: timing.c:154
int ast_timer_ack(const struct ast_timer *handle, unsigned int quantity)
Acknowledge a timer event.
Definition: timing.c:171
int ast_timer_set_rate(const struct ast_timer *handle, unsigned int rate)
Set the timing tick rate.
Definition: timing.c:166
enum ast_timer_event ast_timer_get_event(const struct ast_timer *handle)
Retrieve timing event.
Definition: timing.c:186
int ast_timer_enable_continuous(const struct ast_timer *handle)
Enable continuous mode.
Definition: timing.c:176
const char * ast_timer_get_name(const struct ast_timer *handle)
Get name of timer in use.
Definition: timing.c:196
int ast_timer_disable_continuous(const struct ast_timer *handle)
Disable continuous mode.
Definition: timing.c:181
struct ast_timer * ast_timer_open(void)
Open a timer.
Definition: timing.c:122
ast_timer_event
Definition: timing.h:57
@ AST_TIMING_EVENT_CONTINUOUS
Definition: timing.h:59
@ AST_TIMING_EVENT_EXPIRED
Definition: timing.h:58
int ast_timer_fd(const struct ast_timer *handle)
Get a poll()-able file descriptor for a timer.
Definition: timing.c:161
General Asterisk channel transcoding definitions.
#define AST_TRANS_CAP_RESTRICTED_DIGITAL
Definition: transcap.h:37
#define AST_TRANS_CAP_DIGITAL
Definition: transcap.h:36
#define AST_TRANS_CAP_DIGITAL_W_TONES
Definition: transcap.h:40
#define AST_TRANS_CAP_SPEECH
Definition: transcap.h:35
#define AST_TRANS_CAP_3_1K_AUDIO
Definition: transcap.h:38
#define AST_TRANS_CAP_VIDEO
Definition: transcap.h:41
Support for translation of data formats. translate.c.
struct ast_frame * ast_translate(struct ast_trans_pvt *tr, struct ast_frame *f, int consume)
translates one or more frames Apply an input frame into the translator and receive zero or one output...
Definition: translate.c:566
int ast_translator_best_choice(struct ast_format_cap *dst_cap, struct ast_format_cap *src_cap, struct ast_format **dst_fmt_out, struct ast_format **src_fmt_out)
Chooses the best translation path.
Definition: translate.c:1402
void ast_translator_free_path(struct ast_trans_pvt *tr)
Frees a translator path Frees the given translator path structure.
Definition: translate.c:476
struct ast_trans_pvt * ast_translator_build_path(struct ast_format *dest, struct ast_format *source)
Builds a translator path Build a path (possibly NULL) from source to dest.
Definition: translate.c:486
unsigned int ast_translate_path_steps(struct ast_format *dest, struct ast_format *src)
Returns the number of steps required to convert from 'src' to 'dest'.
Definition: translate.c:1536
FILE * out
Definition: utils/frame.c:33
Utility functions.
#define ast_test_flag(p, flag)
Definition: utils.h:63
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
#define ast_assert(a)
Definition: utils.h:739
int ast_get_tid(void)
Get current thread ID.
Definition: utils.c:2752
#define ast_clear_flag(p, flag)
Definition: utils.h:77
#define SWAP(a, b)
Definition: utils.h:235
#define ast_set_flag(p, flag)
Definition: utils.h:70
#define ARRAY_LEN(a)
Definition: utils.h:666
#define MAX(a, b)
Definition: utils.h:233
#define AST_FLAGS_ALL
Definition: utils.h:196