app_dial.c File Reference

dial() & retrydial() - Trivial application to dial a channel and send an URL on answer More...

#include "asterisk.h"
#include <sys/time.h>
#include <signal.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include "asterisk/paths.h"
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/translate.h"
#include "asterisk/say.h"
#include "asterisk/config.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/callerid.h"
#include "asterisk/utils.h"
#include "asterisk/app.h"
#include "asterisk/causes.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/manager.h"
#include "asterisk/privacy.h"
#include "asterisk/stringfields.h"
#include "asterisk/dsp.h"
#include "asterisk/aoc.h"
#include "asterisk/ccss.h"
#include "asterisk/indications.h"
#include "asterisk/framehook.h"
#include "asterisk/dial.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/bridge_after.h"
#include "asterisk/features_config.h"
#include "asterisk/max_forwards.h"
#include "asterisk/stream.h"

Include dependency graph for app_dial.c:

Go to the source code of this file.

Data Structures
struct	cause_args
struct	chanlist
	List of channel drivers. More...
struct	dial_head
struct	privacy_args

Macros
#define	AST_MAX_WATCHERS   256
#define	CAN_EARLY_BRIDGE(flags, chan, peer)
#define	DIAL_CALLERID_ABSENT   (1LLU << 33) /* TRUE if caller id is not available for connected line. */
#define	DIAL_NOFORWARDHTML   (1LLU << 32)
#define	DIAL_STILLGOING   (1LLU << 31)
#define	OPT_CALLEE_GO_ON   (1LLU << 36)
#define	OPT_CALLER_ANSWER   (1LLU << 40)
#define	OPT_CANCEL_ELSEWHERE   (1LLU << 34)
#define	OPT_CANCEL_TIMEOUT   (1LLU << 37)
#define	OPT_FORCE_CID_PRES   (1LLU << 39)
#define	OPT_FORCE_CID_TAG   (1LLU << 38)
#define	OPT_HANGUPCAUSE   (1LLU << 44)
#define	OPT_PEER_H   (1LLU << 35)
#define	OPT_PREDIAL_CALLEE   (1LLU << 41)
#define	OPT_PREDIAL_CALLER   (1LLU << 42)
#define	OPT_RING_WITH_EARLY_MEDIA   (1LLU << 43)

Enumerations
enum	{   OPT_ANNOUNCE = (1 << 0), OPT_RESETCDR = (1 << 1), OPT_DTMF_EXIT = (1 << 2), OPT_SENDDTMF = (1 << 3),   OPT_FORCECLID = (1 << 4), OPT_GO_ON = (1 << 5), OPT_CALLEE_HANGUP = (1 << 6), OPT_CALLER_HANGUP = (1 << 7),   OPT_ORIGINAL_CLID = (1 << 8), OPT_DURATION_LIMIT = (1 << 9), OPT_MUSICBACK = (1 << 10), OPT_CALLEE_MACRO = (1 << 11),   OPT_SCREEN_NOINTRO = (1 << 12), OPT_SCREEN_NOCALLERID = (1 << 13), OPT_IGNORE_CONNECTEDLINE = (1 << 14), OPT_SCREENING = (1 << 15),   OPT_PRIVACY = (1 << 16), OPT_RINGBACK = (1 << 17), OPT_DURATION_STOP = (1 << 18), OPT_CALLEE_TRANSFER = (1 << 19),   OPT_CALLER_TRANSFER = (1 << 20), OPT_CALLEE_MONITOR = (1 << 21), OPT_CALLER_MONITOR = (1 << 22), OPT_GOTO = (1 << 23),   OPT_OPERMODE = (1 << 24), OPT_CALLEE_PARK = (1 << 25), OPT_CALLER_PARK = (1 << 26), OPT_IGNORE_FORWARDING = (1 << 27),   OPT_CALLEE_GOSUB = (1 << 28), OPT_CALLEE_MIXMONITOR = (1 << 29), OPT_CALLER_MIXMONITOR = (1 << 30) }
enum	{   OPT_ARG_ANNOUNCE = 0, OPT_ARG_SENDDTMF, OPT_ARG_GOTO, OPT_ARG_DURATION_LIMIT,   OPT_ARG_MUSICBACK, OPT_ARG_CALLEE_MACRO, OPT_ARG_RINGBACK, OPT_ARG_CALLEE_GOSUB,   OPT_ARG_CALLEE_GO_ON, OPT_ARG_PRIVACY, OPT_ARG_DURATION_STOP, OPT_ARG_OPERMODE,   OPT_ARG_SCREEN_NOINTRO, OPT_ARG_ORIGINAL_CLID, OPT_ARG_FORCECLID, OPT_ARG_FORCE_CID_TAG,   OPT_ARG_FORCE_CID_PRES, OPT_ARG_PREDIAL_CALLEE, OPT_ARG_PREDIAL_CALLER, OPT_ARG_HANGUPCAUSE,   OPT_ARG_ARRAY_SIZE }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static void	chanlist_free (struct chanlist *outgoing)
static int	detect_disconnect (struct ast_channel *chan, char code, struct ast_str **featurecode)
static int	dial_exec (struct ast_channel *chan, const char *data)
static int	dial_exec_full (struct ast_channel *chan, const char *data, struct ast_flags64 *peerflags, int *continue_exec)
static int	dial_handle_playtones (struct ast_channel *chan, const char *data)
static void	do_forward (struct chanlist *o, struct cause_args *num, struct ast_flags64 *peerflags, int single, int caller_entertained, int *to, struct ast_party_id *forced_clid, struct ast_party_id *stored_clid)
static void	end_bridge_callback (void *data)
static void	end_bridge_callback_data_fixup (struct ast_bridge_config *bconfig, struct ast_channel *originator, struct ast_channel *terminator)
static const char *	get_cid_name (char *name, int namelen, struct ast_channel *chan)
static void	handle_cause (int cause, struct cause_args *num)
static void	hanguptree (struct dial_head *out_chans, struct ast_channel *exception, int hangupcause)
static int	load_module (void)
static int	onedigit_goto (struct ast_channel *chan, const char *context, char exten, int pri)
static void	publish_dial_end_event (struct ast_channel *in, struct dial_head *out_chans, struct ast_channel *exception, const char *status)
static int	retrydial_exec (struct ast_channel *chan, const char *data)
static void	set_duration_var (struct ast_channel *chan, const char *var_base, int64_t duration)
static void	setup_peer_after_bridge_goto (struct ast_channel *chan, struct ast_channel *peer, struct ast_flags64 *opts, char *opt_args[])
static int	setup_privacy_args (struct privacy_args *pa, struct ast_flags64 *opts, char *opt_args[], struct ast_channel *chan)
	returns 1 if successful, 0 or <0 if the caller should 'goto out' More...
static int	unload_module (void)
static void	update_connected_line_from_peer (struct ast_channel *chan, struct ast_channel *peer, int is_caller)
static int	valid_priv_reply (struct ast_flags64 *opts, int res)
static struct ast_channel *	wait_for_answer (struct ast_channel *in, struct dial_head *out_chans, int *to, struct ast_flags64 *peerflags, char *opt_args[], struct privacy_args *pa, const struct cause_args *num_in, int *result, char *dtmf_progress, char *mf_progress, const int ignore_cc, struct ast_party_id *forced_clid, struct ast_party_id *stored_clid, struct ast_bridge_config *config)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Dialing Application" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "ccss", }
static const char	app [] = "Dial"
static const struct ast_module_info *	ast_module_info = &__mod_info
static const struct ast_app_option	dial_exec_options [128] = { [ 'A' ] = { .flag = OPT_ANNOUNCE , .arg_index = OPT_ARG_ANNOUNCE + 1 }, [ 'a' ] = { .flag = (1LLU << 40) }, [ 'b' ] = { .flag = (1LLU << 41) , .arg_index = OPT_ARG_PREDIAL_CALLEE + 1 }, [ 'B' ] = { .flag = (1LLU << 42) , .arg_index = OPT_ARG_PREDIAL_CALLER + 1 }, [ 'C' ] = { .flag = OPT_RESETCDR }, [ 'c' ] = { .flag = (1LLU << 34) }, [ 'd' ] = { .flag = OPT_DTMF_EXIT }, [ 'D' ] = { .flag = OPT_SENDDTMF , .arg_index = OPT_ARG_SENDDTMF + 1 }, [ 'e' ] = { .flag = (1LLU << 35) }, [ 'f' ] = { .flag = OPT_FORCECLID , .arg_index = OPT_ARG_FORCECLID + 1 }, [ 'F' ] = { .flag = (1LLU << 36) , .arg_index = OPT_ARG_CALLEE_GO_ON + 1 }, [ 'g' ] = { .flag = OPT_GO_ON }, [ 'G' ] = { .flag = OPT_GOTO , .arg_index = OPT_ARG_GOTO + 1 }, [ 'h' ] = { .flag = OPT_CALLEE_HANGUP }, [ 'H' ] = { .flag = OPT_CALLER_HANGUP }, [ 'i' ] = { .flag = OPT_IGNORE_FORWARDING }, [ 'I' ] = { .flag = OPT_IGNORE_CONNECTEDLINE }, [ 'k' ] = { .flag = OPT_CALLEE_PARK }, [ 'K' ] = { .flag = OPT_CALLER_PARK }, [ 'L' ] = { .flag = OPT_DURATION_LIMIT , .arg_index = OPT_ARG_DURATION_LIMIT + 1 }, [ 'm' ] = { .flag = OPT_MUSICBACK , .arg_index = OPT_ARG_MUSICBACK + 1 }, [ 'M' ] = { .flag = OPT_CALLEE_MACRO , .arg_index = OPT_ARG_CALLEE_MACRO + 1 }, [ 'n' ] = { .flag = OPT_SCREEN_NOINTRO , .arg_index = OPT_ARG_SCREEN_NOINTRO + 1 }, [ 'N' ] = { .flag = OPT_SCREEN_NOCALLERID }, [ 'o' ] = { .flag = OPT_ORIGINAL_CLID , .arg_index = OPT_ARG_ORIGINAL_CLID + 1 }, [ 'O' ] = { .flag = OPT_OPERMODE , .arg_index = OPT_ARG_OPERMODE + 1 }, [ 'p' ] = { .flag = OPT_SCREENING }, [ 'P' ] = { .flag = OPT_PRIVACY , .arg_index = OPT_ARG_PRIVACY + 1 }, [ 'Q' ] = { .flag = (1LLU << 44) , .arg_index = OPT_ARG_HANGUPCAUSE + 1 }, [ 'r' ] = { .flag = OPT_RINGBACK , .arg_index = OPT_ARG_RINGBACK + 1 }, [ 'R' ] = { .flag = (1LLU << 43) }, [ 'S' ] = { .flag = OPT_DURATION_STOP , .arg_index = OPT_ARG_DURATION_STOP + 1 }, [ 's' ] = { .flag = (1LLU << 38) , .arg_index = OPT_ARG_FORCE_CID_TAG + 1 }, [ 't' ] = { .flag = OPT_CALLEE_TRANSFER }, [ 'T' ] = { .flag = OPT_CALLER_TRANSFER }, [ 'u' ] = { .flag = (1LLU << 39) , .arg_index = OPT_ARG_FORCE_CID_PRES + 1 }, [ 'U' ] = { .flag = OPT_CALLEE_GOSUB , .arg_index = OPT_ARG_CALLEE_GOSUB + 1 }, [ 'w' ] = { .flag = OPT_CALLEE_MONITOR }, [ 'W' ] = { .flag = OPT_CALLER_MONITOR }, [ 'x' ] = { .flag = OPT_CALLEE_MIXMONITOR }, [ 'X' ] = { .flag = OPT_CALLER_MIXMONITOR }, [ 'z' ] = { .flag = (1LLU << 37) }, }
static const char	rapp [] = "RetryDial"

Detailed Description

dial() & retrydial() - Trivial application to dial a channel and send an URL on answer

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file app_dial.c.

Macro Definition Documentation

AST_MAX_WATCHERS

#define AST_MAX_WATCHERS   256

Definition at line 847 of file app_dial.c.

Referenced by wait_for_answer().

CAN_EARLY_BRIDGE

#define CAN_EARLY_BRIDGE	(		flags,
			chan,
			peer
	)

Definition at line 786 of file app_dial.c.

Referenced by dial_exec_full(), do_forward(), and wait_for_answer().

DIAL_CALLERID_ABSENT

#define DIAL_CALLERID_ABSENT   (1LLU << 33) /* TRUE if caller id is not available for connected line. */

Definition at line 703 of file app_dial.c.

Referenced by dial_exec_full(), do_forward(), and wait_for_answer().

DIAL_NOFORWARDHTML

#define DIAL_NOFORWARDHTML   (1LLU << 32)

Definition at line 702 of file app_dial.c.

Referenced by dial_exec_full(), and wait_for_answer().

DIAL_STILLGOING

#define DIAL_STILLGOING   (1LLU << 31)

Definition at line 701 of file app_dial.c.

Referenced by dial_exec_full(), do_forward(), and wait_for_answer().

OPT_CALLEE_GO_ON

#define OPT_CALLEE_GO_ON   (1LLU << 36)

Definition at line 706 of file app_dial.c.

Referenced by setup_peer_after_bridge_goto().

OPT_CALLER_ANSWER

#define OPT_CALLER_ANSWER   (1LLU << 40)

Definition at line 710 of file app_dial.c.

Referenced by dial_exec_full().

OPT_CANCEL_ELSEWHERE

#define OPT_CANCEL_ELSEWHERE   (1LLU << 34)

Definition at line 704 of file app_dial.c.

Referenced by dial_exec_full().

OPT_CANCEL_TIMEOUT

#define OPT_CANCEL_TIMEOUT   (1LLU << 37)

Definition at line 707 of file app_dial.c.

Referenced by dial_exec_full(), and do_forward().

OPT_FORCE_CID_PRES

#define OPT_FORCE_CID_PRES   (1LLU << 39)

Definition at line 709 of file app_dial.c.

Referenced by dial_exec_full().

OPT_FORCE_CID_TAG

#define OPT_FORCE_CID_TAG   (1LLU << 38)

Definition at line 708 of file app_dial.c.

Referenced by dial_exec_full().

OPT_HANGUPCAUSE

#define OPT_HANGUPCAUSE   (1LLU << 44)

Definition at line 714 of file app_dial.c.

Referenced by dial_exec_full().

OPT_PEER_H

#define OPT_PEER_H   (1LLU << 35)

Definition at line 705 of file app_dial.c.

Referenced by setup_peer_after_bridge_goto().

OPT_PREDIAL_CALLEE

#define OPT_PREDIAL_CALLEE   (1LLU << 41)

Definition at line 711 of file app_dial.c.

Referenced by dial_exec_full().

OPT_PREDIAL_CALLER

#define OPT_PREDIAL_CALLER   (1LLU << 42)

Definition at line 712 of file app_dial.c.

Referenced by dial_exec_full().

OPT_RING_WITH_EARLY_MEDIA

#define OPT_RING_WITH_EARLY_MEDIA   (1LLU << 43)

Definition at line 713 of file app_dial.c.

Referenced by dial_exec_full(), and valid_priv_reply().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
OPT_ANNOUNCE
OPT_RESETCDR
OPT_DTMF_EXIT
OPT_SENDDTMF
OPT_FORCECLID
OPT_GO_ON
OPT_CALLEE_HANGUP
OPT_CALLER_HANGUP
OPT_ORIGINAL_CLID
OPT_DURATION_LIMIT
OPT_MUSICBACK
OPT_CALLEE_MACRO
OPT_SCREEN_NOINTRO
OPT_SCREEN_NOCALLERID
OPT_IGNORE_CONNECTEDLINE
OPT_SCREENING
OPT_PRIVACY
OPT_RINGBACK
OPT_DURATION_STOP
OPT_CALLEE_TRANSFER
OPT_CALLER_TRANSFER
OPT_CALLEE_MONITOR
OPT_CALLER_MONITOR
OPT_GOTO
OPT_OPERMODE
OPT_CALLEE_PARK
OPT_CALLER_PARK
OPT_IGNORE_FORWARDING
OPT_CALLEE_GOSUB
OPT_CALLEE_MIXMONITOR
OPT_CALLER_MIXMONITOR

Definition at line 666 of file app_dial.c.

     {
   OPT_ANNOUNCE =          (1 << 0),
   OPT_RESETCDR =          (1 << 1),
   OPT_DTMF_EXIT =         (1 << 2),
   OPT_SENDDTMF =          (1 << 3),
   OPT_FORCECLID =         (1 << 4),
   OPT_GO_ON =             (1 << 5),
   OPT_CALLEE_HANGUP =     (1 << 6),
   OPT_CALLER_HANGUP =     (1 << 7),
   OPT_ORIGINAL_CLID =     (1 << 8),
   OPT_DURATION_LIMIT =    (1 << 9),
   OPT_MUSICBACK =         (1 << 10),
   OPT_CALLEE_MACRO =      (1 << 11),
   OPT_SCREEN_NOINTRO =    (1 << 12),
   OPT_SCREEN_NOCALLERID = (1 << 13),
   OPT_IGNORE_CONNECTEDLINE = (1 << 14),
   OPT_SCREENING =         (1 << 15),
   OPT_PRIVACY =           (1 << 16),
   OPT_RINGBACK =          (1 << 17),
   OPT_DURATION_STOP =     (1 << 18),
   OPT_CALLEE_TRANSFER =   (1 << 19),
   OPT_CALLER_TRANSFER =   (1 << 20),
   OPT_CALLEE_MONITOR =    (1 << 21),
   OPT_CALLER_MONITOR =    (1 << 22),
   OPT_GOTO =              (1 << 23),
   OPT_OPERMODE =          (1 << 24),
   OPT_CALLEE_PARK =       (1 << 25),
   OPT_CALLER_PARK =       (1 << 26),
   OPT_IGNORE_FORWARDING = (1 << 27),
   OPT_CALLEE_GOSUB =      (1 << 28),
   OPT_CALLEE_MIXMONITOR = (1 << 29),
   OPT_CALLER_MIXMONITOR = (1 << 30),
};

anonymous enum

anonymous enum

Enumerator
OPT_ARG_ANNOUNCE
OPT_ARG_SENDDTMF
OPT_ARG_GOTO
OPT_ARG_DURATION_LIMIT
OPT_ARG_MUSICBACK
OPT_ARG_CALLEE_MACRO
OPT_ARG_RINGBACK
OPT_ARG_CALLEE_GOSUB
OPT_ARG_CALLEE_GO_ON
OPT_ARG_PRIVACY
OPT_ARG_DURATION_STOP
OPT_ARG_OPERMODE
OPT_ARG_SCREEN_NOINTRO
OPT_ARG_ORIGINAL_CLID
OPT_ARG_FORCECLID
OPT_ARG_FORCE_CID_TAG
OPT_ARG_FORCE_CID_PRES
OPT_ARG_PREDIAL_CALLEE
OPT_ARG_PREDIAL_CALLER
OPT_ARG_HANGUPCAUSE
OPT_ARG_ARRAY_SIZE

Definition at line 716 of file app_dial.c.

     {
   OPT_ARG_ANNOUNCE = 0,
   OPT_ARG_SENDDTMF,
   OPT_ARG_GOTO,
   OPT_ARG_DURATION_LIMIT,
   OPT_ARG_MUSICBACK,
   OPT_ARG_CALLEE_MACRO,
   OPT_ARG_RINGBACK,
   OPT_ARG_CALLEE_GOSUB,
   OPT_ARG_CALLEE_GO_ON,
   OPT_ARG_PRIVACY,
   OPT_ARG_DURATION_STOP,
   OPT_ARG_OPERMODE,
   OPT_ARG_SCREEN_NOINTRO,
   OPT_ARG_ORIGINAL_CLID,
   OPT_ARG_FORCECLID,
   OPT_ARG_FORCE_CID_TAG,
   OPT_ARG_FORCE_CID_PRES,
   OPT_ARG_PREDIAL_CALLEE,
   OPT_ARG_PREDIAL_CALLER,
   OPT_ARG_HANGUPCAUSE,
   /* note: this entry _MUST_ be the last one in the enum */
   OPT_ARG_ARRAY_SIZE
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 3567 of file app_dial.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 3567 of file app_dial.c.

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 3567 of file app_dial.c.

chanlist_free()

static void chanlist_free ( struct chanlist *  outgoing )

static

Definition at line 821 of file app_dial.c.

References chanlist::aoc_s_rate_list, ast_aoc_destroy_decoded(), ast_free, ast_party_connected_line_free(), chanlist::connected, and chanlist::orig_chan_name.

Referenced by dial_exec_full(), and hanguptree().

{
   ast_party_connected_line_free(&outgoing->connected);
   ast_aoc_destroy_decoded(outgoing->aoc_s_rate_list);
   ast_free(outgoing->orig_chan_name);
   ast_free(outgoing);
}

detect_disconnect()

static int detect_disconnect ( struct ast_channel *  chan, char  code, struct ast_str **  featurecode  )

static

Definition at line 1898 of file app_dial.c.

References AST_FEATURE_MAX_LEN, ast_get_builtin_feature(), ast_str_append(), ast_str_buffer(), ast_str_reset(), and ast_str_strlen().

Referenced by wait_for_answer().

{
   char disconnect_code[AST_FEATURE_MAX_LEN];
   int res;

   ast_str_append(featurecode, 1, "%c", code);

   res = ast_get_builtin_feature(chan, "disconnect", disconnect_code, sizeof(disconnect_code));
   if (res) {
      ast_str_reset(*featurecode);
      return 0;
   }

   if (strlen(disconnect_code) > ast_str_strlen(*featurecode)) {
      /* Could be a partial match, anyway */
      if (strncmp(disconnect_code, ast_str_buffer(*featurecode), ast_str_strlen(*featurecode))) {
         ast_str_reset(*featurecode);
      }
      return 0;
   }

   if (strcmp(disconnect_code, ast_str_buffer(*featurecode))) {
      ast_str_reset(*featurecode);
      return 0;
   }

   return 1;
}

dial_exec()

static int dial_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 3425 of file app_dial.c.

References dial_exec_full(), and NULL.

Referenced by load_module().

{
   struct ast_flags64 peerflags;

   memset(&peerflags, 0, sizeof(peerflags));

   return dial_exec_full(chan, data, &peerflags, NULL);
}

dial_exec_full()

static int dial_exec_full ( struct ast_channel *  chan, const char *  data, struct ast_flags64 *  peerflags, int *  continue_exec  )

static

< TRUE if force CallerID on call forward only. Legacy behaviour.

Forced CallerID party information to send.

Note

This will not have any malloced strings so do not free it.

Stored CallerID information if needed.

Note

If OPT_ORIGINAL_CLID set then this is the o option CallerID. Otherwise it is the dialplan extension and hint name.

This will not have any malloced strings so do not free it.

CallerID party information to store.

Note

This will not have any malloced strings so do not free it.

Definition at line 2254 of file app_dial.c.

References ast_bridge_config::answer_topology, args, ast_answer(), AST_APP_ARG, ast_app_exec_macro(), ast_app_exec_sub(), ast_app_expand_sub_args(), ast_app_group_set_channel(), ast_app_parse_options64(), ast_asprintf, ast_autoservice_chan_hangup_peer(), ast_autoservice_start(), ast_autoservice_stop(), ast_bridge_call(), ast_bridge_setup_after_goto(), ast_bridge_timelimit(), ast_call(), ast_callerid_parse(), ast_calloc, ast_cause2str(), AST_CAUSE_ANSWERED_ELSEWHERE, AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, ast_cc_busy_interface(), ast_cc_call_failed(), ast_cc_call_init(), ast_cc_callback(), ast_cc_extension_monitor_add_dialstring(), ast_cdr_reset(), ast_channel_adsicpe_set(), ast_channel_appl_set(), ast_channel_caller(), ast_channel_clear_flag(), ast_channel_connected(), ast_channel_connected_line_macro(), ast_channel_connected_line_sub(), ast_channel_context(), ast_channel_context_set(), ast_channel_data_set(), ast_channel_datastore_inherit(), ast_channel_dialed(), ast_channel_early_bridge(), ast_channel_exten(), ast_channel_exten_set(), ast_channel_flags(), ast_channel_get_device_name(), ast_channel_get_stream_topology(), ast_channel_hangupcause(), ast_channel_hangupcause_set(), ast_channel_inherit_variables(), ast_channel_language(), ast_channel_lock, ast_channel_lock_both, ast_channel_macrocontext(), ast_channel_macroexten(), ast_channel_make_compatible(), ast_channel_musicclass(), AST_CHANNEL_NAME, ast_channel_name(), ast_channel_priority(), ast_channel_priority_set(), ast_channel_publish_dial(), ast_channel_redirecting(), ast_channel_req_accountcodes(), AST_CHANNEL_REQUESTOR_BRIDGE_PEER, ast_channel_sched(), ast_channel_sendurl(), ast_channel_set_caller_event(), ast_channel_set_connected_line(), ast_channel_set_flag(), ast_channel_setoption(), ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_stream(), ast_channel_supports_html(), ast_channel_timingfunc(), ast_channel_transfercapability(), ast_channel_transfercapability_set(), ast_channel_unlock, ast_channel_visible_indication_set(), ast_channel_whentohangup(), ast_channel_whentohangup_set(), ast_check_hangup(), ast_check_hangup_locked(), ast_clear_flag, ast_connected_line_copy_from_caller(), AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HANGUP, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, ast_copy_flags64, ast_copy_string(), ast_deactivate_generator(), ast_debug, AST_DECLARE_APP_ARGS, AST_DIGIT_ANY, ast_dtmf_stream(), ast_exists_extension(), AST_FEATURE_AUTOMIXMON, AST_FEATURE_AUTOMON, AST_FEATURE_DISCONNECT, AST_FEATURE_PARKCALL, AST_FEATURE_REDIRECT, ast_filedelete(), ast_fileexists(), AST_FLAG_END_DTMF_ONLY, AST_FLAG_OUTGOING, AST_FRAME_CONTROL, AST_FRAME_DTMF_END, ast_free, ast_frfree, ast_hangup(), ast_ignore_cc(), ast_indicate(), ast_indicate_data(), AST_LIST_EMPTY, AST_LIST_FIRST, AST_LIST_HEAD_NOLOCK_INIT_VALUE, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, AST_MAX_EXTENSION, ast_max_forwards_decrement(), ast_max_forwards_get(), ast_mf_stream(), ast_moh_start(), ast_moh_stop(), AST_OPTION_OPRMODE, ast_parse_caller_presentation(), ast_parseable_goto(), ast_party_caller_set_init(), ast_party_connected_line_copy(), ast_party_connected_line_set_init(), ast_party_id_init(), ast_party_id_set_init(), ast_party_redirecting_copy(), AST_PBX_INCOMPLETE, ast_pbx_start(), ast_pre_call(), AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, AST_PRIVACY_UNKNOWN, ast_read(), ast_replace_subargument_delimiter(), ast_request_with_stream_topology(), ast_rtp_instance_early_bridge_make_compatible(), ast_sched_runq(), ast_sched_wait(), ast_senddigit(), ast_set2_flag64, ast_set_flag, ast_set_flag64, AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_stopstream(), ast_str2cause(), ast_str_tmp, ast_strdup, ast_strdupa, ast_stream_topology_clone(), ast_stream_topology_free(), ast_stream_topology_to_str(), ast_streamfile(), ast_strip(), ast_strlen_zero, ast_test_flag64, ast_trace, ast_tvadd(), ast_tvnow(), ast_tvzero(), ast_verb, ast_waitfor_n(), CAN_EARLY_BRIDGE, chanlist::chan, chanlist_free(), chanlist::connected, ast_frame::data, ast_frame::datalen, DIAL_CALLERID_ABSENT, dial_exec_options, dial_handle_playtones(), DIAL_NOFORWARDHTML, DIAL_STILLGOING, digit, done, ast_bridge_config::end_bridge_callback, end_bridge_callback(), ast_bridge_config::end_bridge_callback_data, ast_bridge_config::end_bridge_callback_data_fixup, end_bridge_callback_data_fixup(), ast_bridge_config::end_sound, ast_bridge_config::features_callee, ast_bridge_config::features_caller, ast_flags64::flags, ast_frame::frametype, get_cid_name(), handle_cause(), hanguptree(), ast_party_caller::id, ast_party_connected_line::id, ast_frame_subclass::integer, chanlist::interface, LOG_ERROR, LOG_NOTICE, LOG_WARNING, oprmode::mode, name, ast_party_id::name, NULL, ast_party_id::number, chanlist::number, OPT_ANNOUNCE, OPT_ARG_ANNOUNCE, OPT_ARG_ARRAY_SIZE, OPT_ARG_CALLEE_GOSUB, OPT_ARG_CALLEE_MACRO, OPT_ARG_DURATION_LIMIT, OPT_ARG_DURATION_STOP, OPT_ARG_FORCE_CID_PRES, OPT_ARG_FORCE_CID_TAG, OPT_ARG_FORCECLID, OPT_ARG_GOTO, OPT_ARG_HANGUPCAUSE, OPT_ARG_MUSICBACK, OPT_ARG_OPERMODE, OPT_ARG_ORIGINAL_CLID, OPT_ARG_PREDIAL_CALLEE, OPT_ARG_PREDIAL_CALLER, OPT_ARG_PRIVACY, OPT_ARG_RINGBACK, OPT_ARG_SCREEN_NOINTRO, OPT_ARG_SENDDTMF, OPT_CALLEE_GOSUB, OPT_CALLEE_HANGUP, OPT_CALLEE_MACRO, OPT_CALLEE_MIXMONITOR, OPT_CALLEE_MONITOR, OPT_CALLEE_PARK, OPT_CALLEE_TRANSFER, OPT_CALLER_ANSWER, OPT_CALLER_HANGUP, OPT_CALLER_MIXMONITOR, OPT_CALLER_MONITOR, OPT_CALLER_PARK, OPT_CALLER_TRANSFER, OPT_CANCEL_ELSEWHERE, OPT_CANCEL_TIMEOUT, OPT_DTMF_EXIT, OPT_DURATION_LIMIT, OPT_DURATION_STOP, OPT_FORCE_CID_PRES, OPT_FORCE_CID_TAG, OPT_FORCECLID, OPT_GO_ON, OPT_GOTO, OPT_HANGUPCAUSE, OPT_IGNORE_CONNECTEDLINE, OPT_IGNORE_FORWARDING, OPT_MUSICBACK, OPT_OPERMODE, OPT_ORIGINAL_CLID, OPT_PREDIAL_CALLEE, OPT_PREDIAL_CALLER, OPT_PRIVACY, OPT_RESETCDR, OPT_RING_WITH_EARLY_MEDIA, OPT_RINGBACK, OPT_SCREEN_NOINTRO, OPT_SCREENING, OPT_SENDDTMF, options, chanlist::orig_chan_name, out, parse(), pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), oprmode::peer, ast_party_number::presentation, privacy_args::privdb_val, privacy_args::privintro, ast_frame::ptr, result, S_COR, S_OR, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, privacy_args::sentringing, setup_peer_after_bridge_goto(), setup_privacy_args(), ast_bridge_config::start_sound, privacy_args::status, ast_party_name::str, ast_party_number::str, ast_party_subaddress::str, strsep(), chanlist::stuff, ast_party_id::subaddress, ast_frame::subclass, ast_party_id::tag, chanlist::tech, timeout, tmp(), ast_party_dialed::transit_network_select, url, ast_party_name::valid, ast_party_number::valid, wait_for_answer(), and ast_bridge_config::warning_sound.

Referenced by dial_exec(), and retrydial_exec().

{
   int res = -1; /* default: error */
   char *rest, *cur; /* scan the list of destinations */
   struct dial_head out_chans = AST_LIST_HEAD_NOLOCK_INIT_VALUE; /* list of destinations */
   struct chanlist *outgoing;
   struct chanlist *tmp;
   struct ast_channel *peer = NULL;
   int to; /* timeout */
   struct cause_args num = { chan, 0, 0, 0 };
   int cause;

   struct ast_bridge_config config = { { 0, } };
   struct timeval calldurationlimit = { 0, };
   char *dtmfcalled = NULL, *dtmfcalling = NULL, *dtmf_progress=NULL;
   char *mfcalled = NULL, *mfcalling = NULL, *mf_progress=NULL;
   struct privacy_args pa = {
      .sentringing = 0,
      .privdb_val = 0,
      .status = "INVALIDARGS",
   };
   int sentringing = 0, moh = 0;
   const char *outbound_group = NULL;
   int result = 0;
   char *parse;
   int opermode = 0;
   int delprivintro = 0;
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(peers);
      AST_APP_ARG(timeout);
      AST_APP_ARG(options);
      AST_APP_ARG(url);
   );
   struct ast_flags64 opts = { 0, };
   char *opt_args[OPT_ARG_ARRAY_SIZE];
   int fulldial = 0, num_dialed = 0;
   int ignore_cc = 0;
   char device_name[AST_CHANNEL_NAME];
   char forced_clid_name[AST_MAX_EXTENSION];
   char stored_clid_name[AST_MAX_EXTENSION];
   int force_forwards_only;   /*!< TRUE if force CallerID on call forward only. Legacy behaviour.*/
   /*!
    * \brief Forced CallerID party information to send.
    * \note This will not have any malloced strings so do not free it.
    */
   struct ast_party_id forced_clid;
   /*!
    * \brief Stored CallerID information if needed.
    *
    * \note If OPT_ORIGINAL_CLID set then this is the o option
    * CallerID.  Otherwise it is the dialplan extension and hint
    * name.
    *
    * \note This will not have any malloced strings so do not free it.
    */
   struct ast_party_id stored_clid;
   /*!
    * \brief CallerID party information to store.
    * \note This will not have any malloced strings so do not free it.
    */
   struct ast_party_caller caller;
   int max_forwards;
   SCOPE_ENTER(1, "%s: Data: %s\n", ast_channel_name(chan), data);

   /* Reset all DIAL variables back to blank, to prevent confusion (in case we don't reset all of them). */
   ast_channel_lock(chan);
   ast_channel_stage_snapshot(chan);
   pbx_builtin_setvar_helper(chan, "DIALSTATUS", "");
   pbx_builtin_setvar_helper(chan, "DIALEDPEERNUMBER", "");
   pbx_builtin_setvar_helper(chan, "DIALEDPEERNAME", "");
   pbx_builtin_setvar_helper(chan, "ANSWEREDTIME", "");
   pbx_builtin_setvar_helper(chan, "ANSWEREDTIME_MS", "");
   pbx_builtin_setvar_helper(chan, "DIALEDTIME", "");
   pbx_builtin_setvar_helper(chan, "DIALEDTIME_MS", "");
   pbx_builtin_setvar_helper(chan, "RINGTIME", "");
   pbx_builtin_setvar_helper(chan, "RINGTIME_MS", "");
   pbx_builtin_setvar_helper(chan, "PROGRESSTIME", "");
   pbx_builtin_setvar_helper(chan, "PROGRESSTIME_MS", "");
   ast_channel_stage_snapshot_done(chan);
   max_forwards = ast_max_forwards_get(chan);
   ast_channel_unlock(chan);

   if (max_forwards <= 0) {
      ast_log(LOG_WARNING, "Cannot place outbound call from channel '%s'. Max forwards exceeded\n",
            ast_channel_name(chan));
      pbx_builtin_setvar_helper(chan, "DIALSTATUS", "BUSY");
      SCOPE_EXIT_RTN_VALUE(-1, "%s: Max forwards exceeded\n", ast_channel_name(chan));
   }

   if (ast_check_hangup_locked(chan)) {
      /*
       * Caller hung up before we could dial.  If dial is executed
       * within an AGI then the AGI has likely eaten all queued
       * frames before executing the dial in DeadAGI mode.  With
       * the caller hung up and no pending frames from the caller's
       * read queue, dial would not know that the call has hung up
       * until a called channel answers.  It is rather annoying to
       * whoever just answered the non-existent call.
       *
       * Dial should not continue execution in DeadAGI mode, hangup
       * handlers, or the h exten.
       */
      ast_verb(3, "Caller hung up before dial.\n");
      pbx_builtin_setvar_helper(chan, "DIALSTATUS", "CANCEL");
      SCOPE_EXIT_RTN_VALUE(-1, "%s: Caller hung up before dial\n", ast_channel_name(chan));
   }

   parse = ast_strdupa(data ?: "");

   AST_STANDARD_APP_ARGS(args, parse);

   if (!ast_strlen_zero(args.options) &&
      ast_app_parse_options64(dial_exec_options, &opts, opt_args, args.options)) {
      pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
      goto done;
   }

   if (ast_cc_call_init(chan, &ignore_cc)) {
      goto done;
   }

   if (ast_test_flag64(&opts, OPT_SCREEN_NOINTRO) && !ast_strlen_zero(opt_args[OPT_ARG_SCREEN_NOINTRO])) {
      delprivintro = atoi(opt_args[OPT_ARG_SCREEN_NOINTRO]);

      if (delprivintro < 0 || delprivintro > 1) {
         ast_log(LOG_WARNING, "Unknown argument %d specified to n option, ignoring\n", delprivintro);
         delprivintro = 0;
      }
   }

   if (!ast_test_flag64(&opts, OPT_RINGBACK)) {
      opt_args[OPT_ARG_RINGBACK] = NULL;
   }

   if (ast_test_flag64(&opts, OPT_OPERMODE)) {
      opermode = ast_strlen_zero(opt_args[OPT_ARG_OPERMODE]) ? 1 : atoi(opt_args[OPT_ARG_OPERMODE]);
      ast_verb(3, "Setting operator services mode to %d.\n", opermode);
   }

   if (ast_test_flag64(&opts, OPT_DURATION_STOP) && !ast_strlen_zero(opt_args[OPT_ARG_DURATION_STOP])) {
      calldurationlimit.tv_sec = atoi(opt_args[OPT_ARG_DURATION_STOP]);
      if (!calldurationlimit.tv_sec) {
         ast_log(LOG_WARNING, "Dial does not accept S(%s)\n", opt_args[OPT_ARG_DURATION_STOP]);
         pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
         goto done;
      }
      ast_verb(3, "Setting call duration limit to %.3lf seconds.\n", calldurationlimit.tv_sec + calldurationlimit.tv_usec / 1000000.0);
   }

   if (ast_test_flag64(&opts, OPT_SENDDTMF) && !ast_strlen_zero(opt_args[OPT_ARG_SENDDTMF])) {
      mf_progress = opt_args[OPT_ARG_SENDDTMF];
      dtmfcalling = strsep(&mf_progress, ":");
      dtmfcalled = strsep(&mf_progress, ":");
      dtmf_progress = strsep(&mf_progress, ":");
      mfcalling = strsep(&mf_progress, ":");
      mfcalled = strsep(&mf_progress, ":");
   }

   if (ast_test_flag64(&opts, OPT_DURATION_LIMIT) && !ast_strlen_zero(opt_args[OPT_ARG_DURATION_LIMIT])) {
      if (ast_bridge_timelimit(chan, &config, opt_args[OPT_ARG_DURATION_LIMIT], &calldurationlimit))
         goto done;
   }

   /* Setup the forced CallerID information to send if used. */
   ast_party_id_init(&forced_clid);
   force_forwards_only = 0;
   if (ast_test_flag64(&opts, OPT_FORCECLID)) {
      if (ast_strlen_zero(opt_args[OPT_ARG_FORCECLID])) {
         ast_channel_lock(chan);
         forced_clid.number.str = ast_strdupa(S_OR(ast_channel_macroexten(chan), ast_channel_exten(chan)));
         ast_channel_unlock(chan);
         forced_clid_name[0] = '\0';
         forced_clid.name.str = (char *) get_cid_name(forced_clid_name,
            sizeof(forced_clid_name), chan);
         force_forwards_only = 1;
      } else {
         /* Note: The opt_args[OPT_ARG_FORCECLID] string value is altered here. */
         ast_callerid_parse(opt_args[OPT_ARG_FORCECLID], &forced_clid.name.str,
            &forced_clid.number.str);
      }
      if (!ast_strlen_zero(forced_clid.name.str)) {
         forced_clid.name.valid = 1;
      }
      if (!ast_strlen_zero(forced_clid.number.str)) {
         forced_clid.number.valid = 1;
      }
   }
   if (ast_test_flag64(&opts, OPT_FORCE_CID_TAG)
      && !ast_strlen_zero(opt_args[OPT_ARG_FORCE_CID_TAG])) {
      forced_clid.tag = opt_args[OPT_ARG_FORCE_CID_TAG];
   }
   forced_clid.number.presentation = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
   if (ast_test_flag64(&opts, OPT_FORCE_CID_PRES)
      && !ast_strlen_zero(opt_args[OPT_ARG_FORCE_CID_PRES])) {
      int pres;

      pres = ast_parse_caller_presentation(opt_args[OPT_ARG_FORCE_CID_PRES]);
      if (0 <= pres) {
         forced_clid.number.presentation = pres;
      }
   }

   /* Setup the stored CallerID information if needed. */
   ast_party_id_init(&stored_clid);
   if (ast_test_flag64(&opts, OPT_ORIGINAL_CLID)) {
      if (ast_strlen_zero(opt_args[OPT_ARG_ORIGINAL_CLID])) {
         ast_channel_lock(chan);
         ast_party_id_set_init(&stored_clid, &ast_channel_caller(chan)->id);
         if (!ast_strlen_zero(ast_channel_caller(chan)->id.name.str)) {
            stored_clid.name.str = ast_strdupa(ast_channel_caller(chan)->id.name.str);
         }
         if (!ast_strlen_zero(ast_channel_caller(chan)->id.number.str)) {
            stored_clid.number.str = ast_strdupa(ast_channel_caller(chan)->id.number.str);
         }
         if (!ast_strlen_zero(ast_channel_caller(chan)->id.subaddress.str)) {
            stored_clid.subaddress.str = ast_strdupa(ast_channel_caller(chan)->id.subaddress.str);
         }
         if (!ast_strlen_zero(ast_channel_caller(chan)->id.tag)) {
            stored_clid.tag = ast_strdupa(ast_channel_caller(chan)->id.tag);
         }
         ast_channel_unlock(chan);
      } else {
         /* Note: The opt_args[OPT_ARG_ORIGINAL_CLID] string value is altered here. */
         ast_callerid_parse(opt_args[OPT_ARG_ORIGINAL_CLID], &stored_clid.name.str,
            &stored_clid.number.str);
         if (!ast_strlen_zero(stored_clid.name.str)) {
            stored_clid.name.valid = 1;
         }
         if (!ast_strlen_zero(stored_clid.number.str)) {
            stored_clid.number.valid = 1;
         }
      }
   } else {
      /*
       * In case the new channel has no preset CallerID number by the
       * channel driver, setup the dialplan extension and hint name.
       */
      stored_clid_name[0] = '\0';
      stored_clid.name.str = (char *) get_cid_name(stored_clid_name,
         sizeof(stored_clid_name), chan);
      if (ast_strlen_zero(stored_clid.name.str)) {
         stored_clid.name.str = NULL;
      } else {
         stored_clid.name.valid = 1;
      }
      ast_channel_lock(chan);
      stored_clid.number.str = ast_strdupa(S_OR(ast_channel_macroexten(chan), ast_channel_exten(chan)));
      stored_clid.number.valid = 1;
      ast_channel_unlock(chan);
   }

   if (ast_test_flag64(&opts, OPT_RESETCDR)) {
      ast_cdr_reset(ast_channel_name(chan), 0);
   }
   if (ast_test_flag64(&opts, OPT_PRIVACY) && ast_strlen_zero(opt_args[OPT_ARG_PRIVACY]))
      opt_args[OPT_ARG_PRIVACY] = ast_strdupa(ast_channel_exten(chan));

   if (ast_test_flag64(&opts, OPT_PRIVACY) || ast_test_flag64(&opts, OPT_SCREENING)) {
      res = setup_privacy_args(&pa, &opts, opt_args, chan);
      if (res <= 0)
         goto out;
      res = -1; /* reset default */
   }

   if (continue_exec)
      *continue_exec = 0;

   /* If a channel group has been specified, get it for use when we create peer channels */

   ast_channel_lock(chan);
   if ((outbound_group = pbx_builtin_getvar_helper(chan, "OUTBOUND_GROUP_ONCE"))) {
      outbound_group = ast_strdupa(outbound_group);
      pbx_builtin_setvar_helper(chan, "OUTBOUND_GROUP_ONCE", NULL);
   } else if ((outbound_group = pbx_builtin_getvar_helper(chan, "OUTBOUND_GROUP"))) {
      outbound_group = ast_strdupa(outbound_group);
   }
   ast_channel_unlock(chan);

   /* Set per dial instance flags.  These flags are also passed back to RetryDial. */
   ast_copy_flags64(peerflags, &opts, OPT_DTMF_EXIT | OPT_GO_ON | OPT_ORIGINAL_CLID
      | OPT_CALLER_HANGUP | OPT_IGNORE_FORWARDING | OPT_CANCEL_TIMEOUT
      | OPT_ANNOUNCE | OPT_CALLEE_MACRO | OPT_CALLEE_GOSUB | OPT_FORCECLID);

   /* PREDIAL: Run gosub on the caller's channel */
   if (ast_test_flag64(&opts, OPT_PREDIAL_CALLER)
      && !ast_strlen_zero(opt_args[OPT_ARG_PREDIAL_CALLER])) {
      ast_replace_subargument_delimiter(opt_args[OPT_ARG_PREDIAL_CALLER]);
      ast_app_exec_sub(NULL, chan, opt_args[OPT_ARG_PREDIAL_CALLER], 0);
   }

   /* loop through the list of dial destinations */
   rest = args.peers;
   while ((cur = strsep(&rest, "&"))) {
      struct ast_channel *tc; /* channel for this destination */
      char *number;
      char *tech;
      size_t tech_len;
      size_t number_len;
      struct ast_stream_topology *topology;

      cur = ast_strip(cur);
      if (ast_strlen_zero(cur)) {
         /* No tech/resource in this position. */
         continue;
      }

      /* Get a technology/resource pair */
      number = cur;
      tech = strsep(&number, "/");

      num_dialed++;
      if (ast_strlen_zero(number)) {
         ast_log(LOG_WARNING, "Dial argument takes format (technology/resource)\n");
         goto out;
      }

      tech_len = strlen(tech) + 1;
      number_len = strlen(number) + 1;
      tmp = ast_calloc(1, sizeof(*tmp) + (2 * tech_len) + number_len);
      if (!tmp) {
         goto out;
      }

      /* Save tech, number, and interface. */
      cur = tmp->stuff;
      strcpy(cur, tech);
      tmp->tech = cur;
      cur += tech_len;
      strcpy(cur, tech);
      cur[tech_len - 1] = '/';
      tmp->interface = cur;
      cur += tech_len;
      strcpy(cur, number);
      tmp->number = cur;

      if (opts.flags) {
         /* Set per outgoing call leg options. */
         ast_copy_flags64(tmp, &opts,
            OPT_CANCEL_ELSEWHERE |
            OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
            OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
            OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
            OPT_CALLEE_PARK | OPT_CALLER_PARK |
            OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
            OPT_RINGBACK | OPT_MUSICBACK | OPT_FORCECLID | OPT_IGNORE_CONNECTEDLINE |
            OPT_RING_WITH_EARLY_MEDIA);
         ast_set2_flag64(tmp, args.url, DIAL_NOFORWARDHTML);
      }

      /* Request the peer */

      ast_channel_lock(chan);
      /*
       * Seed the chanlist's connected line information with previously
       * acquired connected line info from the incoming channel.  The
       * previously acquired connected line info could have been set
       * through the CONNECTED_LINE dialplan function.
       */
      ast_party_connected_line_copy(&tmp->connected, ast_channel_connected(chan));

      topology = ast_stream_topology_clone(ast_channel_get_stream_topology(chan));

      ast_channel_unlock(chan);

      tc = ast_request_with_stream_topology(tmp->tech, topology, NULL, chan, tmp->number, &cause);

      ast_stream_topology_free(topology);

      if (!tc) {
         /* If we can't, just go on to the next call */
         ast_log(LOG_WARNING, "Unable to create channel of type '%s' (cause %d - %s)\n",
            tmp->tech, cause, ast_cause2str(cause));
         handle_cause(cause, &num);
         if (!rest) {
            /* we are on the last destination */
            ast_channel_hangupcause_set(chan, cause);
         }
         if (!ignore_cc && (cause == AST_CAUSE_BUSY || cause == AST_CAUSE_CONGESTION)) {
            if (!ast_cc_callback(chan, tmp->tech, tmp->number, ast_cc_busy_interface)) {
               ast_cc_extension_monitor_add_dialstring(chan, tmp->interface, "");
            }
         }
         chanlist_free(tmp);
         continue;
      }

      ast_channel_get_device_name(tc, device_name, sizeof(device_name));
      if (!ignore_cc) {
         ast_cc_extension_monitor_add_dialstring(chan, tmp->interface, device_name);
      }

      ast_channel_lock_both(tc, chan);
      ast_channel_stage_snapshot(tc);

      pbx_builtin_setvar_helper(tc, "DIALEDPEERNUMBER", tmp->number);

      /* Setup outgoing SDP to match incoming one */
      if (!AST_LIST_FIRST(&out_chans) && !rest && CAN_EARLY_BRIDGE(peerflags, chan, tc)) {
         /* We are on the only destination. */
         ast_rtp_instance_early_bridge_make_compatible(tc, chan);
      }

      /* Inherit specially named variables from parent channel */
      ast_channel_inherit_variables(chan, tc);
      ast_channel_datastore_inherit(chan, tc);
      ast_max_forwards_decrement(tc);

      ast_channel_appl_set(tc, "AppDial");
      ast_channel_data_set(tc, "(Outgoing Line)");

      memset(ast_channel_whentohangup(tc), 0, sizeof(*ast_channel_whentohangup(tc)));

      /* Determine CallerID to store in outgoing channel. */
      ast_party_caller_set_init(&caller, ast_channel_caller(tc));
      if (ast_test_flag64(peerflags, OPT_ORIGINAL_CLID)) {
         caller.id = stored_clid;
         ast_channel_set_caller_event(tc, &caller, NULL);
         ast_set_flag64(tmp, DIAL_CALLERID_ABSENT);
      } else if (ast_strlen_zero(S_COR(ast_channel_caller(tc)->id.number.valid,
         ast_channel_caller(tc)->id.number.str, NULL))) {
         /*
          * The new channel has no preset CallerID number by the channel
          * driver.  Use the dialplan extension and hint name.
          */
         caller.id = stored_clid;
         if (!caller.id.name.valid
            && !ast_strlen_zero(S_COR(ast_channel_connected(chan)->id.name.valid,
               ast_channel_connected(chan)->id.name.str, NULL))) {
            /*
             * No hint name available.  We have a connected name supplied by
             * the dialplan we can use instead.
             */
            caller.id.name.valid = 1;
            caller.id.name = ast_channel_connected(chan)->id.name;
         }
         ast_channel_set_caller_event(tc, &caller, NULL);
         ast_set_flag64(tmp, DIAL_CALLERID_ABSENT);
      } else if (ast_strlen_zero(S_COR(ast_channel_caller(tc)->id.name.valid, ast_channel_caller(tc)->id.name.str,
         NULL))) {
         /* The new channel has no preset CallerID name by the channel driver. */
         if (!ast_strlen_zero(S_COR(ast_channel_connected(chan)->id.name.valid,
            ast_channel_connected(chan)->id.name.str, NULL))) {
            /*
             * We have a connected name supplied by the dialplan we can
             * use instead.
             */
            caller.id.name.valid = 1;
            caller.id.name = ast_channel_connected(chan)->id.name;
            ast_channel_set_caller_event(tc, &caller, NULL);
         }
      }

      /* Determine CallerID for outgoing channel to send. */
      if (ast_test_flag64(peerflags, OPT_FORCECLID) && !force_forwards_only) {
         struct ast_party_connected_line connected;

         ast_party_connected_line_set_init(&connected, ast_channel_connected(tc));
         connected.id = forced_clid;
         ast_channel_set_connected_line(tc, &connected, NULL);
      } else {
         ast_connected_line_copy_from_caller(ast_channel_connected(tc), ast_channel_caller(chan));
      }

      ast_party_redirecting_copy(ast_channel_redirecting(tc), ast_channel_redirecting(chan));

      ast_channel_dialed(tc)->transit_network_select = ast_channel_dialed(chan)->transit_network_select;

      ast_channel_req_accountcodes(tc, chan, AST_CHANNEL_REQUESTOR_BRIDGE_PEER);
      if (ast_strlen_zero(ast_channel_musicclass(tc))) {
         ast_channel_musicclass_set(tc, ast_channel_musicclass(chan));
      }

      /* Pass ADSI CPE and transfer capability */
      ast_channel_adsicpe_set(tc, ast_channel_adsicpe(chan));
      ast_channel_transfercapability_set(tc, ast_channel_transfercapability(chan));

      /* If we have an outbound group, set this peer channel to it */
      if (outbound_group)
         ast_app_group_set_channel(tc, outbound_group);
      /* If the calling channel has the ANSWERED_ELSEWHERE flag set, inherit it. This is to support local channels */
      if (ast_channel_hangupcause(chan) == AST_CAUSE_ANSWERED_ELSEWHERE)
         ast_channel_hangupcause_set(tc, AST_CAUSE_ANSWERED_ELSEWHERE);

      /* Check if we're forced by configuration */
      if (ast_test_flag64(&opts, OPT_CANCEL_ELSEWHERE))
          ast_channel_hangupcause_set(tc, AST_CAUSE_ANSWERED_ELSEWHERE);


      /* Inherit context and extension */
      ast_channel_dialcontext_set(tc, ast_strlen_zero(ast_channel_macrocontext(chan)) ? ast_channel_context(chan) : ast_channel_macrocontext(chan));
      if (!ast_strlen_zero(ast_channel_macroexten(chan)))
         ast_channel_exten_set(tc, ast_channel_macroexten(chan));
      else
         ast_channel_exten_set(tc, ast_channel_exten(chan));

      ast_channel_stage_snapshot_done(tc);

      /* Save the original channel name to detect call pickup masquerading in. */
      tmp->orig_chan_name = ast_strdup(ast_channel_name(tc));

      ast_channel_unlock(tc);
      ast_channel_unlock(chan);

      /* Put channel in the list of outgoing thingies. */
      tmp->chan = tc;
      AST_LIST_INSERT_TAIL(&out_chans, tmp, node);
   }

   if (AST_LIST_EMPTY(&out_chans)) {
      ast_verb(3, "No devices or endpoints to dial (technology/resource)\n");
      if (continue_exec) {
         /* There is no point in having RetryDial try again */
         *continue_exec = 1;
      }
      strcpy(pa.status, "CHANUNAVAIL");
      res = 0;
      goto out;
   }

   /*
    * PREDIAL: Run gosub on all of the callee channels
    *
    * We run the callee predial before ast_call() in case the user
    * wishes to do something on the newly created channels before
    * the channel does anything important.
    *
    * Inside the target gosub we will be able to do something with
    * the newly created channel name ie: now the calling channel
    * can know what channel will be used to call the destination
    * ex: now we will know that SIP/abc-123 is calling SIP/def-124
    */
   if (ast_test_flag64(&opts, OPT_PREDIAL_CALLEE)
      && !ast_strlen_zero(opt_args[OPT_ARG_PREDIAL_CALLEE])
      && !AST_LIST_EMPTY(&out_chans)) {
      const char *predial_callee;

      ast_replace_subargument_delimiter(opt_args[OPT_ARG_PREDIAL_CALLEE]);
      predial_callee = ast_app_expand_sub_args(chan, opt_args[OPT_ARG_PREDIAL_CALLEE]);
      if (predial_callee) {
         ast_autoservice_start(chan);
         AST_LIST_TRAVERSE(&out_chans, tmp, node) {
            ast_pre_call(tmp->chan, predial_callee);
         }
         ast_autoservice_stop(chan);
         ast_free((char *) predial_callee);
      }
   }

   /* Start all outgoing calls */
   AST_LIST_TRAVERSE_SAFE_BEGIN(&out_chans, tmp, node) {
      res = ast_call(tmp->chan, tmp->number, 0); /* Place the call, but don't wait on the answer */
      ast_channel_lock(chan);

      /* check the results of ast_call */
      if (res) {
         /* Again, keep going even if there's an error */
         ast_debug(1, "ast call on peer returned %d\n", res);
         ast_verb(3, "Couldn't call %s\n", tmp->interface);
         if (ast_channel_hangupcause(tmp->chan)) {
            ast_channel_hangupcause_set(chan, ast_channel_hangupcause(tmp->chan));
         }
         ast_channel_unlock(chan);
         ast_cc_call_failed(chan, tmp->chan, tmp->interface);
         ast_hangup(tmp->chan);
         tmp->chan = NULL;
         AST_LIST_REMOVE_CURRENT(node);
         chanlist_free(tmp);
         continue;
      }

      ast_channel_publish_dial(chan, tmp->chan, tmp->number, NULL);
      ast_channel_unlock(chan);

      ast_verb(3, "Called %s\n", tmp->interface);
      ast_set_flag64(tmp, DIAL_STILLGOING);

      /* If this line is up, don't try anybody else */
      if (ast_channel_state(tmp->chan) == AST_STATE_UP) {
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;

   if (ast_strlen_zero(args.timeout)) {
      to = -1;
   } else {
      to = atoi(args.timeout);
      if (to > 0)
         to *= 1000;
      else {
         ast_log(LOG_WARNING, "Invalid timeout specified: '%s'. Setting timeout to infinite\n", args.timeout);
         to = -1;
      }
   }

   outgoing = AST_LIST_FIRST(&out_chans);
   if (!outgoing) {
      strcpy(pa.status, "CHANUNAVAIL");
      if (fulldial == num_dialed) {
         res = -1;
         goto out;
      }
   } else {
      /* Our status will at least be NOANSWER */
      strcpy(pa.status, "NOANSWER");
      if (ast_test_flag64(outgoing, OPT_MUSICBACK)) {
         moh = 1;
         if (!ast_strlen_zero(opt_args[OPT_ARG_MUSICBACK])) {
            char *original_moh = ast_strdupa(ast_channel_musicclass(chan));
            ast_channel_musicclass_set(chan, opt_args[OPT_ARG_MUSICBACK]);
            ast_moh_start(chan, opt_args[OPT_ARG_MUSICBACK], NULL);
            ast_channel_musicclass_set(chan, original_moh);
         } else {
            ast_moh_start(chan, NULL, NULL);
         }
         ast_indicate(chan, AST_CONTROL_PROGRESS);
      } else if (ast_test_flag64(outgoing, OPT_RINGBACK) || ast_test_flag64(outgoing, OPT_RING_WITH_EARLY_MEDIA)) {
         if (!ast_strlen_zero(opt_args[OPT_ARG_RINGBACK])) {
            if (dial_handle_playtones(chan, opt_args[OPT_ARG_RINGBACK])){
               ast_indicate(chan, AST_CONTROL_RINGING);
               sentringing++;
            } else {
               ast_indicate(chan, AST_CONTROL_PROGRESS);
            }
         } else {
            ast_indicate(chan, AST_CONTROL_RINGING);
            sentringing++;
         }
      }
   }

   peer = wait_for_answer(chan, &out_chans, &to, peerflags, opt_args, &pa, &num, &result,
      dtmf_progress, mf_progress, ignore_cc, &forced_clid, &stored_clid, &config);

   if (!peer) {
      if (result) {
         res = result;
      } else if (to) { /* Musta gotten hung up */
         res = -1;
      } else { /* Nobody answered, next please? */
         res = 0;
      }
   } else {
      const char *number;
      const char *name;
      int dial_end_raised = 0;
      int cause = -1;

      if (ast_test_flag64(&opts, OPT_CALLER_ANSWER)) {
         ast_answer(chan);
      }

      /* Ah ha!  Someone answered within the desired timeframe.  Of course after this
         we will always return with -1 so that it is hung up properly after the
         conversation.  */

      if (ast_test_flag64(&opts, OPT_HANGUPCAUSE)
         && !ast_strlen_zero(opt_args[OPT_ARG_HANGUPCAUSE])) {
         cause = ast_str2cause(opt_args[OPT_ARG_HANGUPCAUSE]);
         if (cause <= 0) {
            if (!strcasecmp(opt_args[OPT_ARG_HANGUPCAUSE], "NONE")) {
               cause = 0;
            } else if (sscanf(opt_args[OPT_ARG_HANGUPCAUSE], "%30d", &cause) != 1
               || cause < 0) {
               ast_log(LOG_WARNING, "Invalid cause given to Dial(...Q(<cause>)): \"%s\"\n",
                  opt_args[OPT_ARG_HANGUPCAUSE]);
               cause = -1;
            }
         }
      }
      hanguptree(&out_chans, peer, cause >= 0 ? cause : AST_CAUSE_ANSWERED_ELSEWHERE);

      /* If appropriate, log that we have a destination channel and set the answer time */

      ast_channel_lock(peer);
      name = ast_strdupa(ast_channel_name(peer));

      number = pbx_builtin_getvar_helper(peer, "DIALEDPEERNUMBER");
      if (ast_strlen_zero(number)) {
         number = NULL;
      } else {
         number = ast_strdupa(number);
      }
      ast_channel_unlock(peer);

      ast_channel_lock(chan);
      ast_channel_stage_snapshot(chan);

      strcpy(pa.status, "ANSWER");
      pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);

      pbx_builtin_setvar_helper(chan, "DIALEDPEERNAME", name);
      pbx_builtin_setvar_helper(chan, "DIALEDPEERNUMBER", number);

      ast_channel_stage_snapshot_done(chan);
      ast_channel_unlock(chan);

      if (!ast_strlen_zero(args.url) && ast_channel_supports_html(peer) ) {
         ast_debug(1, "app_dial: sendurl=%s.\n", args.url);
         ast_channel_sendurl( peer, args.url );
      }
      if ( (ast_test_flag64(&opts, OPT_PRIVACY) || ast_test_flag64(&opts, OPT_SCREENING)) && pa.privdb_val == AST_PRIVACY_UNKNOWN) {
         if (do_privacy(chan, peer, &opts, opt_args, &pa)) {
            ast_channel_publish_dial(chan, peer, NULL, pa.status);
            /* hang up on the callee -- he didn't want to talk anyway! */
            ast_autoservice_chan_hangup_peer(chan, peer);
            res = 0;
            goto out;
         }
      }
      if (!ast_test_flag64(&opts, OPT_ANNOUNCE) || ast_strlen_zero(opt_args[OPT_ARG_ANNOUNCE])) {
         res = 0;
      } else {
         int digit = 0;
         struct ast_channel *chans[2];
         struct ast_channel *active_chan;
         char *calledfile = NULL, *callerfile = NULL;
         int calledstream = 0, callerstream = 0;

         chans[0] = chan;
         chans[1] = peer;

         /* we need to stream the announcement(s) when the OPT_ARG_ANNOUNCE (-A) is set */
         callerfile = opt_args[OPT_ARG_ANNOUNCE];
         calledfile = strsep(&callerfile, ":");

         /* stream the file(s) */
         if (!ast_strlen_zero(calledfile)) {
            res = ast_streamfile(peer, calledfile, ast_channel_language(peer));
            if (res) {
               res = 0;
               ast_log(LOG_ERROR, "error streaming file '%s' to callee\n", calledfile);
            } else {
               calledstream = 1;
            }
         }
         if (!ast_strlen_zero(callerfile)) {
            res = ast_streamfile(chan, callerfile, ast_channel_language(chan));
            if (res) {
               res = 0;
               ast_log(LOG_ERROR, "error streaming file '%s' to caller\n", callerfile);
            } else {
               callerstream = 1;
            }
         }

         /* can't use ast_waitstream, because we're streaming two files at once, and can't block
            We'll need to handle both channels at once. */

         ast_channel_set_flag(peer, AST_FLAG_END_DTMF_ONLY);
         while (ast_channel_stream(peer) || ast_channel_stream(chan)) {
            int mspeer, mschan;

            mspeer = ast_sched_wait(ast_channel_sched(peer));
            mschan = ast_sched_wait(ast_channel_sched(chan));

            if (calledstream) {
               if (mspeer < 0 && !ast_channel_timingfunc(peer)) {
                  ast_stopstream(peer);
                  calledstream = 0;
               }
            }
            if (callerstream) {
               if (mschan < 0 && !ast_channel_timingfunc(chan)) {
                  ast_stopstream(chan);
                  callerstream = 0;
               }
            }

            if (!calledstream && !callerstream) {
               break;
            }

            if (mspeer < 0)
               mspeer = 1000;

            if (mschan < 0)
               mschan = 1000;

            /* wait for the lowest maximum of the two */
            active_chan = ast_waitfor_n(chans, 2, (mspeer > mschan ? &mschan : &mspeer));
            if (active_chan) {
               struct ast_channel *other_chan;
               struct ast_frame *fr = ast_read(active_chan);

               if (!fr) {
                  ast_autoservice_chan_hangup_peer(chan, peer);
                  res = -1;
                  goto done;
               }
               switch (fr->frametype) {
               case AST_FRAME_DTMF_END:
                  digit = fr->subclass.integer;
                  if (active_chan == peer && strchr(AST_DIGIT_ANY, res)) {
                     ast_stopstream(peer);
                     res = ast_senddigit(chan, digit, 0);
                  }
                  break;
               case AST_FRAME_CONTROL:
                  switch (fr->subclass.integer) {
                  case AST_CONTROL_HANGUP:
                     ast_frfree(fr);
                     ast_autoservice_chan_hangup_peer(chan, peer);
                     res = -1;
                     goto done;
                  case AST_CONTROL_CONNECTED_LINE:
                     /* Pass COLP update to the other channel. */
                     if (active_chan == chan) {
                        other_chan = peer;
                     } else {
                        other_chan = chan;
                     }
                     if (ast_channel_connected_line_sub(active_chan, other_chan, fr, 1)
                        && ast_channel_connected_line_macro(active_chan,
                           other_chan, fr, other_chan == chan, 1)) {
                        ast_indicate_data(other_chan, fr->subclass.integer,
                           fr->data.ptr, fr->datalen);
                     }
                     break;
                  default:
                     break;
                  }
                  break;
               default:
                  /* Ignore all others */
                  break;
               }
               ast_frfree(fr);
            }
            ast_sched_runq(ast_channel_sched(peer));
            ast_sched_runq(ast_channel_sched(chan));
         }
         ast_channel_clear_flag(peer, AST_FLAG_END_DTMF_ONLY);
      }

      if (chan && peer && ast_test_flag64(&opts, OPT_GOTO) && !ast_strlen_zero(opt_args[OPT_ARG_GOTO])) {
         /* chan and peer are going into the PBX; as such neither are considered
          * outgoing channels any longer */
         ast_channel_clear_flag(chan, AST_FLAG_OUTGOING);

         ast_replace_subargument_delimiter(opt_args[OPT_ARG_GOTO]);
         ast_parseable_goto(chan, opt_args[OPT_ARG_GOTO]);
         /* peer goes to the same context and extension as chan, so just copy info from chan*/
         ast_channel_lock(peer);
         ast_channel_stage_snapshot(peer);
         ast_clear_flag(ast_channel_flags(peer), AST_FLAG_OUTGOING);
         ast_channel_context_set(peer, ast_channel_context(chan));
         ast_channel_exten_set(peer, ast_channel_exten(chan));
         ast_channel_priority_set(peer, ast_channel_priority(chan) + 2);
         ast_channel_stage_snapshot_done(peer);
         ast_channel_unlock(peer);
         if (ast_pbx_start(peer)) {
            ast_autoservice_chan_hangup_peer(chan, peer);
         }
         if (continue_exec)
            *continue_exec = 1;
         res = 0;
         ast_channel_publish_dial(chan, peer, NULL, "ANSWER");
         goto done;
      }

      if (ast_test_flag64(&opts, OPT_CALLEE_MACRO) && !ast_strlen_zero(opt_args[OPT_ARG_CALLEE_MACRO])) {
         const char *macro_result_peer;
         int macro_res;

         /* Set peer->exten and peer->context so that MACRO_EXTEN and MACRO_CONTEXT get set */
         ast_channel_lock_both(chan, peer);
         ast_channel_context_set(peer, ast_channel_context(chan));
         ast_channel_exten_set(peer, ast_channel_exten(chan));
         ast_channel_unlock(peer);
         ast_channel_unlock(chan);
         ast_replace_subargument_delimiter(opt_args[OPT_ARG_CALLEE_MACRO]);
         macro_res = ast_app_exec_macro(chan, peer, opt_args[OPT_ARG_CALLEE_MACRO]);

         ast_channel_lock(peer);

         if (!macro_res && (macro_result_peer = pbx_builtin_getvar_helper(peer, "MACRO_RESULT"))) {
            char *macro_result = ast_strdupa(macro_result_peer);
            char *macro_transfer_dest;

            ast_channel_unlock(peer);

            if (!strcasecmp(macro_result, "BUSY")) {
               ast_copy_string(pa.status, macro_result, sizeof(pa.status));
               ast_set_flag64(peerflags, OPT_GO_ON);
               macro_res = -1;
            } else if (!strcasecmp(macro_result, "CONGESTION") || !strcasecmp(macro_result, "CHANUNAVAIL")) {
               ast_copy_string(pa.status, macro_result, sizeof(pa.status));
               ast_set_flag64(peerflags, OPT_GO_ON);
               macro_res = -1;
            } else if (!strcasecmp(macro_result, "CONTINUE")) {
               /* hangup peer and keep chan alive assuming the macro has changed
                  the context / exten / priority or perhaps
                  the next priority in the current exten is desired.
               */
               ast_set_flag64(peerflags, OPT_GO_ON);
               macro_res = -1;
            } else if (!strcasecmp(macro_result, "ABORT")) {
               /* Hangup both ends unless the caller has the g flag */
               macro_res = -1;
            } else if (!strncasecmp(macro_result, "GOTO:", 5)) {
               macro_transfer_dest = macro_result + 5;
               macro_res = -1;
               /* perform a transfer to a new extension */
               if (strchr(macro_transfer_dest, '^')) { /* context^exten^priority*/
                  ast_replace_subargument_delimiter(macro_transfer_dest);
               }
               if (!ast_parseable_goto(chan, macro_transfer_dest)) {
                  ast_set_flag64(peerflags, OPT_GO_ON);
               }
            }
            if (macro_res && !dial_end_raised) {
               ast_channel_publish_dial(chan, peer, NULL, macro_result);
               dial_end_raised = 1;
            }
         } else {
            ast_channel_unlock(peer);
         }
         res = macro_res;
      }

      if (ast_test_flag64(&opts, OPT_CALLEE_GOSUB) && !ast_strlen_zero(opt_args[OPT_ARG_CALLEE_GOSUB])) {
         const char *gosub_result_peer;
         char *gosub_argstart;
         char *gosub_args = NULL;
         int gosub_res = -1;

         ast_replace_subargument_delimiter(opt_args[OPT_ARG_CALLEE_GOSUB]);
         gosub_argstart = strchr(opt_args[OPT_ARG_CALLEE_GOSUB], ',');
         if (gosub_argstart) {
            const char *what_is_s = "s";
            *gosub_argstart = 0;
            if (!ast_exists_extension(peer, opt_args[OPT_ARG_CALLEE_GOSUB], "s", 1, S_COR(ast_channel_caller(peer)->id.number.valid, ast_channel_caller(peer)->id.number.str, NULL)) &&
                ast_exists_extension(peer, opt_args[OPT_ARG_CALLEE_GOSUB], "~~s~~", 1, S_COR(ast_channel_caller(peer)->id.number.valid, ast_channel_caller(peer)->id.number.str, NULL))) {
               what_is_s = "~~s~~";
            }
            if (ast_asprintf(&gosub_args, "%s,%s,1(%s)", opt_args[OPT_ARG_CALLEE_GOSUB], what_is_s, gosub_argstart + 1) < 0) {
               gosub_args = NULL;
            }
            *gosub_argstart = ',';
         } else {
            const char *what_is_s = "s";
            if (!ast_exists_extension(peer, opt_args[OPT_ARG_CALLEE_GOSUB], "s", 1, S_COR(ast_channel_caller(peer)->id.number.valid, ast_channel_caller(peer)->id.number.str, NULL)) &&
                ast_exists_extension(peer, opt_args[OPT_ARG_CALLEE_GOSUB], "~~s~~", 1, S_COR(ast_channel_caller(peer)->id.number.valid, ast_channel_caller(peer)->id.number.str, NULL))) {
               what_is_s = "~~s~~";
            }
            if (ast_asprintf(&gosub_args, "%s,%s,1", opt_args[OPT_ARG_CALLEE_GOSUB], what_is_s) < 0) {
               gosub_args = NULL;
            }
         }
         if (gosub_args) {
            gosub_res = ast_app_exec_sub(chan, peer, gosub_args, 0);
            ast_free(gosub_args);
         } else {
            ast_log(LOG_ERROR, "Could not Allocate string for Gosub arguments -- Gosub Call Aborted!\n");
         }

         ast_channel_lock_both(chan, peer);

         if (!gosub_res && (gosub_result_peer = pbx_builtin_getvar_helper(peer, "GOSUB_RESULT"))) {
            char *gosub_transfer_dest;
            char *gosub_result = ast_strdupa(gosub_result_peer);
            const char *gosub_retval = pbx_builtin_getvar_helper(peer, "GOSUB_RETVAL");

            /* Inherit return value from the peer, so it can be used in the master */
            if (gosub_retval) {
               pbx_builtin_setvar_helper(chan, "GOSUB_RETVAL", gosub_retval);
            }

            ast_channel_unlock(peer);
            ast_channel_unlock(chan);

            if (!strcasecmp(gosub_result, "BUSY")) {
               ast_copy_string(pa.status, gosub_result, sizeof(pa.status));
               ast_set_flag64(peerflags, OPT_GO_ON);
               gosub_res = -1;
            } else if (!strcasecmp(gosub_result, "CONGESTION") || !strcasecmp(gosub_result, "CHANUNAVAIL")) {
               ast_copy_string(pa.status, gosub_result, sizeof(pa.status));
               ast_set_flag64(peerflags, OPT_GO_ON);
               gosub_res = -1;
            } else if (!strcasecmp(gosub_result, "CONTINUE")) {
               /* Hangup peer and continue with the next extension priority. */
               ast_set_flag64(peerflags, OPT_GO_ON);
               gosub_res = -1;
            } else if (!strcasecmp(gosub_result, "ABORT")) {
               /* Hangup both ends unless the caller has the g flag */
               gosub_res = -1;
            } else if (!strncasecmp(gosub_result, "GOTO:", 5)) {
               gosub_transfer_dest = gosub_result + 5;
               gosub_res = -1;
               /* perform a transfer to a new extension */
               if (strchr(gosub_transfer_dest, '^')) { /* context^exten^priority*/
                  ast_replace_subargument_delimiter(gosub_transfer_dest);
               }
               if (!ast_parseable_goto(chan, gosub_transfer_dest)) {
                  ast_set_flag64(peerflags, OPT_GO_ON);
               }
            }
            if (gosub_res) {
               res = gosub_res;
               if (!dial_end_raised) {
                  ast_channel_publish_dial(chan, peer, NULL, gosub_result);
                  dial_end_raised = 1;
               }
            }
         } else {
            ast_channel_unlock(peer);
            ast_channel_unlock(chan);
         }
      }

      if (!res) {

         /* None of the Dial options changed our status; inform
          * everyone that this channel answered
          */
         if (!dial_end_raised) {
            ast_channel_publish_dial(chan, peer, NULL, "ANSWER");
            dial_end_raised = 1;
         }

         if (!ast_tvzero(calldurationlimit)) {
            struct timeval whentohangup = ast_tvadd(ast_tvnow(), calldurationlimit);
            ast_channel_lock(peer);
            ast_channel_whentohangup_set(peer, &whentohangup);
            ast_channel_unlock(peer);
         }
         if (!ast_strlen_zero(mfcalled)) {
            ast_verb(3, "Sending MF '%s' to the called party.\n", mfcalled);
            res = ast_mf_stream(peer, chan, mfcalled, 50, 55, 120, 65, 0);
         }
         if (!ast_strlen_zero(mfcalling)) {
            ast_verb(3, "Sending MF '%s' to the calling party.\n", mfcalling);
            res = ast_mf_stream(chan, peer, mfcalling, 50, 55, 120, 65, 0);
         }
         if (!ast_strlen_zero(dtmfcalled)) {
            ast_verb(3, "Sending DTMF '%s' to the called party.\n", dtmfcalled);
            res = ast_dtmf_stream(peer, chan, dtmfcalled, 250, 0);
         }
         if (!ast_strlen_zero(dtmfcalling)) {
            ast_verb(3, "Sending DTMF '%s' to the calling party.\n", dtmfcalling);
            res = ast_dtmf_stream(chan, peer, dtmfcalling, 250, 0);
         }
      }

      if (res) { /* some error */
         if (!ast_check_hangup(chan) && ast_check_hangup(peer)) {
            ast_channel_hangupcause_set(chan, ast_channel_hangupcause(peer));
         }
         setup_peer_after_bridge_goto(chan, peer, &opts, opt_args);
         if (ast_bridge_setup_after_goto(peer)
            || ast_pbx_start(peer)) {
            ast_autoservice_chan_hangup_peer(chan, peer);
         }
         res = -1;
      } else {
         if (ast_test_flag64(peerflags, OPT_CALLEE_TRANSFER))
            ast_set_flag(&(config.features_callee), AST_FEATURE_REDIRECT);
         if (ast_test_flag64(peerflags, OPT_CALLER_TRANSFER))
            ast_set_flag(&(config.features_caller), AST_FEATURE_REDIRECT);
         if (ast_test_flag64(peerflags, OPT_CALLEE_HANGUP))
            ast_set_flag(&(config.features_callee), AST_FEATURE_DISCONNECT);
         if (ast_test_flag64(peerflags, OPT_CALLER_HANGUP))
            ast_set_flag(&(config.features_caller), AST_FEATURE_DISCONNECT);
         if (ast_test_flag64(peerflags, OPT_CALLEE_MONITOR))
            ast_set_flag(&(config.features_callee), AST_FEATURE_AUTOMON);
         if (ast_test_flag64(peerflags, OPT_CALLER_MONITOR))
            ast_set_flag(&(config.features_caller), AST_FEATURE_AUTOMON);
         if (ast_test_flag64(peerflags, OPT_CALLEE_PARK))
            ast_set_flag(&(config.features_callee), AST_FEATURE_PARKCALL);
         if (ast_test_flag64(peerflags, OPT_CALLER_PARK))
            ast_set_flag(&(config.features_caller), AST_FEATURE_PARKCALL);
         if (ast_test_flag64(peerflags, OPT_CALLEE_MIXMONITOR))
            ast_set_flag(&(config.features_callee), AST_FEATURE_AUTOMIXMON);
         if (ast_test_flag64(peerflags, OPT_CALLER_MIXMONITOR))
            ast_set_flag(&(config.features_caller), AST_FEATURE_AUTOMIXMON);

         config.end_bridge_callback = end_bridge_callback;
         config.end_bridge_callback_data = chan;
         config.end_bridge_callback_data_fixup = end_bridge_callback_data_fixup;

         if (moh) {
            moh = 0;
            ast_moh_stop(chan);
         } else if (sentringing) {
            sentringing = 0;
            ast_indicate(chan, -1);
         }
         /* Be sure no generators are left on it and reset the visible indication */
         ast_deactivate_generator(chan);
         ast_channel_visible_indication_set(chan, 0);
         /* Make sure channels are compatible */
         res = ast_channel_make_compatible(chan, peer);
         if (res < 0) {
            ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n", ast_channel_name(chan), ast_channel_name(peer));
            ast_autoservice_chan_hangup_peer(chan, peer);
            res = -1;
            goto done;
         }
         if (opermode) {
            struct oprmode oprmode;

            oprmode.peer = peer;
            oprmode.mode = opermode;

            ast_channel_setoption(chan, AST_OPTION_OPRMODE, &oprmode, sizeof(oprmode), 0);
         }
         setup_peer_after_bridge_goto(chan, peer, &opts, opt_args);

         res = ast_bridge_call(chan, peer, &config);
      }
   }
out:
   if (moh) {
      moh = 0;
      ast_moh_stop(chan);
   } else if (sentringing) {
      sentringing = 0;
      ast_indicate(chan, -1);
   }

   if (delprivintro && ast_fileexists(pa.privintro, NULL, NULL) > 0) {
      ast_filedelete(pa.privintro, NULL);
      if (ast_fileexists(pa.privintro, NULL, NULL) > 0) {
         ast_log(LOG_NOTICE, "privacy: ast_filedelete didn't do its job on %s\n", pa.privintro);
      } else {
         ast_verb(3, "Successfully deleted %s intro file\n", pa.privintro);
      }
   }

   ast_channel_early_bridge(chan, NULL);
    /* forward 'answered elsewhere' if we received it */
   hanguptree(&out_chans, NULL,
      ast_channel_hangupcause(chan) == AST_CAUSE_ANSWERED_ELSEWHERE
      || ast_test_flag64(&opts, OPT_CANCEL_ELSEWHERE)
      ? AST_CAUSE_ANSWERED_ELSEWHERE : -1);
   pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
   ast_debug(1, "Exiting with DIALSTATUS=%s.\n", pa.status);

   if ((ast_test_flag64(peerflags, OPT_GO_ON)) && !ast_check_hangup(chan) && (res != AST_PBX_INCOMPLETE)) {
      if (!ast_tvzero(calldurationlimit))
         memset(ast_channel_whentohangup(chan), 0, sizeof(*ast_channel_whentohangup(chan)));
      res = 0;
   }

done:
   if (config.answer_topology) {
      ast_trace(2, "%s Cleaning up topology: %p %s\n",
         peer ? ast_channel_name(peer) : "<no channel>", &config.answer_topology,
         ast_str_tmp(256, ast_stream_topology_to_str(config.answer_topology, &STR_TMP)));

      /*
       * At this point, the channel driver that answered should have bumped the
       * topology refcount for itself.  Here we're cleaning up the reference we added
       * in wait_for_answer().
       */
      ast_stream_topology_free(config.answer_topology);
   }
   if (config.warning_sound) {
      ast_free((char *)config.warning_sound);
   }
   if (config.end_sound) {
      ast_free((char *)config.end_sound);
   }
   if (config.start_sound) {
      ast_free((char *)config.start_sound);
   }
   ast_ignore_cc(chan);
   SCOPE_EXIT_RTN_VALUE(res, "%s: Done\n", ast_channel_name(chan));
}

dial_handle_playtones()

static int dial_handle_playtones ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 2190 of file app_dial.c.

References ast_channel_zone(), ast_debug, ast_get_indication_tone(), ast_log, ast_playtones_start(), ast_strlen_zero, ast_tone_zone_sound_unref(), ast_tone_zone_sound::data, LOG_WARNING, NULL, and str.

Referenced by dial_exec_full().

{
   struct ast_tone_zone_sound *ts = NULL;
   int res;
   const char *str = data;

   if (ast_strlen_zero(str)) {
      ast_debug(1,"Nothing to play\n");
      return -1;
   }

   ts = ast_get_indication_tone(ast_channel_zone(chan), str);

   if (ts && ts->data[0]) {
      res = ast_playtones_start(chan, 0, ts->data, 0);
   } else {
      res = -1;
   }

   if (ts) {
      ts = ast_tone_zone_sound_unref(ts);
   }

   if (res) {
      ast_log(LOG_WARNING, "Unable to start playtone \'%s\'\n", str);
   }

   return res;
}

do_forward()

static void do_forward ( struct chanlist *  o, struct cause_args *  num, struct ast_flags64 *  peerflags, int  single, int  caller_entertained, int *  to, struct ast_party_id *  forced_clid, struct ast_party_id *  stored_clid  )

static

helper function for wait_for_answer()

Parameters

o	Outgoing call channel list.
num	Incoming call channel cause accumulation
peerflags	Dial option flags
single	TRUE if there is only one outgoing call.
caller_entertained	TRUE if the caller is being entertained by MOH or ringback.
to	Remaining call timeout time.
forced_clid	OPT_FORCECLID caller id to send
stored_clid	Caller id representing the called party if needed

XXX this code is highly suspicious, as it essentially overwrites the outgoing channel without properly deleting it.

Todo:

eventually this function should be intergrated into and replaced by ast_call_forward()

Definition at line 930 of file app_dial.c.

References ast_call(), AST_CAUSE_BUSY, ast_channel_appl_set(), ast_channel_call_forward(), ast_channel_caller(), ast_channel_connected(), ast_channel_context(), ast_channel_data_set(), ast_channel_datastore_inherit(), ast_channel_dialed(), ast_channel_exten(), ast_channel_get_stream_topology(), ast_channel_inherit_variables(), ast_channel_lock, ast_channel_lock_both, ast_channel_macroexten(), ast_channel_make_compatible(), AST_CHANNEL_NAME, ast_channel_name(), ast_channel_publish_dial(), ast_channel_publish_dial_forward(), ast_channel_publish_snapshot(), ast_channel_redirecting(), ast_channel_redirecting_macro(), ast_channel_redirecting_sub(), ast_channel_req_accountcodes(), AST_CHANNEL_REQUESTOR_BRIDGE_PEER, ast_channel_set_caller_event(), ast_channel_unlock, ast_channel_update_redirecting(), ast_clear_flag64, ast_connected_line_copy_from_caller(), ast_copy_string(), ast_hangup(), ast_ignore_cc(), ast_indicate(), ast_log, ast_max_forwards_decrement(), ast_party_caller_set_init(), ast_party_connected_line_copy(), ast_party_connected_line_init(), ast_party_number_free(), ast_party_number_init(), ast_party_redirecting_copy(), ast_party_redirecting_free(), ast_party_redirecting_init(), ast_request_with_stream_topology(), ast_rtp_instance_early_bridge_make_compatible(), ast_set_flag64, ast_strdup, ast_stream_topology_clone(), ast_stream_topology_free(), ast_strlen_zero, ast_test_flag64, ast_verb, c, CAN_EARLY_BRIDGE, chanlist::chan, cause_args::chan, DIAL_CALLERID_ABSENT, DIAL_STILLGOING, ast_party_redirecting::from, handle_cause(), ast_party_caller::id, ast_party_connected_line::id, in, LOG_NOTICE, cause_args::nochan, NULL, ast_party_id::number, OPT_CANCEL_TIMEOUT, OPT_FORCECLID, OPT_IGNORE_CONNECTEDLINE, OPT_IGNORE_FORWARDING, OPT_ORIGINAL_CLID, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), S_COR, S_OR, ast_party_number::str, chanlist::stuff, chanlist::tech, ast_party_dialed::transit_network_select, and ast_party_number::valid.

Referenced by wait_for_answer().

{
   char tmpchan[256];
   char forwarder[AST_CHANNEL_NAME];
   struct ast_channel *original = o->chan;
   struct ast_channel *c = o->chan; /* the winner */
   struct ast_channel *in = num->chan; /* the input channel */
   char *stuff;
   char *tech;
   int cause;
   struct ast_party_caller caller;

   ast_copy_string(forwarder, ast_channel_name(c), sizeof(forwarder));
   ast_copy_string(tmpchan, ast_channel_call_forward(c), sizeof(tmpchan));
   if ((stuff = strchr(tmpchan, '/'))) {
      *stuff++ = '\0';
      tech = tmpchan;
   } else {
      const char *forward_context;
      ast_channel_lock(c);
      forward_context = pbx_builtin_getvar_helper(c, "FORWARD_CONTEXT");
      if (ast_strlen_zero(forward_context)) {
         forward_context = NULL;
      }
      snprintf(tmpchan, sizeof(tmpchan), "%s@%s", ast_channel_call_forward(c), forward_context ? forward_context : ast_channel_context(c));
      ast_channel_unlock(c);
      stuff = tmpchan;
      tech = "Local";
   }
   if (!strcasecmp(tech, "Local")) {
      /*
       * Drop the connected line update block for local channels since
       * this is going to run dialplan and the user can change his
       * mind about what connected line information he wants to send.
       */
      ast_clear_flag64(o, OPT_IGNORE_CONNECTEDLINE);
   }

   /* Before processing channel, go ahead and check for forwarding */
   ast_verb(3, "Now forwarding %s to '%s/%s' (thanks to %s)\n", ast_channel_name(in), tech, stuff, ast_channel_name(c));
   /* If we have been told to ignore forwards, just set this channel to null and continue processing extensions normally */
   if (ast_test_flag64(peerflags, OPT_IGNORE_FORWARDING)) {
      ast_verb(3, "Forwarding %s to '%s/%s' prevented.\n", ast_channel_name(in), tech, stuff);
      ast_channel_publish_dial_forward(in, original, NULL, NULL, "CANCEL",
         ast_channel_call_forward(original));
      c = o->chan = NULL;
      cause = AST_CAUSE_BUSY;
   } else {
      struct ast_stream_topology *topology;

      ast_channel_lock(in);
      topology = ast_stream_topology_clone(ast_channel_get_stream_topology(in));
      ast_channel_unlock(in);

      /* Setup parameters */
      c = o->chan = ast_request_with_stream_topology(tech, topology, NULL, in, stuff, &cause);

      ast_stream_topology_free(topology);

      if (c) {
         if (single && !caller_entertained) {
            ast_channel_make_compatible(in, o->chan);
         }
         ast_channel_lock_both(in, o->chan);
         ast_channel_inherit_variables(in, o->chan);
         ast_channel_datastore_inherit(in, o->chan);
         pbx_builtin_setvar_helper(o->chan, "FORWARDERNAME", forwarder);
         ast_max_forwards_decrement(o->chan);
         ast_channel_unlock(in);
         ast_channel_unlock(o->chan);
         /* When a call is forwarded, we don't want to track new interfaces
          * dialed for CC purposes. Setting the done flag will ensure that
          * any Dial operations that happen later won't record CC interfaces.
          */
         ast_ignore_cc(o->chan);
         ast_verb(3, "Not accepting call completion offers from call-forward recipient %s\n",
            ast_channel_name(o->chan));
      } else
         ast_log(LOG_NOTICE,
            "Forwarding failed to create channel to dial '%s/%s' (cause = %d)\n",
            tech, stuff, cause);
   }
   if (!c) {
      ast_channel_publish_dial(in, original, stuff, "BUSY");
      ast_clear_flag64(o, DIAL_STILLGOING);
      handle_cause(cause, num);
      ast_hangup(original);
   } else {
      ast_channel_lock_both(c, original);
      ast_party_redirecting_copy(ast_channel_redirecting(c),
         ast_channel_redirecting(original));
      ast_channel_unlock(c);
      ast_channel_unlock(original);

      ast_channel_lock_both(c, in);

      if (single && !caller_entertained && CAN_EARLY_BRIDGE(peerflags, c, in)) {
         ast_rtp_instance_early_bridge_make_compatible(c, in);
      }

      if (!ast_channel_redirecting(c)->from.number.valid
         || ast_strlen_zero(ast_channel_redirecting(c)->from.number.str)) {
         /*
          * The call was not previously redirected so it is
          * now redirected from this number.
          */
         ast_party_number_free(&ast_channel_redirecting(c)->from.number);
         ast_party_number_init(&ast_channel_redirecting(c)->from.number);
         ast_channel_redirecting(c)->from.number.valid = 1;
         ast_channel_redirecting(c)->from.number.str =
            ast_strdup(S_OR(ast_channel_macroexten(in), ast_channel_exten(in)));
      }

      ast_channel_dialed(c)->transit_network_select = ast_channel_dialed(in)->transit_network_select;

      /* Determine CallerID to store in outgoing channel. */
      ast_party_caller_set_init(&caller, ast_channel_caller(c));
      if (ast_test_flag64(peerflags, OPT_ORIGINAL_CLID)) {
         caller.id = *stored_clid;
         ast_channel_set_caller_event(c, &caller, NULL);
         ast_set_flag64(o, DIAL_CALLERID_ABSENT);
      } else if (ast_strlen_zero(S_COR(ast_channel_caller(c)->id.number.valid,
         ast_channel_caller(c)->id.number.str, NULL))) {
         /*
          * The new channel has no preset CallerID number by the channel
          * driver.  Use the dialplan extension and hint name.
          */
         caller.id = *stored_clid;
         ast_channel_set_caller_event(c, &caller, NULL);
         ast_set_flag64(o, DIAL_CALLERID_ABSENT);
      } else {
         ast_clear_flag64(o, DIAL_CALLERID_ABSENT);
      }

      /* Determine CallerID for outgoing channel to send. */
      if (ast_test_flag64(o, OPT_FORCECLID)) {
         struct ast_party_connected_line connected;

         ast_party_connected_line_init(&connected);
         connected.id = *forced_clid;
         ast_party_connected_line_copy(ast_channel_connected(c), &connected);
      } else {
         ast_connected_line_copy_from_caller(ast_channel_connected(c), ast_channel_caller(in));
      }

      ast_channel_req_accountcodes(c, in, AST_CHANNEL_REQUESTOR_BRIDGE_PEER);

      ast_channel_appl_set(c, "AppDial");
      ast_channel_data_set(c, "(Outgoing Line)");
      ast_channel_publish_snapshot(c);

      ast_channel_unlock(in);
      if (single && !ast_test_flag64(o, OPT_IGNORE_CONNECTEDLINE)) {
         struct ast_party_redirecting redirecting;

         /*
          * Redirecting updates to the caller make sense only on single
          * calls.
          *
          * We must unlock c before calling
          * ast_channel_redirecting_macro, because we put c into
          * autoservice there.  That is pretty much a guaranteed
          * deadlock.  This is why the handling of c's lock may seem a
          * bit unusual here.
          */
         ast_party_redirecting_init(&redirecting);
         ast_party_redirecting_copy(&redirecting, ast_channel_redirecting(c));
         ast_channel_unlock(c);
         if (ast_channel_redirecting_sub(c, in, &redirecting, 0) &&
            ast_channel_redirecting_macro(c, in, &redirecting, 1, 0)) {
            ast_channel_update_redirecting(in, &redirecting, NULL);
         }
         ast_party_redirecting_free(&redirecting);
      } else {
         ast_channel_unlock(c);
      }

      if (ast_test_flag64(peerflags, OPT_CANCEL_TIMEOUT)) {
         *to = -1;
      }

      if (ast_call(c, stuff, 0)) {
         ast_log(LOG_NOTICE, "Forwarding failed to dial '%s/%s'\n",
            tech, stuff);
         ast_channel_publish_dial(in, original, stuff, "CONGESTION");
         ast_clear_flag64(o, DIAL_STILLGOING);
         ast_hangup(original);
         ast_hangup(c);
         c = o->chan = NULL;
         num->nochan++;
      } else {
         ast_channel_publish_dial_forward(in, original, c, NULL, "CANCEL",
            ast_channel_call_forward(original));

         ast_channel_publish_dial(in, c, stuff, NULL);

         /* Hangup the original channel now, in case we needed it */
         ast_hangup(original);
      }
      if (single && !caller_entertained) {
         ast_indicate(in, -1);
      }
   }
}

end_bridge_callback()

static void end_bridge_callback ( void *  data )

static

Definition at line 2174 of file app_dial.c.

References ast_channel_get_duration_ms(), ast_channel_get_up_time_ms(), ast_channel_lock, ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_unlock, ast_channel::data, and set_duration_var().

Referenced by dial_exec_full().

{
   struct ast_channel *chan = data;

   ast_channel_lock(chan);
   ast_channel_stage_snapshot(chan);
   set_duration_var(chan, "ANSWEREDTIME", ast_channel_get_up_time_ms(chan));
   set_duration_var(chan, "DIALEDTIME", ast_channel_get_duration_ms(chan));
   ast_channel_stage_snapshot_done(chan);
   ast_channel_unlock(chan);
}

end_bridge_callback_data_fixup()

static void end_bridge_callback_data_fixup ( struct ast_bridge_config *  bconfig, struct ast_channel *  originator, struct ast_channel *  terminator  )

static

Definition at line 2186 of file app_dial.c.

References ast_bridge_config::end_bridge_callback_data.

Referenced by dial_exec_full().

                                                                                                                                              {
   bconfig->end_bridge_callback_data = originator;
}

get_cid_name()

static const char* get_cid_name ( char *  name, int  namelen, struct ast_channel *  chan  )

static

Definition at line 900 of file app_dial.c.

References ast_channel_context(), ast_channel_exten(), ast_channel_lock, ast_channel_macrocontext(), ast_channel_macroexten(), ast_channel_unlock, ast_get_hint(), ast_strdupa, context, exten, name, NULL, and S_OR.

Referenced by dial_exec_full().

{
   const char *context;
   const char *exten;

   ast_channel_lock(chan);
   context = ast_strdupa(S_OR(ast_channel_macrocontext(chan), ast_channel_context(chan)));
   exten = ast_strdupa(S_OR(ast_channel_macroexten(chan), ast_channel_exten(chan)));
   ast_channel_unlock(chan);

   return ast_get_hint(NULL, 0, name, namelen, chan, context, exten) ? name : "";
}

handle_cause()

static void handle_cause ( int  cause, struct cause_args *  num  )

static

Definition at line 859 of file app_dial.c.

References AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, AST_CAUSE_NO_ANSWER, AST_CAUSE_NO_ROUTE_DESTINATION, AST_CAUSE_NORMAL_CLEARING, AST_CAUSE_UNREGISTERED, cause_args::busy, cause_args::congestion, and cause_args::nochan.

Referenced by dial_exec_full(), do_forward(), and wait_for_answer().

{
   switch(cause) {
   case AST_CAUSE_BUSY:
      num->busy++;
      break;
   case AST_CAUSE_CONGESTION:
      num->congestion++;
      break;
   case AST_CAUSE_NO_ROUTE_DESTINATION:
   case AST_CAUSE_UNREGISTERED:
      num->nochan++;
      break;
   case AST_CAUSE_NO_ANSWER:
   case AST_CAUSE_NORMAL_CLEARING:
      break;
   default:
      num->nochan++;
      break;
   }
}

hanguptree()

static void hanguptree ( struct dial_head *  out_chans, struct ast_channel *  exception, int  hangupcause  )

static

Definition at line 829 of file app_dial.c.

References ast_channel_hangupcause_set(), ast_hangup(), AST_LIST_REMOVE_HEAD, chanlist::chan, and chanlist_free().

Referenced by dial_exec_full().

{
   /* Hang up a tree of stuff */
   struct chanlist *outgoing;

   while ((outgoing = AST_LIST_REMOVE_HEAD(out_chans, node))) {
      /* Hangup any existing lines we have open */
      if (outgoing->chan && (outgoing->chan != exception)) {
         if (hangupcause >= 0) {
            /* This is for the channel drivers */
            ast_channel_hangupcause_set(outgoing->chan, hangupcause);
         }
         ast_hangup(outgoing->chan);
      }
      chanlist_free(outgoing);
   }
}

load_module()

static int load_module ( void  )

static

Definition at line 3552 of file app_dial.c.

References app, AST_MODFLAG_DEFAULT, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ast_register_application_xml, ASTERISK_GPL_KEY, dial_exec(), rapp, retrydial_exec(), and unload_module().

{
   int res;

   res = ast_register_application_xml(app, dial_exec);
   res |= ast_register_application_xml(rapp, retrydial_exec);

   return res;
}

onedigit_goto()

static int onedigit_goto ( struct ast_channel *  chan, const char *  context, char  exten, int  pri  )

static

Definition at line 881 of file app_dial.c.

References ast_channel_context(), ast_channel_macrocontext(), ast_goto_if_exists(), ast_strlen_zero, and exten.

Referenced by retrydial_exec(), and wait_for_answer().

{
   char rexten[2] = { exten, '\0' };

   if (context) {
      if (!ast_goto_if_exists(chan, context, rexten, pri))
         return 1;
   } else {
      if (!ast_goto_if_exists(chan, ast_channel_context(chan), rexten, pri))
         return 1;
      else if (!ast_strlen_zero(ast_channel_macrocontext(chan))) {
         if (!ast_goto_if_exists(chan, ast_channel_macrocontext(chan), rexten, pri))
            return 1;
      }
   }
   return 0;
}

publish_dial_end_event()

static void publish_dial_end_event ( struct ast_channel *  in, struct dial_head *  out_chans, struct ast_channel *  exception, const char *  status  )

static

Definition at line 1146 of file app_dial.c.

References ast_channel_publish_dial(), AST_LIST_TRAVERSE, chanlist::chan, and NULL.

Referenced by wait_for_answer().

{
   struct chanlist *outgoing;
   AST_LIST_TRAVERSE(out_chans, outgoing, node) {
      if (!outgoing->chan || outgoing->chan == exception) {
         continue;
      }
      ast_channel_publish_dial(in, outgoing->chan, NULL, status);
   }
}

retrydial_exec()

static int retrydial_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 3434 of file app_dial.c.

References args, AST_APP_ARG, ast_channel_data_set(), ast_channel_flags(), ast_channel_language(), ast_channel_lock, ast_channel_unlock, AST_DECLARE_APP_ARGS, AST_DIGIT_ANY, ast_fileexists(), AST_FLAG_MOH, ast_log, ast_moh_start(), ast_moh_stop(), AST_PBX_INCOMPLETE, AST_STANDARD_APP_ARGS, ast_strdupa, ast_streamfile(), ast_strlen_zero, ast_test_flag, ast_test_flag64, ast_waitfordigit(), ast_waitstream(), context, dial_exec_full(), done, LOG_ERROR, LOG_WARNING, NULL, onedigit_goto(), OPT_DTMF_EXIT, parse(), pbx_builtin_getvar_helper(), and rapp.

Referenced by load_module().

{
   char *parse;
   const char *context = NULL;
   int sleepms = 0, loops = 0, res = -1;
   struct ast_flags64 peerflags = { 0, };
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(announce);
      AST_APP_ARG(sleep);
      AST_APP_ARG(retries);
      AST_APP_ARG(dialdata);
   );

   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "RetryDial requires an argument!\n");
      return -1;
   }

   parse = ast_strdupa(data);
   AST_STANDARD_APP_ARGS(args, parse);

   if (!ast_strlen_zero(args.sleep) && (sleepms = atoi(args.sleep)))
      sleepms *= 1000;

   if (!ast_strlen_zero(args.retries)) {
      loops = atoi(args.retries);
   }

   if (!args.dialdata) {
      ast_log(LOG_ERROR, "%s requires a 4th argument (dialdata)\n", rapp);
      goto done;
   }

   if (sleepms < 1000)
      sleepms = 10000;

   if (!loops)
      loops = -1; /* run forever */

   ast_channel_lock(chan);
   context = pbx_builtin_getvar_helper(chan, "EXITCONTEXT");
   context = !ast_strlen_zero(context) ? ast_strdupa(context) : NULL;
   ast_channel_unlock(chan);

   res = 0;
   while (loops) {
      int continue_exec;

      ast_channel_data_set(chan, "Retrying");
      if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_MOH))
         ast_moh_stop(chan);

      res = dial_exec_full(chan, args.dialdata, &peerflags, &continue_exec);
      if (continue_exec)
         break;

      if (res == 0) {
         if (ast_test_flag64(&peerflags, OPT_DTMF_EXIT)) {
            if (!ast_strlen_zero(args.announce)) {
               if (ast_fileexists(args.announce, NULL, ast_channel_language(chan)) > 0) {
                  if (!(res = ast_streamfile(chan, args.announce, ast_channel_language(chan))))
                     ast_waitstream(chan, AST_DIGIT_ANY);
               } else
                  ast_log(LOG_WARNING, "Announce file \"%s\" specified in Retrydial does not exist\n", args.announce);
            }
            if (!res && sleepms) {
               if (!ast_test_flag(ast_channel_flags(chan), AST_FLAG_MOH))
                  ast_moh_start(chan, NULL, NULL);
               res = ast_waitfordigit(chan, sleepms);
            }
         } else {
            if (!ast_strlen_zero(args.announce)) {
               if (ast_fileexists(args.announce, NULL, ast_channel_language(chan)) > 0) {
                  if (!(res = ast_streamfile(chan, args.announce, ast_channel_language(chan))))
                     res = ast_waitstream(chan, "");
               } else
                  ast_log(LOG_WARNING, "Announce file \"%s\" specified in Retrydial does not exist\n", args.announce);
            }
            if (sleepms) {
               if (!ast_test_flag(ast_channel_flags(chan), AST_FLAG_MOH))
                  ast_moh_start(chan, NULL, NULL);
               if (!res)
                  res = ast_waitfordigit(chan, sleepms);
            }
         }
      }

      if (res < 0 || res == AST_PBX_INCOMPLETE) {
         break;
      } else if (res > 0) { /* Trying to send the call elsewhere (1 digit ext) */
         if (onedigit_goto(chan, context, (char) res, 1)) {
            res = 0;
            break;
         }
      }
      loops--;
   }
   if (loops == 0)
      res = 0;
   else if (res == 1)
      res = 0;

   if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_MOH))
      ast_moh_stop(chan);
 done:
   return res;
}

set_duration_var()

static void set_duration_var ( struct ast_channel *  chan, const char *  var_base, int64_t  duration  )

static

Definition at line 1189 of file app_dial.c.

References buf, and pbx_builtin_setvar_helper().

Referenced by end_bridge_callback(), and wait_for_answer().

{
   char buf[32];
   char full_var_name[128];

   snprintf(buf, sizeof(buf), "%" PRId64, duration / 1000);
   pbx_builtin_setvar_helper(chan, var_base, buf);

   snprintf(full_var_name, sizeof(full_var_name), "%s_MS", var_base);
   snprintf(buf, sizeof(buf), "%" PRId64, duration);
   pbx_builtin_setvar_helper(chan, full_var_name, buf);
}

setup_peer_after_bridge_goto()

static void setup_peer_after_bridge_goto ( struct ast_channel *  chan, struct ast_channel *  peer, struct ast_flags64 *  opts, char *  opt_args[]  )

static

Definition at line 2232 of file app_dial.c.

References ast_bridge_set_after_go_on(), ast_bridge_set_after_h(), ast_channel_context(), ast_channel_exten(), ast_channel_lock, ast_channel_priority(), ast_channel_unlock, ast_strdupa, ast_test_flag64, context, OPT_ARG_CALLEE_GO_ON, OPT_CALLEE_GO_ON, OPT_PEER_H, and priority.

Referenced by dial_exec_full().

{
   const char *context;
   const char *extension;
   int priority;

   if (ast_test_flag64(opts, OPT_PEER_H)) {
      ast_channel_lock(chan);
      context = ast_strdupa(ast_channel_context(chan));
      ast_channel_unlock(chan);
      ast_bridge_set_after_h(peer, context);
   } else if (ast_test_flag64(opts, OPT_CALLEE_GO_ON)) {
      ast_channel_lock(chan);
      context = ast_strdupa(ast_channel_context(chan));
      extension = ast_strdupa(ast_channel_exten(chan));
      priority = ast_channel_priority(chan);
      ast_channel_unlock(chan);
      ast_bridge_set_after_go_on(peer, context, extension, priority,
         opt_args[OPT_ARG_CALLEE_GO_ON]);
   }
}

setup_privacy_args()

static int setup_privacy_args ( struct privacy_args *  pa, struct ast_flags64 *  opts, char *  opt_args[], struct ast_channel *  chan  )

static

returns 1 if successful, 0 or <0 if the caller should 'goto out'

Definition at line 2075 of file app_dial.c.

References ast_answer(), ast_channel_caller(), ast_channel_exten(), ast_channel_language(), ast_channel_name(), ast_config_AST_DATA_DIR, ast_copy_string(), ast_dsp_get_threshold_from_settings(), ast_filedelete(), ast_fileexists(), ast_log, ast_mkdir(), ast_play_and_record(), AST_PRIVACY_ALLOW, ast_privacy_check(), AST_PRIVACY_DENY, AST_PRIVACY_KILL, AST_PRIVACY_TORTURE, AST_PRIVACY_UNKNOWN, ast_shrink_phone_number(), ast_strdupa, ast_streamfile(), ast_strlen_zero, ast_test_flag64, ast_verb, ast_waitstream(), LOG_NOTICE, LOG_WARNING, NULL, OPT_ARG_PRIVACY, OPT_PRIVACY, OPT_SCREEN_NOCALLERID, privacy_args::privcid, privacy_args::privdb_val, privacy_args::privintro, silencethreshold, privacy_args::status, and THRESHOLD_SILENCE.

Referenced by dial_exec_full().

{
   char callerid[60];
   int res;
   char *l;

   if (ast_channel_caller(chan)->id.number.valid
      && !ast_strlen_zero(ast_channel_caller(chan)->id.number.str)) {
      l = ast_strdupa(ast_channel_caller(chan)->id.number.str);
      ast_shrink_phone_number(l);
      if (ast_test_flag64(opts, OPT_PRIVACY) ) {
         ast_verb(3, "Privacy DB is '%s', clid is '%s'\n", opt_args[OPT_ARG_PRIVACY], l);
         pa->privdb_val = ast_privacy_check(opt_args[OPT_ARG_PRIVACY], l);
      } else {
         ast_verb(3, "Privacy Screening, clid is '%s'\n", l);
         pa->privdb_val = AST_PRIVACY_UNKNOWN;
      }
   } else {
      char *tnam, *tn2;

      tnam = ast_strdupa(ast_channel_name(chan));
      /* clean the channel name so slashes don't try to end up in disk file name */
      for (tn2 = tnam; *tn2; tn2++) {
         if (*tn2 == '/')  /* any other chars to be afraid of? */
            *tn2 = '=';
      }
      ast_verb(3, "Privacy-- callerid is empty\n");

      snprintf(callerid, sizeof(callerid), "NOCALLERID_%s%s", ast_channel_exten(chan), tnam);
      l = callerid;
      pa->privdb_val = AST_PRIVACY_UNKNOWN;
   }

   ast_copy_string(pa->privcid, l, sizeof(pa->privcid));

   if (strncmp(pa->privcid, "NOCALLERID", 10) != 0 && ast_test_flag64(opts, OPT_SCREEN_NOCALLERID)) {
      /* if callerid is set and OPT_SCREEN_NOCALLERID is set also */
      ast_verb(3, "CallerID set (%s); N option set; Screening should be off\n", pa->privcid);
      pa->privdb_val = AST_PRIVACY_ALLOW;
   } else if (ast_test_flag64(opts, OPT_SCREEN_NOCALLERID) && strncmp(pa->privcid, "NOCALLERID", 10) == 0) {
      ast_verb(3, "CallerID blank; N option set; Screening should happen; dbval is %d\n", pa->privdb_val);
   }

   if (pa->privdb_val == AST_PRIVACY_DENY) {
      ast_verb(3, "Privacy DB reports PRIVACY_DENY for this callerid. Dial reports unavailable\n");
      ast_copy_string(pa->status, "NOANSWER", sizeof(pa->status));
      return 0;
   } else if (pa->privdb_val == AST_PRIVACY_KILL) {
      ast_copy_string(pa->status, "DONTCALL", sizeof(pa->status));
      return 0; /* Is this right? */
   } else if (pa->privdb_val == AST_PRIVACY_TORTURE) {
      ast_copy_string(pa->status, "TORTURE", sizeof(pa->status));
      return 0; /* is this right??? */
   } else if (pa->privdb_val == AST_PRIVACY_UNKNOWN) {
      /* Get the user's intro, store it in priv-callerintros/$CID,
         unless it is already there-- this should be done before the
         call is actually dialed  */

      /* make sure the priv-callerintros dir actually exists */
      snprintf(pa->privintro, sizeof(pa->privintro), "%s/sounds/priv-callerintros", ast_config_AST_DATA_DIR);
      if ((res = ast_mkdir(pa->privintro, 0755))) {
         ast_log(LOG_WARNING, "privacy: can't create directory priv-callerintros: %s\n", strerror(res));
         return -1;
      }

      snprintf(pa->privintro, sizeof(pa->privintro), "priv-callerintros/%s", pa->privcid);
      if (ast_fileexists(pa->privintro, NULL, NULL ) > 0 && strncmp(pa->privcid, "NOCALLERID", 10) != 0) {
         /* the DELUX version of this code would allow this caller the
            option to hear and retape their previously recorded intro.
         */
      } else {
         int duration; /* for feedback from play_and_wait */
         /* the file doesn't exist yet. Let the caller submit his
            vocal intro for posterity */
         /* priv-recordintro script:
            "At the tone, please say your name:"
         */
         int silencethreshold = ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE);
         ast_answer(chan);
         res = ast_play_and_record(chan, "priv-recordintro", pa->privintro, 4, "sln", &duration, NULL, silencethreshold, 2000, 0);  /* NOTE: I've reduced the total time to 4 sec */
                           /* don't think we'll need a lock removed, we took care of
                              conflicts by naming the pa.privintro file */
         if (res == -1) {
            /* Delete the file regardless since they hung up during recording */
            ast_filedelete(pa->privintro, NULL);
            if (ast_fileexists(pa->privintro, NULL, NULL) > 0)
               ast_log(LOG_NOTICE, "privacy: ast_filedelete didn't do its job on %s\n", pa->privintro);
            else
               ast_verb(3, "Successfully deleted %s intro file\n", pa->privintro);
            return -1;
         }
         if (!ast_streamfile(chan, "vm-dialout", ast_channel_language(chan)) )
            ast_waitstream(chan, "");
      }
   }
   return 1; /* success */
}

unload_module()

static int unload_module ( void  )

static

Definition at line 3542 of file app_dial.c.

References app, ast_unregister_application(), and rapp.

Referenced by load_module().

{
   int res;

   res = ast_unregister_application(app);
   res |= ast_unregister_application(rapp);

   return res;
}

update_connected_line_from_peer()

static void update_connected_line_from_peer ( struct ast_channel *  chan, struct ast_channel *  peer, int  is_caller  )

static

Definition at line 1168 of file app_dial.c.

References ast_channel_caller(), ast_channel_connected_line_macro(), ast_channel_connected_line_sub(), ast_channel_lock, ast_channel_unlock, ast_channel_update_connected_line(), ast_connected_line_copy_from_caller(), AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER, ast_party_connected_line_free(), ast_party_connected_line_init(), NULL, and ast_party_connected_line::source.

Referenced by wait_for_answer().

{
   struct ast_party_connected_line connected_caller;

   ast_party_connected_line_init(&connected_caller);

   ast_channel_lock(peer);
   ast_connected_line_copy_from_caller(&connected_caller, ast_channel_caller(peer));
   ast_channel_unlock(peer);
   connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
   if (ast_channel_connected_line_sub(peer, chan, &connected_caller, 0)
      && ast_channel_connected_line_macro(peer, chan, &connected_caller, is_caller, 0)) {
      ast_channel_update_connected_line(chan, &connected_caller, NULL);
   }
   ast_party_connected_line_free(&connected_caller);
}

valid_priv_reply()

static int valid_priv_reply ( struct ast_flags64 *  opts, int  res  )

static

Definition at line 1928 of file app_dial.c.

References ast_autoservice_start(), ast_autoservice_stop(), ast_channel_musicclass(), AST_CONTROL_RINGING, ast_copy_string(), ast_filedelete(), ast_fileexists(), ast_indicate(), ast_log, ast_moh_start(), ast_moh_stop(), ast_play_and_wait(), AST_PRIVACY_ALLOW, AST_PRIVACY_DENY, AST_PRIVACY_KILL, ast_privacy_set(), AST_PRIVACY_TORTURE, ast_strdupa, ast_strlen_zero, ast_test_flag64, ast_verb, chanlist::chan, LOG_NOTICE, NULL, OPT_ARG_MUSICBACK, OPT_ARG_PRIVACY, OPT_MUSICBACK, OPT_PRIVACY, OPT_RING_WITH_EARLY_MEDIA, OPT_RINGBACK, OPT_SCREEN_NOINTRO, OPT_SCREENING, privacy_args::privcid, privacy_args::privintro, privacy_args::sentringing, and privacy_args::status.

{
   if (res < '1')
      return 0;
   if (ast_test_flag64(opts, OPT_PRIVACY) && res <= '5')
      return 1;
   if (ast_test_flag64(opts, OPT_SCREENING) && res <= '4')
      return 1;
   return 0;
}

wait_for_answer()

static struct ast_channel* wait_for_answer ( struct ast_channel *  in, struct dial_head *  out_chans, int *  to, struct ast_flags64 *  peerflags, char *  opt_args[], struct privacy_args *  pa, const struct cause_args *  num_in, int *  result, char *  dtmf_progress, char *  mf_progress, const int  ignore_cc, struct ast_party_id *  forced_clid, struct ast_party_id *  stored_clid, struct ast_bridge_config *  config  )

static

Definition at line 1202 of file app_dial.c.

References ast_bridge_config::answer_topology, ao2_bump, chanlist::aoc_s_rate_list, ast_aoc_decode(), ast_aoc_destroy_decoded(), ast_aoc_destroy_encoded(), ast_aoc_encode(), ast_aoc_get_msg_type(), AST_AOC_S, AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, AST_CAUSE_NORMAL_CLEARING, ast_cc_completed(), ast_cc_failed(), ast_cc_is_recall(), ast_channel_call_forward(), ast_channel_connected(), ast_channel_connected_line_macro(), ast_channel_connected_line_sub(), ast_channel_creationtime(), ast_channel_early_bridge(), ast_channel_exten_set(), ast_channel_hangupcause(), ast_channel_hangupcause_set(), ast_channel_lock, ast_channel_make_compatible(), ast_channel_name(), ast_channel_publish_dial(), ast_channel_redirecting_macro(), ast_channel_redirecting_sub(), ast_channel_sendhtml(), ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_unlock, ast_channel_update_connected_line(), ast_check_hangup(), ast_check_hangup_locked(), ast_clear_flag64, ast_connected_line_parse_data(), AST_CONTROL_ANSWER, AST_CONTROL_AOC, AST_CONTROL_BUSY, AST_CONTROL_CC, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_OFFHOOK, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_REDIRECTING, AST_CONTROL_RINGING, AST_CONTROL_SRCCHANGE, AST_CONTROL_SRCUPDATE, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, ast_copy_flags64, ast_deactivate_generator(), ast_debug, ast_dtmf_stream(), AST_FEATURE_MAX_LEN, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_HTML, AST_FRAME_IMAGE, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_free, ast_frfree, ast_handle_cc_control_frame(), ast_hangup(), ast_hangup_cause_to_dial_status(), ast_indicate(), ast_indicate_data(), AST_LIST_FIRST, AST_LIST_NEXT, AST_LIST_TRAVERSE, ast_log, AST_MAX_WATCHERS, ast_mf_stream(), ast_party_connected_line_copy(), ast_party_connected_line_free(), ast_party_connected_line_set(), ast_party_connected_line_set_init(), ast_read(), ast_remaining_ms(), AST_STATE_UP, ast_str_alloca, ast_str_tmp, ast_strdup, ast_stream_topology_to_str(), ast_strlen_zero, ast_test_flag64, ast_trace, ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), ast_verb, ast_waitfor_n(), ast_write(), cause_args::busy, c, CAN_EARLY_BRIDGE, chanlist::chan, cause_args::congestion, chanlist::connected, context, ast_frame::data, ast_frame::datalen, detect_disconnect(), DIAL_CALLERID_ABSENT, DIAL_NOFORWARDHTML, DIAL_STILLGOING, do_forward(), ast_frame::frametype, handle_cause(), in, ast_frame_subclass::integer, LOG_ERROR, LOG_WARNING, ast_channel::name, cause_args::nochan, NULL, onedigit_goto(), OPT_ARG_RINGBACK, OPT_CALLEE_HANGUP, OPT_CALLEE_MIXMONITOR, OPT_CALLEE_MONITOR, OPT_CALLEE_PARK, OPT_CALLEE_TRANSFER, OPT_CALLER_HANGUP, OPT_CALLER_MIXMONITOR, OPT_CALLER_MONITOR, OPT_CALLER_PARK, OPT_CALLER_TRANSFER, OPT_DTMF_EXIT, OPT_IGNORE_CONNECTEDLINE, OPT_MUSICBACK, OPT_RINGBACK, chanlist::orig_chan_name, pbx_builtin_getvar_helper(), chanlist::pending_connected_update, ast_frame::ptr, publish_dial_end_event(), SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, privacy_args::sentringing, set_duration_var(), privacy_args::status, ast_frame::subclass, ast_frame_subclass::topology, ast_frame::uint32, and update_connected_line_from_peer().

Referenced by dial_exec_full().

{
   struct cause_args num = *num_in;
   int prestart = num.busy + num.congestion + num.nochan;
   int orig = *to;
   struct ast_channel *peer = NULL;
   struct chanlist *outgoing = AST_LIST_FIRST(out_chans);
   /* single is set if only one destination is enabled */
   int single = outgoing && !AST_LIST_NEXT(outgoing, node);
   int caller_entertained = outgoing
      && ast_test_flag64(outgoing, OPT_MUSICBACK | OPT_RINGBACK);
   struct ast_str *featurecode = ast_str_alloca(AST_FEATURE_MAX_LEN + 1);
   int cc_recall_core_id;
   int is_cc_recall;
   int cc_frame_received = 0;
   int num_ringing = 0;
   int sent_ring = 0;
   int sent_progress = 0;
   struct timeval start = ast_tvnow();
   SCOPE_ENTER(3, "%s\n", ast_channel_name(in));

   if (single) {
      /* Turn off hold music, etc */
      if (!caller_entertained) {
         ast_deactivate_generator(in);
         /* If we are calling a single channel, and not providing ringback or music, */
         /* then, make them compatible for in-band tone purpose */
         if (ast_channel_make_compatible(in, outgoing->chan) < 0) {
            /* If these channels can not be made compatible,
             * there is no point in continuing.  The bridge
             * will just fail if it gets that far.
             */
            *to = -1;
            strcpy(pa->status, "CONGESTION");
            ast_channel_publish_dial(in, outgoing->chan, NULL, pa->status);
            SCOPE_EXIT_RTN_VALUE(NULL, "%s: can't be made compat with %s\n",
               ast_channel_name(in), ast_channel_name(outgoing->chan));
         }
      }

      if (!ast_test_flag64(outgoing, OPT_IGNORE_CONNECTEDLINE)
         && !ast_test_flag64(outgoing, DIAL_CALLERID_ABSENT)) {
         update_connected_line_from_peer(in, outgoing->chan, 1);
      }
   }

   is_cc_recall = ast_cc_is_recall(in, &cc_recall_core_id, NULL);

   while ((*to = ast_remaining_ms(start, orig)) && !peer) {
      struct chanlist *o;
      int pos = 0; /* how many channels do we handle */
      int numlines = prestart;
      struct ast_channel *winner;
      struct ast_channel *watchers[AST_MAX_WATCHERS];

      watchers[pos++] = in;
      AST_LIST_TRAVERSE(out_chans, o, node) {
         /* Keep track of important channels */
         if (ast_test_flag64(o, DIAL_STILLGOING) && o->chan)
            watchers[pos++] = o->chan;
         numlines++;
      }
      if (o && !o->chan) {
         ast_log(LOG_ERROR, "!!! Channel's gone\n");
      }
      ast_log(LOG_ERROR, "!!! Watcher pos: %d\n", pos);
      if (pos == 1) { /* only the input channel is available */
         if (numlines == (num.busy + num.congestion + num.nochan)) {
            ast_verb(2, "Everyone is busy/congested at this time (%d:%d/%d/%d)\n", numlines, num.busy, num.congestion, num.nochan);
            if (num.busy)
               strcpy(pa->status, "BUSY");
            else if (num.congestion)
               strcpy(pa->status, "CONGESTION");
            else if (num.nochan)
               strcpy(pa->status, "CHANUNAVAIL");
         } else {
            ast_verb(3, "No one is available to answer at this time (%d:%d/%d/%d)\n", numlines, num.busy, num.congestion, num.nochan);
         }
         *to = 0;
         if (is_cc_recall) {
            ast_cc_failed(cc_recall_core_id, "Everyone is busy/congested for the recall. How sad");
         }
         SCOPE_EXIT_RTN_VALUE(NULL, "%s: No outging channels available\n", ast_channel_name(in));
      }
      winner = ast_waitfor_n(watchers, pos, to);
      AST_LIST_TRAVERSE(out_chans, o, node) {
         struct ast_frame *f;
         struct ast_channel *c = o->chan;

         if (c == NULL) {
            continue;
         }
         if (ast_test_flag64(o, DIAL_STILLGOING) && ast_channel_state(c) == AST_STATE_UP) {
            if (!peer) {
               ast_verb(3, "%s answered %s\n", ast_channel_name(c), ast_channel_name(in));
               if (o->orig_chan_name
                  && strcmp(o->orig_chan_name, ast_channel_name(c))) {
                  /*
                   * The channel name changed so we must generate COLP update.
                   * Likely because a call pickup channel masqueraded in.
                   */
                  update_connected_line_from_peer(in, c, 1);
               } else if (!single && !ast_test_flag64(o, OPT_IGNORE_CONNECTEDLINE)) {
                  if (o->pending_connected_update) {
                     if (ast_channel_connected_line_sub(c, in, &o->connected, 0) &&
                        ast_channel_connected_line_macro(c, in, &o->connected, 1, 0)) {
                        ast_channel_update_connected_line(in, &o->connected, NULL);
                     }
                  } else if (!ast_test_flag64(o, DIAL_CALLERID_ABSENT)) {
                     update_connected_line_from_peer(in, c, 1);
                  }
               }
               if (o->aoc_s_rate_list) {
                  size_t encoded_size;
                  struct ast_aoc_encoded *encoded;
                  if ((encoded = ast_aoc_encode(o->aoc_s_rate_list, &encoded_size, o->chan))) {
                     ast_indicate_data(in, AST_CONTROL_AOC, encoded, encoded_size);
                     ast_aoc_destroy_encoded(encoded);
                  }
               }
               peer = c;
               publish_dial_end_event(in, out_chans, peer, "CANCEL");
               ast_copy_flags64(peerflags, o,
                  OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
                  OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
                  OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
                  OPT_CALLEE_PARK | OPT_CALLER_PARK |
                  OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
                  DIAL_NOFORWARDHTML);
               ast_channel_dialcontext_set(c, "");
               ast_channel_exten_set(c, "");
            }
            continue;
         }
         if (c != winner) {
            ast_log(LOG_WARNING, "And C2: %s\n", ast_channel_name(c));
            continue;
         }
         /* here, o->chan == c == winner */
         if (!ast_strlen_zero(ast_channel_call_forward(c))) {
            pa->sentringing = 0;
            if (!ignore_cc && (f = ast_read(c))) {
               if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_CC) {
                  /* This channel is forwarding the call, and is capable of CC, so
                   * be sure to add the new device interface to the list
                   */
                  ast_handle_cc_control_frame(in, c, f->data.ptr);
               }
               ast_frfree(f);
            }

            if (o->pending_connected_update) {
               /*
                * Re-seed the chanlist's connected line information with
                * previously acquired connected line info from the incoming
                * channel.  The previously acquired connected line info could
                * have been set through the CONNECTED_LINE dialplan function.
                */
               o->pending_connected_update = 0;
               ast_channel_lock(in);
               ast_party_connected_line_copy(&o->connected, ast_channel_connected(in));
               ast_channel_unlock(in);
            }

            do_forward(o, &num, peerflags, single, caller_entertained, &orig,
               forced_clid, stored_clid);

            if (o->chan) {
               ast_free(o->orig_chan_name);
               o->orig_chan_name = ast_strdup(ast_channel_name(o->chan));
               if (single
                  && !ast_test_flag64(o, OPT_IGNORE_CONNECTEDLINE)
                  && !ast_test_flag64(o, DIAL_CALLERID_ABSENT)) {
                  update_connected_line_from_peer(in, o->chan, 1);
               }
            }
            continue;
         }
         ast_log(LOG_WARNING, "Let's go read a frame !!!\n");
         f = ast_read(winner);
         if (!f) {
            ast_log(LOG_WARNING, "!!! NULL - no frame!\n");
            ast_channel_hangupcause_set(in, ast_channel_hangupcause(c));
            ast_channel_publish_dial(in, c, NULL, ast_hangup_cause_to_dial_status(ast_channel_hangupcause(c)));
            ast_hangup(c);
            c = o->chan = NULL;
            ast_clear_flag64(o, DIAL_STILLGOING);
            handle_cause(ast_channel_hangupcause(in), &num);
            continue;
         } else {
            ast_log(LOG_WARNING, "Frame: %d\n", f->subclass.integer);
         }
         switch (f->frametype) {
         case AST_FRAME_CONTROL:
            switch (f->subclass.integer) {
            case AST_CONTROL_ANSWER:
               /* This is our guy if someone answered. */
               if (!peer) {
                  ast_trace(-1, "%s answered %s\n", ast_channel_name(c), ast_channel_name(in));
                  ast_verb(3, "%s answered %s\n", ast_channel_name(c), ast_channel_name(in));
                  if (o->orig_chan_name
                     && strcmp(o->orig_chan_name, ast_channel_name(c))) {
                     /*
                      * The channel name changed so we must generate COLP update.
                      * Likely because a call pickup channel masqueraded in.
                      */
                     update_connected_line_from_peer(in, c, 1);
                  } else if (!single && !ast_test_flag64(o, OPT_IGNORE_CONNECTEDLINE)) {
                     if (o->pending_connected_update) {
                        if (ast_channel_connected_line_sub(c, in, &o->connected, 0) &&
                           ast_channel_connected_line_macro(c, in, &o->connected, 1, 0)) {
                           ast_channel_update_connected_line(in, &o->connected, NULL);
                        }
                     } else if (!ast_test_flag64(o, DIAL_CALLERID_ABSENT)) {
                        update_connected_line_from_peer(in, c, 1);
                     }
                  }
                  if (o->aoc_s_rate_list) {
                     size_t encoded_size;
                     struct ast_aoc_encoded *encoded;
                     if ((encoded = ast_aoc_encode(o->aoc_s_rate_list, &encoded_size, o->chan))) {
                        ast_indicate_data(in, AST_CONTROL_AOC, encoded, encoded_size);
                        ast_aoc_destroy_encoded(encoded);
                     }
                  }
                  peer = c;
                  /* Answer can optionally include a topology */
                  if (f->subclass.topology) {
                     /*
                      * We need to bump the refcount on the topology to prevent it
                      * from being cleaned up when the frame is cleaned up.
                      */
                     config->answer_topology = ao2_bump(f->subclass.topology);
                     ast_trace(-1, "%s Found topology in frame: %p %p %s\n",
                        ast_channel_name(peer), f, config->answer_topology,
                        ast_str_tmp(256, ast_stream_topology_to_str(config->answer_topology, &STR_TMP)));
                  }

                  /* Inform everyone else that they've been canceled.
                   * The dial end event for the peer will be sent out after
                   * other Dial options have been handled.
                   */
                  publish_dial_end_event(in, out_chans, peer, "CANCEL");
                  ast_copy_flags64(peerflags, o,
                     OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
                     OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
                     OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
                     OPT_CALLEE_PARK | OPT_CALLER_PARK |
                     OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
                     DIAL_NOFORWARDHTML);
                  ast_channel_dialcontext_set(c, "");
                  ast_channel_exten_set(c, "");
                  if (CAN_EARLY_BRIDGE(peerflags, in, peer)) {
                     /* Setup early bridge if appropriate */
                     ast_channel_early_bridge(in, peer);
                  }
               }
               /* If call has been answered, then the eventual hangup is likely to be normal hangup */
               ast_channel_hangupcause_set(in, AST_CAUSE_NORMAL_CLEARING);
               ast_channel_hangupcause_set(c, AST_CAUSE_NORMAL_CLEARING);
               break;
            case AST_CONTROL_BUSY:
               ast_verb(3, "%s is busy\n", ast_channel_name(c));
               ast_channel_hangupcause_set(in, ast_channel_hangupcause(c));
               ast_channel_publish_dial(in, c, NULL, "BUSY");
               ast_hangup(c);
               c = o->chan = NULL;
               ast_clear_flag64(o, DIAL_STILLGOING);
               handle_cause(AST_CAUSE_BUSY, &num);
               break;
            case AST_CONTROL_CONGESTION:
               ast_verb(3, "%s is circuit-busy\n", ast_channel_name(c));
               ast_channel_hangupcause_set(in, ast_channel_hangupcause(c));
               ast_channel_publish_dial(in, c, NULL, "CONGESTION");
               ast_hangup(c);
               c = o->chan = NULL;
               ast_clear_flag64(o, DIAL_STILLGOING);
               handle_cause(AST_CAUSE_CONGESTION, &num);
               break;
            case AST_CONTROL_RINGING:
               /* This is a tricky area to get right when using a native
                * CC agent. The reason is that we do the best we can to send only a
                * single ringing notification to the caller.
                *
                * Call completion complicates the logic used here. CCNR is typically
                * offered during a ringing message. Let's say that party A calls
                * parties B, C, and D. B and C do not support CC requests, but D
                * does. If we were to receive a ringing notification from B before
                * the others, then we would end up sending a ringing message to
                * A with no CCNR offer present.
                *
                * The approach that we have taken is that if we receive a ringing
                * response from a party and no CCNR offer is present, we need to
                * wait. Specifically, we need to wait until either a) a called party
                * offers CCNR in its ringing response or b) all called parties have
                * responded in some way to our call and none offers CCNR.
                *
                * The drawback to this is that if one of the parties has a delayed
                * response or, god forbid, one just plain doesn't respond to our
                * outgoing call, then this will result in a significant delay between
                * when the caller places the call and hears ringback.
                *
                * Note also that if CC is disabled for this call, then it is perfectly
                * fine for ringing frames to get sent through.
                */
               ++num_ringing;
               if (ignore_cc || cc_frame_received || num_ringing == numlines) {
                  ast_verb(3, "%s is ringing\n", ast_channel_name(c));
                  /* Setup early media if appropriate */
                  if (single && !caller_entertained
                     && CAN_EARLY_BRIDGE(peerflags, in, c)) {
                     ast_channel_early_bridge(in, c);
                  }
                  if (!(pa->sentringing) && !ast_test_flag64(outgoing, OPT_MUSICBACK) && ast_strlen_zero(opt_args[OPT_ARG_RINGBACK])) {
                     ast_indicate(in, AST_CONTROL_RINGING);
                     pa->sentringing++;
                  }
                  if (!sent_ring) {
                     struct timeval now, then;
                     int64_t diff;

                     now = ast_tvnow();

                     ast_channel_lock(in);
                     ast_channel_stage_snapshot(in);

                     then = ast_channel_creationtime(c);
                     diff = ast_tvzero(then) ? 0 : ast_tvdiff_ms(now, then);
                     set_duration_var(in, "RINGTIME", diff);

                     ast_channel_stage_snapshot_done(in);
                     ast_channel_unlock(in);
                     sent_ring = 1;
                  }
               }
               ast_channel_publish_dial(in, c, NULL, "RINGING");
               break;
            case AST_CONTROL_PROGRESS:
               ast_verb(3, "%s is making progress passing it to %s\n", ast_channel_name(c), ast_channel_name(in));
               /* Setup early media if appropriate */
               if (single && !caller_entertained
                  && CAN_EARLY_BRIDGE(peerflags, in, c)) {
                  ast_channel_early_bridge(in, c);
               }
               if (!ast_test_flag64(outgoing, OPT_RINGBACK)) {
                  if (single || (!single && !pa->sentringing)) {
                     ast_indicate(in, AST_CONTROL_PROGRESS);
                  }
               }
               if (!sent_progress) {
                  struct timeval now, then;
                  int64_t diff;

                  now = ast_tvnow();

                  ast_channel_lock(in);
                  ast_channel_stage_snapshot(in);

                  then = ast_channel_creationtime(c);
                  diff = ast_tvzero(then) ? 0 : ast_tvdiff_ms(now, then);
                  set_duration_var(in, "PROGRESSTIME", diff);

                  ast_channel_stage_snapshot_done(in);
                  ast_channel_unlock(in);
                  sent_progress = 1;

                  if (!ast_strlen_zero(mf_progress)) {
                     ast_verb(3,
                        "Sending MF '%s' to the called party as result of "
                        "receiving a PROGRESS message.\n",
                        mf_progress);
                     ast_mf_stream(c, in, mf_progress, 50, 55, 120, 65, 0);
                  }
                  if (!ast_strlen_zero(dtmf_progress)) {
                     ast_verb(3,
                        "Sending DTMF '%s' to the called party as result of "
                        "receiving a PROGRESS message.\n",
                        dtmf_progress);
                     ast_dtmf_stream(c, in, dtmf_progress, 250, 0);
                  }
               }
               ast_channel_publish_dial(in, c, NULL, "PROGRESS");
               break;
            case AST_CONTROL_VIDUPDATE:
            case AST_CONTROL_SRCUPDATE:
            case AST_CONTROL_SRCCHANGE:
               if (!single || caller_entertained) {
                  break;
               }
               ast_verb(3, "%s requested media update control %d, passing it to %s\n",
                  ast_channel_name(c), f->subclass.integer, ast_channel_name(in));
               ast_indicate(in, f->subclass.integer);
               break;
            case AST_CONTROL_CONNECTED_LINE:
               if (ast_test_flag64(o, OPT_IGNORE_CONNECTEDLINE)) {
                  ast_verb(3, "Connected line update to %s prevented.\n", ast_channel_name(in));
                  break;
               }
               if (!single) {
                  struct ast_party_connected_line connected;

                  ast_verb(3, "%s connected line has changed. Saving it until answer for %s\n",
                     ast_channel_name(c), ast_channel_name(in));
                  ast_party_connected_line_set_init(&connected, &o->connected);
                  ast_connected_line_parse_data(f->data.ptr, f->datalen, &connected);
                  ast_party_connected_line_set(&o->connected, &connected, NULL);
                  ast_party_connected_line_free(&connected);
                  o->pending_connected_update = 1;
                  break;
               }
               if (ast_channel_connected_line_sub(c, in, f, 1) &&
                  ast_channel_connected_line_macro(c, in, f, 1, 1)) {
                  ast_indicate_data(in, AST_CONTROL_CONNECTED_LINE, f->data.ptr, f->datalen);
               }
               break;
            case AST_CONTROL_AOC:
               {
                  struct ast_aoc_decoded *decoded = ast_aoc_decode(f->data.ptr, f->datalen, o->chan);
                  if (decoded && (ast_aoc_get_msg_type(decoded) == AST_AOC_S)) {
                     ast_aoc_destroy_decoded(o->aoc_s_rate_list);
                     o->aoc_s_rate_list = decoded;
                  } else {
                     ast_aoc_destroy_decoded(decoded);
                  }
               }
               break;
            case AST_CONTROL_REDIRECTING:
               if (!single) {
                  /*
                   * Redirecting updates to the caller make sense only on single
                   * calls.
                   */
                  break;
               }
               if (ast_test_flag64(o, OPT_IGNORE_CONNECTEDLINE)) {
                  ast_verb(3, "Redirecting update to %s prevented.\n", ast_channel_name(in));
                  break;
               }
               ast_verb(3, "%s redirecting info has changed, passing it to %s\n",
                  ast_channel_name(c), ast_channel_name(in));
               if (ast_channel_redirecting_sub(c, in, f, 1) &&
                  ast_channel_redirecting_macro(c, in, f, 1, 1)) {
                  ast_indicate_data(in, AST_CONTROL_REDIRECTING, f->data.ptr, f->datalen);
               }
               pa->sentringing = 0;
               break;
            case AST_CONTROL_PROCEEDING:
               ast_verb(3, "%s is proceeding passing it to %s\n", ast_channel_name(c), ast_channel_name(in));
               if (single && !caller_entertained
                  && CAN_EARLY_BRIDGE(peerflags, in, c)) {
                  ast_channel_early_bridge(in, c);
               }
               if (!ast_test_flag64(outgoing, OPT_RINGBACK))
                  ast_indicate(in, AST_CONTROL_PROCEEDING);
               ast_channel_publish_dial(in, c, NULL, "PROCEEDING");
               break;
            case AST_CONTROL_HOLD:
               /* XXX this should be saved like AST_CONTROL_CONNECTED_LINE for !single || caller_entertained */
               ast_verb(3, "Call on %s placed on hold\n", ast_channel_name(c));
               ast_indicate_data(in, AST_CONTROL_HOLD, f->data.ptr, f->datalen);
               break;
            case AST_CONTROL_UNHOLD:
               /* XXX this should be saved like AST_CONTROL_CONNECTED_LINE for !single || caller_entertained */
               ast_verb(3, "Call on %s left from hold\n", ast_channel_name(c));
               ast_indicate(in, AST_CONTROL_UNHOLD);
               break;
            case AST_CONTROL_OFFHOOK:
            case AST_CONTROL_FLASH:
               /* Ignore going off hook and flash */
               break;
            case AST_CONTROL_CC:
               if (!ignore_cc) {
                  ast_handle_cc_control_frame(in, c, f->data.ptr);
                  cc_frame_received = 1;
               }
               break;
            case AST_CONTROL_PVT_CAUSE_CODE:
               ast_indicate_data(in, AST_CONTROL_PVT_CAUSE_CODE, f->data.ptr, f->datalen);
               break;
            case -1:
               if (single && !caller_entertained) {
                  ast_verb(3, "%s stopped sounds\n", ast_channel_name(c));
                  ast_indicate(in, -1);
                  pa->sentringing = 0;
               }
               break;
            default:
               ast_debug(1, "Dunno what to do with control type %d\n", f->subclass.integer);
               break;
            }
            break;
         case AST_FRAME_VIDEO:
         case AST_FRAME_VOICE:
         case AST_FRAME_IMAGE:
            if (caller_entertained) {
               break;
            }
            /* Fall through */
         case AST_FRAME_TEXT:
            if (single && ast_write(in, f)) {
               ast_log(LOG_WARNING, "Unable to write frametype: %u\n",
                  f->frametype);
            }
            break;
         case AST_FRAME_HTML:
            if (single && !ast_test_flag64(outgoing, DIAL_NOFORWARDHTML)
               && ast_channel_sendhtml(in, f->subclass.integer, f->data.ptr, f->datalen) == -1) {
               ast_log(LOG_WARNING, "Unable to send URL\n");
            }
            break;
         default:
            break;
         }
         ast_frfree(f);
      } /* end for */
      if (winner == in) {
         struct ast_frame *f = ast_read(in);
#if 0
         if (f && (f->frametype != AST_FRAME_VOICE))
            printf("Frame type: %d, %d\n", f->frametype, f->subclass);
         else if (!f || (f->frametype != AST_FRAME_VOICE))
            printf("Hangup received on %s\n", in->name);
#endif
         if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass.integer == AST_CONTROL_HANGUP))) {
            /* Got hung up */
            *to = -1;
            strcpy(pa->status, "CANCEL");
            publish_dial_end_event(in, out_chans, NULL, pa->status);
            if (f) {
               if (f->data.uint32) {
                  ast_channel_hangupcause_set(in, f->data.uint32);
               }
               ast_frfree(f);
            }
            if (is_cc_recall) {
               ast_cc_completed(in, "CC completed, although the caller hung up (cancelled)");
            }
            SCOPE_EXIT_RTN_VALUE(NULL, "%s: Caller hung up\n", ast_channel_name(in));
         }

         /* now f is guaranteed non-NULL */
         
         if (f->frametype == AST_FRAME_DTMF) {
            if (ast_test_flag64(peerflags, OPT_DTMF_EXIT)) {
               const char *context;
               ast_channel_lock(in);
               context = pbx_builtin_getvar_helper(in, "EXITCONTEXT");
               if (onedigit_goto(in, context, (char) f->subclass.integer, 1)) {
                  ast_verb(3, "User hit %c to disconnect call.\n", f->subclass.integer);
                  *to = 0;
                  *result = f->subclass.integer;
                  strcpy(pa->status, "CANCEL");
                  publish_dial_end_event(in, out_chans, NULL, pa->status);
                  ast_frfree(f);
                  ast_channel_unlock(in);
                  if (is_cc_recall) {
                     ast_cc_completed(in, "CC completed, but the caller used DTMF to exit");
                  }
                  SCOPE_EXIT_RTN_VALUE(NULL, "%s: Caller pressed %c to end call\n",
                     ast_channel_name(in), f->subclass.integer);
               }
               ast_channel_unlock(in);
            }

            if (ast_test_flag64(peerflags, OPT_CALLER_HANGUP) &&
               detect_disconnect(in, f->subclass.integer, &featurecode)) {
               ast_verb(3, "User requested call disconnect.\n");
               *to = 0;
               strcpy(pa->status, "CANCEL");
               publish_dial_end_event(in, out_chans, NULL, pa->status);
               ast_frfree(f);
               if (is_cc_recall) {
                  ast_cc_completed(in, "CC completed, but the caller hung up with DTMF");
               }
               SCOPE_EXIT_RTN_VALUE(NULL, "%s: Caller requested disconnect\n",
                  ast_channel_name(in));
            }
         }

         /* Send the frame from the in channel to all outgoing channels. */
         AST_LIST_TRAVERSE(out_chans, o, node) {
            if (!o->chan || !ast_test_flag64(o, DIAL_STILLGOING)) {
               /* This outgoing channel has died so don't send the frame to it. */
               continue;
            }
            if (ast_check_hangup_locked(o->chan)) {
               ast_log(LOG_WARNING, "!!! Should be dead, but we're not?\n");
               continue;
            }
            switch (f->frametype) {
            case AST_FRAME_HTML:
               /* Forward HTML stuff */
               if (!ast_test_flag64(o, DIAL_NOFORWARDHTML)
                  && ast_channel_sendhtml(o->chan, f->subclass.integer, f->data.ptr, f->datalen) == -1) {
                  ast_log(LOG_WARNING, "Unable to send URL\n");
               }
               break;
            case AST_FRAME_VIDEO:
            case AST_FRAME_VOICE:
            case AST_FRAME_IMAGE:
               if (!single || caller_entertained) {
                  /*
                   * We are calling multiple parties or caller is being
                   * entertained and has thus not been made compatible.
                   * No need to check any other called parties.
                   */
                  goto skip_frame;
               }
               /* Fall through */
            case AST_FRAME_TEXT:
            case AST_FRAME_DTMF_BEGIN:
            case AST_FRAME_DTMF_END:
               if (ast_write(o->chan, f)) {
                  ast_log(LOG_WARNING, "Unable to forward frametype: %u\n",
                     f->frametype);
               }
               break;
            case AST_FRAME_CONTROL:
               switch (f->subclass.integer) {
               case AST_CONTROL_HOLD:
                  ast_verb(3, "Call on %s placed on hold\n", ast_channel_name(o->chan));
                  ast_indicate_data(o->chan, AST_CONTROL_HOLD, f->data.ptr, f->datalen);
                  break;
               case AST_CONTROL_UNHOLD:
                  ast_verb(3, "Call on %s left from hold\n", ast_channel_name(o->chan));
                  ast_indicate(o->chan, AST_CONTROL_UNHOLD);
                  break;
               case AST_CONTROL_VIDUPDATE:
               case AST_CONTROL_SRCUPDATE:
               case AST_CONTROL_SRCCHANGE:
                  if (!single || caller_entertained) {
                     /*
                      * We are calling multiple parties or caller is being
                      * entertained and has thus not been made compatible.
                      * No need to check any other called parties.
                      */
                     goto skip_frame;
                  }
                  ast_verb(3, "%s requested media update control %d, passing it to %s\n",
                     ast_channel_name(in), f->subclass.integer, ast_channel_name(o->chan));
                  ast_indicate(o->chan, f->subclass.integer);
                  break;
               case AST_CONTROL_CONNECTED_LINE:
                  if (ast_test_flag64(o, OPT_IGNORE_CONNECTEDLINE)) {
                     ast_verb(3, "Connected line update to %s prevented.\n", ast_channel_name(o->chan));
                     break;
                  }
                  if (ast_channel_connected_line_sub(in, o->chan, f, 1) &&
                     ast_channel_connected_line_macro(in, o->chan, f, 0, 1)) {
                     ast_indicate_data(o->chan, f->subclass.integer, f->data.ptr, f->datalen);
                  }
                  break;
               case AST_CONTROL_REDIRECTING:
                  if (ast_test_flag64(o, OPT_IGNORE_CONNECTEDLINE)) {
                     ast_verb(3, "Redirecting update to %s prevented.\n", ast_channel_name(o->chan));
                     break;
                  }
                  if (ast_channel_redirecting_sub(in, o->chan, f, 1) &&
                     ast_channel_redirecting_macro(in, o->chan, f, 0, 1)) {
                     ast_indicate_data(o->chan, f->subclass.integer, f->data.ptr, f->datalen);
                  }
                  break;
               default:
                  /* We are not going to do anything with this frame. */
                  goto skip_frame;
               }
               break;
            default:
               /* We are not going to do anything with this frame. */
               goto skip_frame;
            }
         }
skip_frame:;
         ast_frfree(f);
      }
   }

   if (!*to || ast_check_hangup(in)) {
      ast_verb(3, "Nobody picked up in %d ms\n", orig);
      publish_dial_end_event(in, out_chans, NULL, "NOANSWER");
   }

   if (is_cc_recall) {
      ast_cc_completed(in, "Recall completed!");
   }
   SCOPE_EXIT_RTN_VALUE(peer, "%s: %s%s\n", ast_channel_name(in),
      peer ? "Answered by " : "No answer", peer ? ast_channel_name(peer) : "");
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Dialing Application" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "ccss", }

static

Definition at line 3567 of file app_dial.c.

app

const char app[] = "Dial"

static

Definition at line 663 of file app_dial.c.

Referenced by load_module(), and unload_module().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 3567 of file app_dial.c.

dial_exec_options

const struct ast_app_option dial_exec_options[128] = { [ 'A' ] = { .flag = OPT_ANNOUNCE , .arg_index = OPT_ARG_ANNOUNCE + 1 }, [ 'a' ] = { .flag = (1LLU << 40) }, [ 'b' ] = { .flag = (1LLU << 41) , .arg_index = OPT_ARG_PREDIAL_CALLEE + 1 }, [ 'B' ] = { .flag = (1LLU << 42) , .arg_index = OPT_ARG_PREDIAL_CALLER + 1 }, [ 'C' ] = { .flag = OPT_RESETCDR }, [ 'c' ] = { .flag = (1LLU << 34) }, [ 'd' ] = { .flag = OPT_DTMF_EXIT }, [ 'D' ] = { .flag = OPT_SENDDTMF , .arg_index = OPT_ARG_SENDDTMF + 1 }, [ 'e' ] = { .flag = (1LLU << 35) }, [ 'f' ] = { .flag = OPT_FORCECLID , .arg_index = OPT_ARG_FORCECLID + 1 }, [ 'F' ] = { .flag = (1LLU << 36) , .arg_index = OPT_ARG_CALLEE_GO_ON + 1 }, [ 'g' ] = { .flag = OPT_GO_ON }, [ 'G' ] = { .flag = OPT_GOTO , .arg_index = OPT_ARG_GOTO + 1 }, [ 'h' ] = { .flag = OPT_CALLEE_HANGUP }, [ 'H' ] = { .flag = OPT_CALLER_HANGUP }, [ 'i' ] = { .flag = OPT_IGNORE_FORWARDING }, [ 'I' ] = { .flag = OPT_IGNORE_CONNECTEDLINE }, [ 'k' ] = { .flag = OPT_CALLEE_PARK }, [ 'K' ] = { .flag = OPT_CALLER_PARK }, [ 'L' ] = { .flag = OPT_DURATION_LIMIT , .arg_index = OPT_ARG_DURATION_LIMIT + 1 }, [ 'm' ] = { .flag = OPT_MUSICBACK , .arg_index = OPT_ARG_MUSICBACK + 1 }, [ 'M' ] = { .flag = OPT_CALLEE_MACRO , .arg_index = OPT_ARG_CALLEE_MACRO + 1 }, [ 'n' ] = { .flag = OPT_SCREEN_NOINTRO , .arg_index = OPT_ARG_SCREEN_NOINTRO + 1 }, [ 'N' ] = { .flag = OPT_SCREEN_NOCALLERID }, [ 'o' ] = { .flag = OPT_ORIGINAL_CLID , .arg_index = OPT_ARG_ORIGINAL_CLID + 1 }, [ 'O' ] = { .flag = OPT_OPERMODE , .arg_index = OPT_ARG_OPERMODE + 1 }, [ 'p' ] = { .flag = OPT_SCREENING }, [ 'P' ] = { .flag = OPT_PRIVACY , .arg_index = OPT_ARG_PRIVACY + 1 }, [ 'Q' ] = { .flag = (1LLU << 44) , .arg_index = OPT_ARG_HANGUPCAUSE + 1 }, [ 'r' ] = { .flag = OPT_RINGBACK , .arg_index = OPT_ARG_RINGBACK + 1 }, [ 'R' ] = { .flag = (1LLU << 43) }, [ 'S' ] = { .flag = OPT_DURATION_STOP , .arg_index = OPT_ARG_DURATION_STOP + 1 }, [ 's' ] = { .flag = (1LLU << 38) , .arg_index = OPT_ARG_FORCE_CID_TAG + 1 }, [ 't' ] = { .flag = OPT_CALLEE_TRANSFER }, [ 'T' ] = { .flag = OPT_CALLER_TRANSFER }, [ 'u' ] = { .flag = (1LLU << 39) , .arg_index = OPT_ARG_FORCE_CID_PRES + 1 }, [ 'U' ] = { .flag = OPT_CALLEE_GOSUB , .arg_index = OPT_ARG_CALLEE_GOSUB + 1 }, [ 'w' ] = { .flag = OPT_CALLEE_MONITOR }, [ 'W' ] = { .flag = OPT_CALLER_MONITOR }, [ 'x' ] = { .flag = OPT_CALLEE_MIXMONITOR }, [ 'X' ] = { .flag = OPT_CALLER_MIXMONITOR }, [ 'z' ] = { .flag = (1LLU << 37) }, }

static

Definition at line 784 of file app_dial.c.

Referenced by dial_exec_full().

rapp

const char rapp[] = "RetryDial"

static

Definition at line 664 of file app_dial.c.

Referenced by load_module(), retrydial_exec(), and unload_module().