dial.c File Reference

Dialing API. More...

#include "asterisk.h"
#include <sys/time.h>
#include <signal.h>
#include "asterisk/channel.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/linkedlists.h"
#include "asterisk/dial.h"
#include "asterisk/pbx.h"
#include "asterisk/musiconhold.h"
#include "asterisk/app.h"
#include "asterisk/causes.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/max_forwards.h"

Include dependency graph for dial.c:

Go to the source code of this file.

Data Structures
struct	answer_exec_struct
	Structure for 'ANSWER_EXEC' option. More...
struct	ast_dial
	Main dialing structure. Contains global options, channels being dialed, and more! More...
struct	ast_dial_channel
	Dialing channel structure. Contains per-channel dialing options, asterisk channel, and more! More...
struct	ast_option_types

Macros
#define	AST_MAX_WATCHERS   256
	Maximum number of channels we can watch at a time.
#define	FIND_RELATIVE_OPTION(dial, dial_channel, ast_dial_option)   (dial_channel->options[ast_dial_option] ? dial_channel->options[ast_dial_option] : dial->options[ast_dial_option])
	Macro for finding the option structure to use on a dialed channel.
#define	IS_CALLER(chan, owner)   (chan == owner ? 1 : 0)
	Macro that determines whether a channel is the caller or not.

Typedefs
typedef int(*	ast_dial_option_cb_disable) (void *data)
	Typedef for dial option disable.
typedef void *(*	ast_dial_option_cb_enable) (void *data)
	Typedef for dial option enable.

Functions
static int	answer_exec_disable (void *data)
	Disable function for 'ANSWER_EXEC' option.
static void *	answer_exec_enable (void *data)
	Enable function for 'ANSWER_EXEC' option.
static void	answer_exec_run (struct ast_dial *dial, struct ast_dial_channel *dial_channel, char *app, char *args)
	Application execution function for 'ANSWER_EXEC' option.
struct ast_channel *	ast_dial_answered (struct ast_dial *dial)
	Return channel that answered.
struct ast_channel *	ast_dial_answered_steal (struct ast_dial *dial)
	Steal the channel that answered.
int	ast_dial_append (struct ast_dial *dial, const char *tech, const char *device, const struct ast_assigned_ids *assignedids)
	Append a channel.
int	ast_dial_append_channel (struct ast_dial *dial, struct ast_channel *chan)
	Append a channel using an actual channel object.
struct ast_dial *	ast_dial_create (void)
	New dialing structure.
int	ast_dial_destroy (struct ast_dial *dial)
	Destroys a dialing structure.
struct ast_channel *	ast_dial_get_channel (struct ast_dial *dial, int num)
	Get the dialing channel, if prerun has been executed.
void *	ast_dial_get_user_data (struct ast_dial *dial)
	Return the user data on a dial structure.
void	ast_dial_hangup (struct ast_dial *dial)
	Hangup channels.
enum ast_dial_result	ast_dial_join (struct ast_dial *dial)
	Cancel async thread.
int	ast_dial_option_disable (struct ast_dial *dial, int num, enum ast_dial_option option)
	Disables an option per channel.
int	ast_dial_option_enable (struct ast_dial *dial, int num, enum ast_dial_option option, void *data)
	Enables an option per channel.
int	ast_dial_option_global_disable (struct ast_dial *dial, enum ast_dial_option option)
	Disables an option globally.
int	ast_dial_option_global_enable (struct ast_dial *dial, enum ast_dial_option option, void *data)
	Enables an option globally.
int	ast_dial_prerun (struct ast_dial *dial, struct ast_channel *chan, struct ast_format_cap *cap)
	Request all appended channels, but do not dial.
int	ast_dial_reason (struct ast_dial *dial, int num)
	Get the reason an outgoing channel has failed.
enum ast_dial_result	ast_dial_run (struct ast_dial *dial, struct ast_channel *chan, int async)
	Execute dialing synchronously or asynchronously.
void	ast_dial_set_global_timeout (struct ast_dial *dial, int timeout)
	Set the maximum time (globally) allowed for trying to ring phones.
void	ast_dial_set_state_callback (struct ast_dial *dial, ast_dial_state_callback callback)
	Set a callback for state changes.
void	ast_dial_set_timeout (struct ast_dial *dial, int num, int timeout)
	Set the maximum time (per channel) allowed for trying to ring the phone.
void	ast_dial_set_user_data (struct ast_dial *dial, void *user_data)
	Set user data on a dial structure.
enum ast_dial_result	ast_dial_state (struct ast_dial *dial)
	Return state of dial.
const char *	ast_hangup_cause_to_dial_status (int hangup_cause)
	Convert a hangup cause to a publishable dial status.
static void *	async_dial (void *data)
	Dial async thread function.
static int	begin_dial (struct ast_dial *dial, struct ast_channel *chan, int async)
	Helper function that does the beginning dialing per dial structure.
static int	begin_dial_channel (struct ast_dial_channel *channel, struct ast_channel *chan, int async, const char *predial_string, struct ast_channel *forwarder_chan)
	Helper function that does the beginning dialing per-appended channel.
static int	begin_dial_prerun (struct ast_dial_channel *channel, struct ast_channel *chan, struct ast_format_cap *cap, const char *predial_string)
	Helper function that requests all channels.
static int	dial_append_common (struct ast_dial *dial, struct ast_dial_channel *channel, const char *tech, const char *device, const struct ast_assigned_ids *assignedids)
static struct ast_dial_channel *	find_dial_channel (struct ast_dial *dial, int num)
	Helper function for finding a channel in a dial structure based on number.
static struct ast_dial_channel *	find_relative_dial_channel (struct ast_dial *dial, struct ast_channel *owner)
	Helper function that finds the dialed channel based on owner.
static int	handle_call_forward (struct ast_dial *dial, struct ast_dial_channel *channel, struct ast_channel *chan)
	Helper function to handle channels that have been call forwarded.
static void	handle_frame (struct ast_dial *dial, struct ast_dial_channel *channel, struct ast_frame *fr, struct ast_channel *chan)
	Helper function that handles frames.
static int	handle_timeout_trip (struct ast_dial *dial, struct timeval start)
	Helper function to handle when a timeout occurs on dialing attempt.
static enum ast_dial_result	monitor_dial (struct ast_dial *dial, struct ast_channel *chan)
	Helper function that basically keeps tabs on dialing attempts.
static int	music_disable (void *data)
static void *	music_enable (void *data)
static int	predial_disable (void *data)
static void *	predial_enable (void *data)
static void	set_state (struct ast_dial *dial, enum ast_dial_result state)

Variables
static const struct ast_option_types	option_types []
	Map options to respective handlers (enable/disable).

Detailed Description

Dialing API.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file dial.c.

Macro Definition Documentation

AST_MAX_WATCHERS

#define AST_MAX_WATCHERS   256

Maximum number of channels we can watch at a time.

Definition at line 211 of file dial.c.

FIND_RELATIVE_OPTION

#define FIND_RELATIVE_OPTION	(		dial,
			dial_channel,
			ast_dial_option
	)		(dial_channel->options[ast_dial_option] ? dial_channel->options[ast_dial_option] : dial->options[ast_dial_option])

Macro for finding the option structure to use on a dialed channel.

Definition at line 214 of file dial.c.

IS_CALLER

#define IS_CALLER	(		chan,
			owner
	)		(chan == owner ? 1 : 0)

Macro that determines whether a channel is the caller or not.

Definition at line 217 of file dial.c.

Typedef Documentation

ast_dial_option_cb_disable

typedef int(* ast_dial_option_cb_disable) (void *data)

Typedef for dial option disable.

Definition at line 81 of file dial.c.

ast_dial_option_cb_enable

typedef void *(* ast_dial_option_cb_enable) (void *data)

Typedef for dial option enable.

Definition at line 78 of file dial.c.

Function Documentation

answer_exec_disable()

static int answer_exec_disable ( void *  data )

static

Disable function for 'ANSWER_EXEC' option.

Definition at line 116 of file dial.c.

{
    struct answer_exec_struct *answer_exec = data;
 
    /* Make sure we have a value */
    if (!answer_exec)
        return -1;
 
    /* If arguments are present, free them too */
    if (answer_exec->args)
        ast_free(answer_exec->args);
 
    /* This is simple - just free the structure */
    ast_free(answer_exec);
 
    return 0;
}

References answer_exec_struct::args, and ast_free.

answer_exec_enable()

static void * answer_exec_enable ( void *  data )

static

Enable function for 'ANSWER_EXEC' option.

Definition at line 90 of file dial.c.

{
    struct answer_exec_struct *answer_exec = NULL;
    char *app = ast_strdupa((char*)data), *args = NULL;
 
    /* Not giving any data to this option is bad, mmmk? */
    if (ast_strlen_zero(app))
        return NULL;
 
    /* Create new data structure */
    if (!(answer_exec = ast_calloc(1, sizeof(*answer_exec))))
        return NULL;
 
    /* Parse out application and arguments */
    if ((args = strchr(app, ','))) {
        *args++ = '\0';
        answer_exec->args = ast_strdup(args);
    }
 
    /* Copy application name */
    ast_copy_string(answer_exec->app, app, sizeof(answer_exec->app));
 
    return answer_exec;
}

References app, answer_exec_struct::app, answer_exec_struct::args, args, ast_calloc, ast_copy_string(), ast_strdup, ast_strdupa, ast_strlen_zero(), and NULL.

answer_exec_run()

static void answer_exec_run ( struct ast_dial *  dial, struct ast_dial_channel *  dial_channel, char *  app, char *  args  )

static

Application execution function for 'ANSWER_EXEC' option.

Definition at line 166 of file dial.c.

{
    struct ast_channel *chan = dial_channel->owner;
 
    /* Execute the application, if available */
    if (ast_pbx_exec_application(chan, app, args)) {
        /* If the application was not found, return immediately */
        return;
    }
 
    /* If another thread is not taking over hang up the channel */
    ast_mutex_lock(&dial->lock);
    if (dial->thread != AST_PTHREADT_STOP) {
        ast_hangup(chan);
        dial_channel->owner = NULL;
    }
    ast_mutex_unlock(&dial->lock);
 
    return;
}

References app, args, ast_hangup(), ast_mutex_lock, ast_mutex_unlock, ast_pbx_exec_application(), AST_PTHREADT_STOP, ast_dial::lock, NULL, ast_dial_channel::owner, and ast_dial::thread.

Referenced by monitor_dial().

ast_dial_answered()

struct ast_channel * ast_dial_answered

(

struct ast_dial *

dial

)

Return channel that answered.

Note

Returns the Asterisk channel that answered

Parameters

dial	Dialing structure

Definition at line 980 of file dial.c.

{
    if (!dial)
        return NULL;
 
    return ((dial->state == AST_DIAL_RESULT_ANSWERED) ? AST_LIST_FIRST(&dial->channels)->owner : NULL);
}

References AST_DIAL_RESULT_ANSWERED, AST_LIST_FIRST, ast_dial::channels, NULL, and ast_dial::state.

Referenced by ari_originate_dial(), dial_trunk(), page_state_callback(), and sla_handle_dial_state_event().

ast_dial_answered_steal()

struct ast_channel * ast_dial_answered_steal

(

struct ast_dial *

dial

)

Steal the channel that answered.

Note

Returns the Asterisk channel that answered and removes it from the dialing structure

Parameters

dial	Dialing structure

Definition at line 992 of file dial.c.

{
    struct ast_channel *chan = NULL;
 
    if (!dial)
        return NULL;
 
    if (dial->state == AST_DIAL_RESULT_ANSWERED) {
        chan = AST_LIST_FIRST(&dial->channels)->owner;
        AST_LIST_FIRST(&dial->channels)->owner = NULL;
    }
 
    return chan;
}

References AST_DIAL_RESULT_ANSWERED, AST_LIST_FIRST, ast_dial::channels, NULL, and ast_dial::state.

Referenced by ari_originate_dial(), do_notify(), pbx_outgoing_exec(), and recall_callback().

ast_dial_append()

int ast_dial_append	(	struct ast_dial *	dial,
		const char *	tech,
		const char *	device,
		const struct ast_assigned_ids *	assignedids
	)

Append a channel.

Note

Appends a channel to a dialing structure

Returns

Returns channel reference number on success, -1 on failure

Definition at line 280 of file dial.c.

{
    struct ast_dial_channel *channel = NULL;
 
    /* Make sure we have required arguments */
    if (!dial || !tech || !device)
        return -1;
 
    /* Allocate new memory for dialed channel structure */
    if (!(channel = ast_calloc(1, sizeof(*channel))))
        return -1;
 
    return dial_append_common(dial, channel, tech, device, assignedids);
}

References ast_calloc, ast_dial_channel::device, dial_append_common(), NULL, and ast_dial_channel::tech.

Referenced by ari_channels_handle_originate_with_id(), dial_trunk(), do_notify(), page_exec(), pbx_outgoing_attempt(), recalling_enter(), and sla_ring_station().

ast_dial_append_channel()

int ast_dial_append_channel	(	struct ast_dial *	dial,
		struct ast_channel *	chan
	)

Append a channel using an actual channel object.

Parameters

dial	The ast_dial to add the channel to
chan	The channel to add to the dial

Return values

-1	Failure
non-zero	The position of the channel in the list of dialed channels

Note

The chan ref is stolen with a successful return.

Definition at line 295 of file dial.c.

{
    struct ast_dial_channel *channel;
    char *tech;
    char *device;
    char *dash;
 
    if (!dial || !chan) {
        return -1;
    }
 
    channel = ast_calloc(1, sizeof(*channel));
    if (!channel) {
        return -1;
    }
    channel->owner = chan;
 
    tech = ast_strdupa(ast_channel_name(chan));
 
    device = strchr(tech, '/');
    if (!device) {
        ast_free(channel);
        return -1;
    }
    *device++ = '\0';
 
    dash = strrchr(device, '-');
    if (dash) {
        *dash = '\0';
    }
 
    return dial_append_common(dial, channel, tech, device, NULL);
}

References ast_calloc, ast_channel_name(), ast_free, ast_strdupa, ast_dial_channel::device, dial_append_common(), NULL, ast_dial_channel::owner, and ast_dial_channel::tech.

ast_dial_create()

struct ast_dial * ast_dial_create

(

void

)

New dialing structure.

Note

Create a dialing structure

Returns

Returns a calloc'd ast_dial structure, NULL on failure

Definition at line 223 of file dial.c.

{
    struct ast_dial *dial = NULL;
 
    /* Allocate new memory for structure */
    if (!(dial = ast_calloc(1, sizeof(*dial))))
        return NULL;
 
    /* Initialize list of channels */
    AST_LIST_HEAD_INIT(&dial->channels);
 
    /* Initialize thread to NULL */
    dial->thread = AST_PTHREADT_NULL;
 
    /* No timeout exists... yet */
    dial->timeout = -1;
    dial->actual_timeout = -1;
 
    /* Can't forget about the lock */
    ast_mutex_init(&dial->lock);
 
    return dial;
}

References ast_dial::actual_timeout, ast_calloc, AST_LIST_HEAD_INIT, ast_mutex_init, AST_PTHREADT_NULL, ast_dial::channels, ast_dial::lock, NULL, ast_dial::thread, and ast_dial::timeout.

Referenced by ari_channels_handle_originate_with_id(), dial_trunk(), do_notify(), page_exec(), pbx_outgoing_attempt(), recalling_enter(), and sla_ring_station().

ast_dial_destroy()

int ast_dial_destroy

(

struct ast_dial *

dial

)

Destroys a dialing structure.

Note

Cancels dialing and destroys (free's) the given ast_dial structure

Parameters

dial	Dialing structure to free

Return values

0	on success
-1	on failure

Definition at line 1094 of file dial.c.

{
    int i = 0;
    struct ast_dial_channel *channel = NULL;
 
    if (!dial)
        return -1;
 
    /* Hangup and deallocate all the dialed channels */
    AST_LIST_LOCK(&dial->channels);
    AST_LIST_TRAVERSE_SAFE_BEGIN(&dial->channels, channel, list) {
        /* Disable any enabled options */
        for (i = 0; i < AST_DIAL_OPTION_MAX; i++) {
            if (!channel->options[i])
                continue;
            if (option_types[i].disable)
                option_types[i].disable(channel->options[i]);
            channel->options[i] = NULL;
        }
 
        /* Hang up channel if need be */
        ast_hangup(channel->owner);
        channel->owner = NULL;
 
        /* Free structure */
        ast_free(channel->tech);
        ast_free(channel->device);
        ast_free(channel->assignedid1);
        ast_free(channel->assignedid2);
 
        AST_LIST_REMOVE_CURRENT(list);
        ast_free(channel);
    }
    AST_LIST_TRAVERSE_SAFE_END;
    AST_LIST_UNLOCK(&dial->channels);
 
    /* Disable any enabled options globally */
    for (i = 0; i < AST_DIAL_OPTION_MAX; i++) {
        if (!dial->options[i])
            continue;
        if (option_types[i].disable)
            option_types[i].disable(dial->options[i]);
        dial->options[i] = NULL;
    }
 
    /* Lock be gone! */
    ast_mutex_destroy(&dial->lock);
 
    /* Free structure */
    ast_free(dial);
 
    return 0;
}

References ast_dial_channel::assignedid1, ast_dial_channel::assignedid2, AST_DIAL_OPTION_MAX, ast_free, ast_hangup(), AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_mutex_destroy, ast_dial::channels, ast_dial_channel::device, ast_option_types::disable, ast_dial_channel::list, ast_dial::lock, NULL, option_types, ast_dial::options, ast_dial_channel::options, ast_dial_channel::owner, and ast_dial_channel::tech.

Referenced by ari_channels_handle_originate_with_id(), ari_originate_dial(), dial_trunk(), do_notify(), monitor_dial(), page_exec(), pbx_outgoing_destroy(), recalling_exit(), run_station(), sla_handle_dial_state_event(), sla_hangup_stations(), sla_ring_station(), and sla_stop_ringing_station().

ast_dial_get_channel()

struct ast_channel * ast_dial_get_channel	(	struct ast_dial *	dial,
		int	num
	)

Get the dialing channel, if prerun has been executed.

Parameters

dial	Dial structure
num	Channel number to get channel of

Returns

Pointer to channel, without reference

Definition at line 1261 of file dial.c.

{
    struct ast_dial_channel *channel;
 
    if (!dial || AST_LIST_EMPTY(&dial->channels) || !(channel = find_dial_channel(dial, num))) {
        return NULL;
    }
 
    return channel->owner;
}

References AST_LIST_EMPTY, ast_dial::channels, find_dial_channel(), NULL, ast_dial_channel::num, and ast_dial_channel::owner.

Referenced by ari_channels_handle_originate_with_id(), pbx_outgoing_attempt(), pbx_outgoing_state_callback(), and recalling_enter().

ast_dial_get_user_data()

void * ast_dial_get_user_data

(

struct ast_dial *

dial

)

Return the user data on a dial structure.

Parameters

dial	The dial structure

Definition at line 1282 of file dial.c.

{
    return dial->user_data;
}

References ast_dial::user_data.

Referenced by ari_originate_dial(), page_state_callback(), and recall_callback().

ast_dial_hangup()

void ast_dial_hangup

(

struct ast_dial *

dial

)

Hangup channels.

Note

Hangup all active channels

Parameters

dial	Dialing structure

Definition at line 1077 of file dial.c.

{
    struct ast_dial_channel *channel = NULL;
 
    if (!dial)
        return;
 
    AST_LIST_LOCK(&dial->channels);
    AST_LIST_TRAVERSE(&dial->channels, channel, list) {
        ast_hangup(channel->owner);
        channel->owner = NULL;
    }
    AST_LIST_UNLOCK(&dial->channels);
 
    return;
}

References ast_hangup(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_dial::channels, ast_dial_channel::list, NULL, and ast_dial_channel::owner.

Referenced by ast_dial_run(), and page_exec().

ast_dial_join()

enum ast_dial_result ast_dial_join

(

struct ast_dial *

dial

)

Cancel async thread.

Note

Cancel a running async thread

Parameters

dial	Dialing structure

Definition at line 1020 of file dial.c.

{
    pthread_t thread;
 
    /* If the dial structure is not running in async, return failed */
    if (dial->thread == AST_PTHREADT_NULL)
        return AST_DIAL_RESULT_FAILED;
 
    /* Record thread */
    thread = dial->thread;
 
    /* Boom, commence locking */
    ast_mutex_lock(&dial->lock);
 
    /* Stop the thread */
    dial->thread = AST_PTHREADT_STOP;
 
    /* If the answered channel is running an application we have to soft hangup it, can't just poke the thread */
    AST_LIST_LOCK(&dial->channels);
    if (AST_LIST_FIRST(&dial->channels)->is_running_app) {
        struct ast_channel *chan = AST_LIST_FIRST(&dial->channels)->owner;
        if (chan) {
            ast_channel_lock(chan);
            ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
            ast_channel_unlock(chan);
        }
    } else {
        struct ast_dial_channel *channel = NULL;
 
        /* Now we signal it with SIGURG so it will break out of it's waitfor */
        pthread_kill(thread, SIGURG);
 
        /* pthread_kill may not be enough, if outgoing channel has already got an answer (no more in waitfor) but is not yet running an application. Force soft hangup. */
        AST_LIST_TRAVERSE(&dial->channels, channel, list) {
            if (channel->owner) {
                ast_softhangup(channel->owner, AST_SOFTHANGUP_EXPLICIT);
            }
        }
    }
    AST_LIST_UNLOCK(&dial->channels);
 
    /* Yay done with it */
    ast_mutex_unlock(&dial->lock);
 
    /* Finally wait for the thread to exit */
    pthread_join(thread, NULL);
 
    /* Yay thread is all gone */
    dial->thread = AST_PTHREADT_NULL;
 
    return dial->state;
}

References ast_channel_lock, ast_channel_unlock, AST_DIAL_RESULT_FAILED, AST_LIST_FIRST, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, AST_PTHREADT_STOP, ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_dial::channels, ast_dial_channel::list, ast_dial::lock, NULL, ast_dial_channel::owner, ast_dial::state, thread, and ast_dial::thread.

Referenced by dial_trunk(), page_exec(), recalling_exit(), run_station(), sla_handle_dial_state_event(), sla_hangup_stations(), sla_ring_station(), and sla_stop_ringing_station().

ast_dial_option_disable()

int ast_dial_option_disable	(	struct ast_dial *	dial,
		int	num,
		enum ast_dial_option	option
	)

Disables an option per channel.

Parameters

dial	Dial structure
num	Channel number to disable option on
option	Option to disable

Return values

0	on success
-1	on failure

Definition at line 1225 of file dial.c.

{
    struct ast_dial_channel *channel = NULL;
 
    /* Ensure we have required arguments */
    if (!dial || AST_LIST_EMPTY(&dial->channels))
        return -1;
 
    if (!(channel = find_dial_channel(dial, num)))
        return -1;
 
    /* If the option is not enabled, return failure */
    if (!channel->options[option])
        return -1;
 
    /* Execute callback of option to disable it if it exists */
    if (option_types[option].disable)
        option_types[option].disable(channel->options[option]);
 
    /* Finally disable the option on the structure */
    channel->options[option] = NULL;
 
    return 0;
}

References AST_LIST_EMPTY, ast_dial::channels, ast_option_types::disable, find_dial_channel(), NULL, ast_dial_channel::num, option_types, and ast_dial_channel::options.

ast_dial_option_enable()

int ast_dial_option_enable	(	struct ast_dial *	dial,
		int	num,
		enum ast_dial_option	option,
		void *	data
	)

Enables an option per channel.

Parameters

dial	Dial structure
num	Channel number to enable option on
option	Option to enable
data	Data to pass to this option (not always needed)

Return values

0	on success
-1	on failure

Definition at line 1184 of file dial.c.

{
    struct ast_dial_channel *channel = NULL;
 
    /* Ensure we have required arguments */
    if (!dial || AST_LIST_EMPTY(&dial->channels))
        return -1;
 
    if (!(channel = find_dial_channel(dial, num)))
        return -1;
 
    /* If the option is already enabled, return failure */
    if (channel->options[option])
        return -1;
 
    /* Execute enable callback if it exists, if not simply make sure the value is set */
    if (option_types[option].enable)
        channel->options[option] = option_types[option].enable(data);
    else
        channel->options[option] = (void*)1;
 
    return 0;
}

References AST_LIST_EMPTY, ast_dial::channels, ast_option_types::enable, find_dial_channel(), NULL, ast_dial_channel::num, option_types, and ast_dial_channel::options.

ast_dial_option_global_disable()

int ast_dial_option_global_disable	(	struct ast_dial *	dial,
		enum ast_dial_option	option
	)

Disables an option globally.

Parameters

dial	Dial structure to disable option on
option	Option to disable

Return values

0	on success
-1	on failure

Definition at line 1208 of file dial.c.

{
    /* If the option is not enabled, return failure */
    if (!dial->options[option]) {
        return -1;
    }
 
    /* Execute callback of option to disable if it exists */
    if (option_types[option].disable)
        option_types[option].disable(dial->options[option]);
 
    /* Finally disable option on the structure */
    dial->options[option] = NULL;
 
    return 0;
}

References ast_option_types::disable, NULL, option_types, and ast_dial::options.

ast_dial_option_global_enable()

int ast_dial_option_global_enable	(	struct ast_dial *	dial,
		enum ast_dial_option	option,
		void *	data
	)

Enables an option globally.

Parameters

dial	Dial structure to enable option on
option	Option to enable
data	Data to pass to this option (not always needed)

Return values

0	on success
-1	on failure

Definition at line 1148 of file dial.c.

{
    /* If the option is already enabled, return failure */
    if (dial->options[option])
        return -1;
 
    /* Execute enable callback if it exists, if not simply make sure the value is set */
    if (option_types[option].enable)
        dial->options[option] = option_types[option].enable(data);
    else
        dial->options[option] = (void*)1;
 
    return 0;
}

References ast_option_types::enable, option_types, and ast_dial::options.

Referenced by do_notify(), page_exec(), and pbx_outgoing_attempt().

ast_dial_prerun()

int ast_dial_prerun	(	struct ast_dial *	dial,
		struct ast_channel *	chan,
		struct ast_format_cap *	cap
	)

Request all appended channels, but do not dial.

Parameters

dial	Dialing structure
chan	Optional dialing channel
cap	Optional requested capabilities

Return values

-1	failure
0	success

Definition at line 431 of file dial.c.

{
    struct ast_dial_channel *channel;
    int res = -1;
    char *predial_string = dial->options[AST_DIAL_OPTION_PREDIAL];
 
    AST_LIST_LOCK(&dial->channels);
    AST_LIST_TRAVERSE(&dial->channels, channel, list) {
        if ((res = begin_dial_prerun(channel, chan, cap, predial_string))) {
            break;
        }
    }
    AST_LIST_UNLOCK(&dial->channels);
 
    return res;
}

References AST_DIAL_OPTION_PREDIAL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, begin_dial_prerun(), ast_dial::channels, ast_dial_channel::list, and ast_dial::options.

Referenced by ari_channels_handle_originate_with_id(), pbx_outgoing_attempt(), and recalling_enter().

ast_dial_reason()

int ast_dial_reason	(	struct ast_dial *	dial,
		int	num
	)

Get the reason an outgoing channel has failed.

Parameters

dial	Dial structure
num	Channel number to get the reason from

Returns

Numerical cause code

Definition at line 1250 of file dial.c.

{
    struct ast_dial_channel *channel;
 
    if (!dial || AST_LIST_EMPTY(&dial->channels) || !(channel = find_dial_channel(dial, num))) {
        return -1;
    }
 
    return channel->cause;
}

References AST_LIST_EMPTY, ast_dial_channel::cause, ast_dial::channels, find_dial_channel(), and ast_dial_channel::num.

Referenced by pbx_outgoing_attempt().

ast_dial_run()

enum ast_dial_result ast_dial_run	(	struct ast_dial *	dial,
		struct ast_channel *	chan,
		int	async
	)

Execute dialing synchronously or asynchronously.

Note

Dials channels in a dial structure.

Returns

Returns dial result code. (TRYING/INVALID/FAILED/ANSWERED/TIMEOUT/UNANSWERED).

Definition at line 938 of file dial.c.

{
    enum ast_dial_result res = AST_DIAL_RESULT_TRYING;
 
    /* Ensure required arguments are passed */
    if (!dial) {
        ast_debug(1, "invalid #1\n");
        return AST_DIAL_RESULT_INVALID;
    }
 
    /* If there are no channels to dial we can't very well try to dial them */
    if (AST_LIST_EMPTY(&dial->channels)) {
        ast_debug(1, "invalid #2\n");
        return AST_DIAL_RESULT_INVALID;
    }
 
    /* Dial each requested channel */
    if (!begin_dial(dial, chan, async))
        return AST_DIAL_RESULT_FAILED;
 
    /* If we are running async spawn a thread and send it away... otherwise block here */
    if (async) {
        /* reference be released at dial destruction if it isn't NULL */
        dial->callid = ast_read_threadstorage_callid();
        dial->state = AST_DIAL_RESULT_TRYING;
        /* Try to create a thread */
        if (ast_pthread_create(&dial->thread, NULL, async_dial, dial)) {
            /* Failed to create the thread - hangup all dialed channels and return failed */
            ast_dial_hangup(dial);
            res = AST_DIAL_RESULT_FAILED;
        }
    } else {
        res = monitor_dial(dial, chan);
    }
 
    return res;
}

References ast_debug, ast_dial_hangup(), AST_DIAL_RESULT_FAILED, AST_DIAL_RESULT_INVALID, AST_DIAL_RESULT_TRYING, AST_LIST_EMPTY, ast_pthread_create, ast_read_threadstorage_callid(), async_dial(), begin_dial(), ast_dial::callid, ast_dial::channels, monitor_dial(), NULL, ast_dial::state, and ast_dial::thread.

Referenced by ari_originate_dial(), dial_trunk(), do_notify(), page_exec(), pbx_outgoing_exec(), recalling_enter(), and sla_ring_station().

ast_dial_set_global_timeout()

void ast_dial_set_global_timeout	(	struct ast_dial *	dial,
		int	timeout
	)

Set the maximum time (globally) allowed for trying to ring phones.

Parameters

dial	The dial structure to apply the time limit to
timeout	Maximum time allowed in milliseconds

Definition at line 1287 of file dial.c.

{
    dial->timeout = timeout;
 
    if (dial->timeout > 0 && (dial->actual_timeout > dial->timeout || dial->actual_timeout == -1))
        dial->actual_timeout = dial->timeout;
 
    return;
}

References ast_dial::actual_timeout, ast_dial::timeout, and ast_dial_channel::timeout.

Referenced by ari_channels_handle_originate_with_id(), do_notify(), page_exec(), and pbx_outgoing_attempt().

ast_dial_set_state_callback()

void ast_dial_set_state_callback	(	struct ast_dial *	dial,
		ast_dial_state_callback	callback
	)

Set a callback for state changes.

Parameters

dial	The dial structure to watch for state changes
callback	the callback

Definition at line 1272 of file dial.c.

{
    dial->state_callback = callback;
}

References callback(), and ast_dial::state_callback.

Referenced by page_exec(), pbx_outgoing_attempt(), recalling_enter(), and sla_ring_station().

ast_dial_set_timeout()

void ast_dial_set_timeout	(	struct ast_dial *	dial,
		int	num,
		int	timeout
	)

Set the maximum time (per channel) allowed for trying to ring the phone.

Parameters

dial	The dial structure the channel belongs to
num	Channel number to set timeout on
timeout	Maximum time allowed in milliseconds

Definition at line 1297 of file dial.c.

{
    struct ast_dial_channel *channel = NULL;
 
    if (!(channel = find_dial_channel(dial, num)))
        return;
 
    channel->timeout = timeout;
 
    if (channel->timeout > 0 && (dial->actual_timeout > channel->timeout || dial->actual_timeout == -1))
        dial->actual_timeout = channel->timeout;
 
    return;
}

References ast_dial::actual_timeout, find_dial_channel(), NULL, ast_dial_channel::num, and ast_dial_channel::timeout.

ast_dial_set_user_data()

void ast_dial_set_user_data	(	struct ast_dial *	dial,
		void *	user_data
	)

Set user data on a dial structure.

Parameters

dial	The dial structure to set a user data pointer on
user_data	The user data pointer

Definition at line 1277 of file dial.c.

{
    dial->user_data = user_data;
}

References ast_dial::user_data.

Referenced by ari_channels_handle_originate_with_id(), page_exec(), and recalling_enter().

ast_dial_state()

enum ast_dial_result ast_dial_state

(

struct ast_dial *

dial

)

Return state of dial.

Note

Returns the state of the dial attempt

Parameters

dial	Dialing structure

Definition at line 1011 of file dial.c.

{
    return dial->state;
}

References ast_dial::state.

Referenced by dial_trunk(), page_state_callback(), pbx_outgoing_state_callback(), recall_callback(), and sla_handle_dial_state_event().

ast_hangup_cause_to_dial_status()

const char * ast_hangup_cause_to_dial_status

(

int

hangup_cause

)

Convert a hangup cause to a publishable dial status.

Since

12

Definition at line 752 of file dial.c.

{
    switch(hangup_cause) {
    case AST_CAUSE_BUSY:
        return "BUSY";
    case AST_CAUSE_CONGESTION:
        return "CONGESTION";
    case AST_CAUSE_NO_ROUTE_DESTINATION:
    case AST_CAUSE_UNREGISTERED:
        return "CHANUNAVAIL";
    case AST_CAUSE_NO_ANSWER:
    default:
        return "NOANSWER";
    }
}

References AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, AST_CAUSE_NO_ANSWER, AST_CAUSE_NO_ROUTE_DESTINATION, and AST_CAUSE_UNREGISTERED.

Referenced by monitor_dial(), try_calling(), and wait_for_answer().

async_dial()

static void * async_dial ( void *  data )

static

Dial async thread function.

Definition at line 921 of file dial.c.

{
    struct ast_dial *dial = data;
    if (dial->callid) {
        ast_callid_threadassoc_add(dial->callid);
    }
 
    /* This is really really simple... we basically pass monitor_dial a NULL owner and it changes it's behavior */
    monitor_dial(dial, NULL);
 
    return NULL;
}

References ast_callid_threadassoc_add(), ast_dial::callid, monitor_dial(), and NULL.

Referenced by ast_dial_run().

begin_dial()

static int begin_dial ( struct ast_dial *  dial, struct ast_channel *  chan, int  async  )

static

Helper function that does the beginning dialing per dial structure.

Definition at line 481 of file dial.c.

{
    struct ast_dial_channel *channel = NULL;
    int success = 0;
    char *predial_string = dial->options[AST_DIAL_OPTION_PREDIAL];
 
    /* Iterate through channel list, requesting and calling each one */
    AST_LIST_LOCK(&dial->channels);
    AST_LIST_TRAVERSE(&dial->channels, channel, list) {
        success += begin_dial_channel(channel, chan, async, predial_string, NULL);
    }
    AST_LIST_UNLOCK(&dial->channels);
 
    /* If number of failures matches the number of channels, then this truly failed */
    return success;
}

References AST_DIAL_OPTION_PREDIAL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, begin_dial_channel(), ast_dial::channels, ast_dial_channel::list, NULL, and ast_dial::options.

Referenced by ast_dial_run().

begin_dial_channel()

static int begin_dial_channel ( struct ast_dial_channel *  channel, struct ast_channel *  chan, int  async, const char *  predial_string, struct ast_channel *  forwarder_chan  )

static

Helper function that does the beginning dialing per-appended channel.

Definition at line 449 of file dial.c.

{
    int res = 1;
    char forwarder[AST_CHANNEL_NAME];
 
    /* If no owner channel exists yet execute pre-run */
    if (!channel->owner && begin_dial_prerun(channel, chan, NULL, predial_string)) {
        return 0;
    }
 
    if (forwarder_chan) {
        ast_copy_string(forwarder, ast_channel_name(forwarder_chan), sizeof(forwarder));
        ast_channel_lock(channel->owner);
        pbx_builtin_setvar_helper(channel->owner, "FORWARDERNAME", forwarder);
        ast_channel_unlock(channel->owner);
    }
 
    /* Attempt to actually call this device */
    if ((res = ast_call(channel->owner, channel->device, 0))) {
        res = 0;
        ast_hangup(channel->owner);
        channel->owner = NULL;
    } else {
        ast_channel_publish_dial(async ? NULL : chan, channel->owner, channel->device, NULL);
        res = 1;
        ast_verb(3, "Called %s\n", channel->device);
    }
 
    return res;
}

References ast_call(), ast_channel_lock, AST_CHANNEL_NAME, ast_channel_name(), ast_channel_publish_dial(), ast_channel_unlock, ast_copy_string(), ast_hangup(), ast_verb, begin_dial_prerun(), ast_dial_channel::device, NULL, ast_dial_channel::owner, and pbx_builtin_setvar_helper().

Referenced by begin_dial(), and handle_call_forward().

begin_dial_prerun()

static int begin_dial_prerun ( struct ast_dial_channel *  channel, struct ast_channel *  chan, struct ast_format_cap *  cap, const char *  predial_string  )

static

Helper function that requests all channels.

Definition at line 330 of file dial.c.

{
    struct ast_format_cap *cap_all_audio = NULL;
    struct ast_format_cap *cap_request;
    struct ast_format_cap *requester_cap = NULL;
    struct ast_assigned_ids assignedids = {
        .uniqueid = channel->assignedid1,
        .uniqueid2 = channel->assignedid2,
    };
 
    if (chan) {
        int max_forwards;
 
        ast_channel_lock(chan);
        max_forwards = ast_max_forwards_get(chan);
        requester_cap = ao2_bump(ast_channel_nativeformats(chan));
        ast_channel_unlock(chan);
 
        if (max_forwards <= 0) {
            ast_log(LOG_WARNING, "Cannot dial from channel '%s'. Max forwards exceeded\n",
                    ast_channel_name(chan));
        }
    }
 
    if (!channel->owner) {
        if (cap && ast_format_cap_count(cap)) {
            cap_request = cap;
        } else if (requester_cap) {
            cap_request = requester_cap;
        } else {
            cap_all_audio = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
            ast_format_cap_append_by_type(cap_all_audio, AST_MEDIA_TYPE_AUDIO);
            cap_request = cap_all_audio;
        }
 
        /* If we fail to create our owner channel bail out */
        if (!(channel->owner = ast_request(channel->tech, cap_request, &assignedids, chan, channel->device, &channel->cause))) {
            ao2_cleanup(cap_all_audio);
            return -1;
        }
        cap_request = NULL;
        ao2_cleanup(requester_cap);
        ao2_cleanup(cap_all_audio);
    }
 
    if (chan) {
        ast_channel_lock_both(chan, channel->owner);
    } else {
        ast_channel_lock(channel->owner);
    }
 
    ast_channel_stage_snapshot(channel->owner);
 
    ast_channel_appl_set(channel->owner, "AppDial2");
    ast_channel_data_set(channel->owner, "(Outgoing Line)");
 
    memset(ast_channel_whentohangup(channel->owner), 0, sizeof(*ast_channel_whentohangup(channel->owner)));
 
    /* Inherit everything from he who spawned this dial */
    if (chan) {
        ast_channel_inherit_variables(chan, channel->owner);
        ast_channel_datastore_inherit(chan, channel->owner);
        ast_max_forwards_decrement(channel->owner);
 
        /* Copy over callerid information */
        ast_party_redirecting_copy(ast_channel_redirecting(channel->owner), ast_channel_redirecting(chan));
 
        ast_channel_dialed(channel->owner)->transit_network_select = ast_channel_dialed(chan)->transit_network_select;
 
        ast_connected_line_copy_from_caller(ast_channel_connected(channel->owner), ast_channel_caller(chan));
 
        ast_channel_language_set(channel->owner, ast_channel_language(chan));
        if (channel->options[AST_DIAL_OPTION_DIAL_REPLACES_SELF]) {
            ast_channel_req_accountcodes(channel->owner, chan, AST_CHANNEL_REQUESTOR_REPLACEMENT);
        } else {
            ast_channel_req_accountcodes(channel->owner, chan, AST_CHANNEL_REQUESTOR_BRIDGE_PEER);
        }
        if (ast_strlen_zero(ast_channel_musicclass(channel->owner)))
            ast_channel_musicclass_set(channel->owner, ast_channel_musicclass(chan));
 
        ast_channel_adsicpe_set(channel->owner, ast_channel_adsicpe(chan));
        ast_channel_transfercapability_set(channel->owner, ast_channel_transfercapability(chan));
        ast_channel_unlock(chan);
    }
 
    ast_channel_stage_snapshot_done(channel->owner);
    ast_channel_unlock(channel->owner);
 
    if (!ast_strlen_zero(predial_string)) {
        if (chan) {
            ast_autoservice_start(chan);
        }
        ast_pre_call(channel->owner, predial_string);
        if (chan) {
            ast_autoservice_stop(chan);
        }
    }
 
    return 0;
}

References ao2_bump, ao2_cleanup, ast_dial_channel::assignedid1, ast_dial_channel::assignedid2, ast_autoservice_start(), ast_autoservice_stop(), ast_channel_adsicpe_set(), ast_channel_appl_set(), ast_channel_caller(), ast_channel_connected(), ast_channel_data_set(), ast_channel_datastore_inherit(), ast_channel_dialed(), ast_channel_inherit_variables(), ast_channel_language(), ast_channel_lock, ast_channel_lock_both, ast_channel_musicclass(), ast_channel_name(), ast_channel_nativeformats(), ast_channel_redirecting(), ast_channel_req_accountcodes(), AST_CHANNEL_REQUESTOR_BRIDGE_PEER, AST_CHANNEL_REQUESTOR_REPLACEMENT, ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_transfercapability(), ast_channel_transfercapability_set(), ast_channel_unlock, ast_channel_whentohangup(), ast_connected_line_copy_from_caller(), AST_DIAL_OPTION_DIAL_REPLACES_SELF, ast_format_cap_alloc, ast_format_cap_append_by_type(), ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_log, ast_max_forwards_decrement(), ast_max_forwards_get(), AST_MEDIA_TYPE_AUDIO, ast_party_redirecting_copy(), ast_pre_call(), ast_request(), ast_strlen_zero(), ast_dial_channel::cause, ast_dial_channel::device, LOG_WARNING, NULL, ast_dial_channel::options, ast_dial_channel::owner, ast_dial_channel::tech, ast_party_dialed::transit_network_select, and ast_assigned_ids::uniqueid.

Referenced by ast_dial_prerun(), and begin_dial_channel().

dial_append_common()

static int dial_append_common ( struct ast_dial *  dial, struct ast_dial_channel *  channel, const char *  tech, const char *  device, const struct ast_assigned_ids *  assignedids  )

static

Definition at line 247 of file dial.c.

{
    /* Record technology and device for when we actually dial */
    channel->tech = ast_strdup(tech);
    channel->device = ast_strdup(device);
 
    /* Store the assigned id */
    if (assignedids && !ast_strlen_zero(assignedids->uniqueid)) {
        channel->assignedid1 = ast_strdup(assignedids->uniqueid);
 
        if (!ast_strlen_zero(assignedids->uniqueid2)) {
            channel->assignedid2 = ast_strdup(assignedids->uniqueid2);
        }
    }
 
    /* Grab reference number from dial structure */
    channel->num = ast_atomic_fetchadd_int(&dial->num, +1);
 
    /* No timeout exists... yet */
    channel->timeout = -1;
 
    /* Insert into channels list */
    AST_LIST_INSERT_TAIL(&dial->channels, channel, list);
 
    return channel->num;
 
}

References ast_dial_channel::assignedid1, ast_dial_channel::assignedid2, ast_atomic_fetchadd_int(), AST_LIST_INSERT_TAIL, ast_strdup, ast_strlen_zero(), ast_dial::channels, ast_dial_channel::device, ast_dial::num, ast_dial_channel::num, ast_dial_channel::tech, ast_dial_channel::timeout, ast_assigned_ids::uniqueid, and ast_assigned_ids::uniqueid2.

Referenced by ast_dial_append(), and ast_dial_append_channel().

find_dial_channel()

static struct ast_dial_channel * find_dial_channel ( struct ast_dial *  dial, int  num  )

static

Helper function for finding a channel in a dial structure based on number.

Definition at line 1165 of file dial.c.

{
    struct ast_dial_channel *channel = AST_LIST_LAST(&dial->channels);
 
    /* We can try to predict programmer behavior, the last channel they added is probably the one they wanted to modify */
    if (channel->num == num)
        return channel;
 
    /* Hrm not at the end... looking through the list it is! */
    AST_LIST_LOCK(&dial->channels);
    AST_LIST_TRAVERSE(&dial->channels, channel, list) {
        if (channel->num == num)
            break;
    }
    AST_LIST_UNLOCK(&dial->channels);
 
    return channel;
}

References AST_LIST_LAST, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_dial::channels, ast_dial_channel::list, and ast_dial_channel::num.

Referenced by ast_dial_get_channel(), ast_dial_option_disable(), ast_dial_option_enable(), ast_dial_reason(), and ast_dial_set_timeout().

find_relative_dial_channel()

static struct ast_dial_channel * find_relative_dial_channel ( struct ast_dial *  dial, struct ast_channel *  owner  )

static

Helper function that finds the dialed channel based on owner.

Definition at line 557 of file dial.c.

{
    struct ast_dial_channel *channel = NULL;
 
    AST_LIST_LOCK(&dial->channels);
    AST_LIST_TRAVERSE(&dial->channels, channel, list) {
        if (channel->owner == owner)
            break;
    }
    AST_LIST_UNLOCK(&dial->channels);
 
    return channel;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_dial::channels, ast_dial_channel::list, NULL, and ast_dial_channel::owner.

Referenced by monitor_dial().

handle_call_forward()

static int handle_call_forward ( struct ast_dial *  dial, struct ast_dial_channel *  channel, struct ast_channel *  chan  )

static

Helper function to handle channels that have been call forwarded.

Definition at line 499 of file dial.c.

{
    struct ast_channel *original = channel->owner;
    char *tmp = ast_strdupa(ast_channel_call_forward(channel->owner));
    char *tech = "Local", *device = tmp, *stuff;
    char *predial_string = dial->options[AST_DIAL_OPTION_PREDIAL];
 
    /* If call forwarding is disabled just drop the original channel and don't attempt to dial the new one */
    if (FIND_RELATIVE_OPTION(dial, channel, AST_DIAL_OPTION_DISABLE_CALL_FORWARDING)) {
        ast_hangup(original);
        channel->owner = NULL;
        return 0;
    }
 
    /* Figure out the new destination */
    if ((stuff = strchr(tmp, '/'))) {
        *stuff++ = '\0';
        tech = tmp;
        device = stuff;
    } else {
        const char *forward_context;
        char destination[AST_MAX_CONTEXT + AST_MAX_EXTENSION + 1];
 
        ast_channel_lock(original);
        forward_context = pbx_builtin_getvar_helper(original, "FORWARD_CONTEXT");
        snprintf(destination, sizeof(destination), "%s@%s", tmp, S_OR(forward_context, ast_channel_context(original)));
        ast_channel_unlock(original);
        device = ast_strdupa(destination);
    }
 
    /* Drop old destination information */
    ast_free(channel->tech);
    ast_free(channel->device);
    ast_free(channel->assignedid1);
    channel->assignedid1 = NULL;
    ast_free(channel->assignedid2);
    channel->assignedid2 = NULL;
 
    /* Update the dial channel with the new destination information */
    channel->tech = ast_strdup(tech);
    channel->device = ast_strdup(device);
    AST_LIST_UNLOCK(&dial->channels);
 
    /* Drop the original channel */
    channel->owner = NULL;
 
    /* Finally give it a go... send it out into the world */
    begin_dial_channel(channel, chan, chan ? 0 : 1, predial_string, original);
 
    ast_channel_publish_dial_forward(chan, original, channel->owner, NULL, "CANCEL",
        ast_channel_call_forward(original));
 
    ast_hangup(original);
 
    return 0;
}

References ast_dial_channel::assignedid1, ast_dial_channel::assignedid2, ast_channel_call_forward(), ast_channel_context(), ast_channel_lock, ast_channel_publish_dial_forward(), ast_channel_unlock, AST_DIAL_OPTION_DISABLE_CALL_FORWARDING, AST_DIAL_OPTION_PREDIAL, ast_free, ast_hangup(), AST_LIST_UNLOCK, AST_MAX_CONTEXT, AST_MAX_EXTENSION, ast_strdup, ast_strdupa, begin_dial_channel(), ast_dial::channels, ast_dial_channel::device, FIND_RELATIVE_OPTION, NULL, ast_dial::options, ast_dial_channel::owner, pbx_builtin_getvar_helper(), S_OR, ast_channel::tech, and ast_dial_channel::tech.

Referenced by monitor_dial().

handle_frame()

static void handle_frame ( struct ast_dial *  dial, struct ast_dial_channel *  channel, struct ast_frame *  fr, struct ast_channel *  chan  )

static

Helper function that handles frames.

Definition at line 580 of file dial.c.

{
    if (fr->frametype == AST_FRAME_CONTROL) {
        switch (fr->subclass.integer) {
        case AST_CONTROL_ANSWER:
            if (chan) {
                ast_verb(3, "%s answered %s\n", ast_channel_name(channel->owner), ast_channel_name(chan));
            } else {
                ast_verb(3, "%s answered\n", ast_channel_name(channel->owner));
            }
            AST_LIST_LOCK(&dial->channels);
            AST_LIST_REMOVE(&dial->channels, channel, list);
            AST_LIST_INSERT_HEAD(&dial->channels, channel, list);
            AST_LIST_UNLOCK(&dial->channels);
            ast_channel_publish_dial(chan, channel->owner, channel->device, "ANSWER");
            set_state(dial, AST_DIAL_RESULT_ANSWERED);
            break;
        case AST_CONTROL_BUSY:
            ast_verb(3, "%s is busy\n", ast_channel_name(channel->owner));
            ast_channel_publish_dial(chan, channel->owner, channel->device, "BUSY");
            ast_hangup(channel->owner);
            channel->cause = AST_CAUSE_USER_BUSY;
            channel->owner = NULL;
            break;
        case AST_CONTROL_CONGESTION:
            ast_verb(3, "%s is circuit-busy\n", ast_channel_name(channel->owner));
            ast_channel_publish_dial(chan, channel->owner, channel->device, "CONGESTION");
            ast_hangup(channel->owner);
            channel->cause = AST_CAUSE_NORMAL_CIRCUIT_CONGESTION;
            channel->owner = NULL;
            break;
        case AST_CONTROL_INCOMPLETE:
            ast_verb(3, "%s dialed Incomplete extension %s\n", ast_channel_name(channel->owner), ast_channel_exten(channel->owner));
            if (chan) {
                ast_indicate(chan, AST_CONTROL_INCOMPLETE);
            } else {
                ast_hangup(channel->owner);
                channel->cause = AST_CAUSE_UNALLOCATED;
                channel->owner = NULL;
            }
            break;
        case AST_CONTROL_RINGING:
            ast_verb(3, "%s is ringing\n", ast_channel_name(channel->owner));
            ast_channel_publish_dial(chan, channel->owner, channel->device, "RINGING");
            if (chan && !dial->options[AST_DIAL_OPTION_MUSIC])
                ast_indicate(chan, AST_CONTROL_RINGING);
            set_state(dial, AST_DIAL_RESULT_RINGING);
            break;
        case AST_CONTROL_PROGRESS:
            ast_channel_publish_dial(chan, channel->owner, channel->device, "PROGRESS");
            if (chan) {
                ast_verb(3, "%s is making progress, passing it to %s\n", ast_channel_name(channel->owner), ast_channel_name(chan));
                ast_indicate(chan, AST_CONTROL_PROGRESS);
            } else {
                ast_verb(3, "%s is making progress\n", ast_channel_name(channel->owner));
            }
            set_state(dial, AST_DIAL_RESULT_PROGRESS);
            break;
        case AST_CONTROL_VIDUPDATE:
            if (!chan) {
                break;
            }
            ast_verb(3, "%s requested a video update, passing it to %s\n", ast_channel_name(channel->owner), ast_channel_name(chan));
            ast_indicate(chan, AST_CONTROL_VIDUPDATE);
            break;
        case AST_CONTROL_SRCUPDATE:
            if (!chan) {
                break;
            }
            ast_verb(3, "%s requested a source update, passing it to %s\n", ast_channel_name(channel->owner), ast_channel_name(chan));
            ast_indicate(chan, AST_CONTROL_SRCUPDATE);
            break;
        case AST_CONTROL_CONNECTED_LINE:
            if (!chan) {
                break;
            }
            ast_verb(3, "%s connected line has changed, passing it to %s\n", ast_channel_name(channel->owner), ast_channel_name(chan));
            if (ast_channel_connected_line_sub(channel->owner, chan, fr, 1)) {
                ast_indicate_data(chan, AST_CONTROL_CONNECTED_LINE, fr->data.ptr, fr->datalen);
            }
            break;
        case AST_CONTROL_REDIRECTING:
            if (!chan) {
                break;
            }
            ast_verb(3, "%s redirecting info has changed, passing it to %s\n", ast_channel_name(channel->owner), ast_channel_name(chan));
            if (ast_channel_redirecting_sub(channel->owner, chan, fr, 1)) {
                ast_indicate_data(chan, AST_CONTROL_REDIRECTING, fr->data.ptr, fr->datalen);
            }
            break;
        case AST_CONTROL_PROCEEDING:
            ast_channel_publish_dial(chan, channel->owner, channel->device, "PROCEEDING");
            if (chan) {
                ast_verb(3, "%s is proceeding, passing it to %s\n", ast_channel_name(channel->owner), ast_channel_name(chan));
                ast_indicate(chan, AST_CONTROL_PROCEEDING);
            } else {
                ast_verb(3, "%s is proceeding\n", ast_channel_name(channel->owner));
            }
            set_state(dial, AST_DIAL_RESULT_PROCEEDING);
            break;
        case AST_CONTROL_HOLD:
            if (!chan) {
                break;
            }
            ast_verb(3, "Call on %s placed on hold\n", ast_channel_name(chan));
            ast_indicate_data(chan, AST_CONTROL_HOLD, fr->data.ptr, fr->datalen);
            break;
        case AST_CONTROL_UNHOLD:
            if (!chan) {
                break;
            }
            ast_verb(3, "Call on %s left from hold\n", ast_channel_name(chan));
            ast_indicate(chan, AST_CONTROL_UNHOLD);
            break;
        case AST_CONTROL_OFFHOOK:
        case AST_CONTROL_FLASH:
            break;
        case AST_CONTROL_PVT_CAUSE_CODE:
            if (chan) {
                ast_indicate_data(chan, AST_CONTROL_PVT_CAUSE_CODE, fr->data.ptr, fr->datalen);
            }
            break;
        case -1:
            if (chan) {
                /* Prod the channel */
                ast_indicate(chan, -1);
            }
            break;
        default:
            break;
        }
    }
}

References AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, AST_CAUSE_UNALLOCATED, AST_CAUSE_USER_BUSY, ast_channel_connected_line_sub(), ast_channel_exten(), ast_channel_name(), ast_channel_publish_dial(), ast_channel_redirecting_sub(), AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_FLASH, AST_CONTROL_HOLD, AST_CONTROL_INCOMPLETE, AST_CONTROL_OFFHOOK, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_REDIRECTING, AST_CONTROL_RINGING, AST_CONTROL_SRCUPDATE, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, AST_DIAL_OPTION_MUSIC, AST_DIAL_RESULT_ANSWERED, AST_DIAL_RESULT_PROCEEDING, AST_DIAL_RESULT_PROGRESS, AST_DIAL_RESULT_RINGING, AST_FRAME_CONTROL, ast_hangup(), ast_indicate(), ast_indicate_data(), AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, ast_verb, ast_dial_channel::cause, ast_dial::channels, ast_frame::data, ast_frame::datalen, ast_dial_channel::device, ast_frame::frametype, ast_frame_subclass::integer, ast_dial_channel::list, NULL, ast_dial::options, ast_dial_channel::owner, ast_frame::ptr, set_state(), and ast_frame::subclass.

Referenced by monitor_dial().

handle_timeout_trip()

static int handle_timeout_trip ( struct ast_dial *  dial, struct timeval  start  )

static

Helper function to handle when a timeout occurs on dialing attempt.

Definition at line 715 of file dial.c.

{
    struct ast_dial_channel *channel = NULL;
    int diff = ast_tvdiff_ms(ast_tvnow(), start), lowest_timeout = -1, new_timeout = -1;
 
    /* If there is no difference yet return the dial timeout so we can go again, we were likely interrupted */
    if (!diff) {
        return dial->timeout;
    }
 
    /* If the global dial timeout tripped switch the state to timeout so our channel loop will drop every channel */
    if (diff >= dial->timeout) {
        set_state(dial, AST_DIAL_RESULT_TIMEOUT);
        new_timeout = 0;
    }
 
    /* Go through dropping out channels that have met their timeout */
    AST_LIST_TRAVERSE(&dial->channels, channel, list) {
        if (dial->state == AST_DIAL_RESULT_TIMEOUT || diff >= channel->timeout) {
            ast_channel_lock(channel->owner);
            ast_channel_hangupcause_set(channel->owner, AST_CAUSE_NO_ANSWER);
            ast_channel_unlock(channel->owner);
            ast_hangup(channel->owner);
            channel->cause = AST_CAUSE_NO_ANSWER;
            channel->owner = NULL;
        } else if ((lowest_timeout == -1) || (lowest_timeout > channel->timeout)) {
            lowest_timeout = channel->timeout;
        }
    }
 
    /* Calculate the new timeout using the lowest timeout found */
    if (lowest_timeout >= 0)
        new_timeout = lowest_timeout - diff;
 
    return new_timeout;
}

References AST_CAUSE_NO_ANSWER, ast_channel_hangupcause_set(), ast_channel_lock, ast_channel_unlock, AST_DIAL_RESULT_TIMEOUT, ast_hangup(), AST_LIST_TRAVERSE, ast_tvdiff_ms(), ast_tvnow(), ast_dial_channel::cause, ast_dial::channels, ast_dial_channel::list, NULL, ast_dial_channel::owner, set_state(), ast_dial::state, ast_dial::timeout, and ast_dial_channel::timeout.

Referenced by monitor_dial().

monitor_dial()

static enum ast_dial_result monitor_dial ( struct ast_dial *  dial, struct ast_channel *  chan  )

static

Helper function that basically keeps tabs on dialing attempts.

Definition at line 769 of file dial.c.

{
    int timeout = -1;
    struct ast_channel *cs[AST_MAX_WATCHERS], *who = NULL;
    struct ast_dial_channel *channel = NULL;
    struct answer_exec_struct *answer_exec = NULL;
    struct timeval start;
 
    set_state(dial, AST_DIAL_RESULT_TRYING);
 
    /* If the "always indicate ringing" option is set, change state to ringing and indicate to the owner if present */
    if (dial->options[AST_DIAL_OPTION_RINGING]) {
        set_state(dial, AST_DIAL_RESULT_RINGING);
        if (chan)
            ast_indicate(chan, AST_CONTROL_RINGING);
    } else if (chan && dial->options[AST_DIAL_OPTION_MUSIC] &&
        !ast_strlen_zero(dial->options[AST_DIAL_OPTION_MUSIC])) {
        char *original_moh = ast_strdupa(ast_channel_musicclass(chan));
        ast_indicate(chan, -1);
        ast_channel_musicclass_set(chan, dial->options[AST_DIAL_OPTION_MUSIC]);
        ast_moh_start(chan, dial->options[AST_DIAL_OPTION_MUSIC], NULL);
        ast_channel_musicclass_set(chan, original_moh);
    }
 
    /* Record start time for timeout purposes */
    start = ast_tvnow();
 
    /* We actually figured out the maximum timeout we can do as they were added, so we can directly access the info */
    timeout = dial->actual_timeout;
 
    /* Go into an infinite loop while we are trying */
    while ((dial->state != AST_DIAL_RESULT_UNANSWERED) && (dial->state != AST_DIAL_RESULT_ANSWERED) && (dial->state != AST_DIAL_RESULT_HANGUP) && (dial->state != AST_DIAL_RESULT_TIMEOUT)) {
        int pos = 0, count = 0;
        struct ast_frame *fr = NULL;
 
        /* Set up channel structure array */
        pos = count = 0;
        if (chan)
            cs[pos++] = chan;
 
        /* Add channels we are attempting to dial */
        AST_LIST_LOCK(&dial->channels);
        AST_LIST_TRAVERSE(&dial->channels, channel, list) {
            if (channel->owner) {
                cs[pos++] = channel->owner;
                count++;
            }
        }
        AST_LIST_UNLOCK(&dial->channels);
 
        /* If we have no outbound channels in progress, switch state to unanswered and stop */
        if (!count) {
            set_state(dial, AST_DIAL_RESULT_UNANSWERED);
            break;
        }
 
        /* Just to be safe... */
        if (dial->thread == AST_PTHREADT_STOP)
            break;
 
        /* Wait for frames from channels */
        who = ast_waitfor_n(cs, pos, &timeout);
 
        /* Check to see if our thread is being canceled */
        if (dial->thread == AST_PTHREADT_STOP)
            break;
 
        /* If the timeout no longer exists OR if we got no channel it basically means the timeout was tripped, so handle it */
        if (!timeout || !who) {
            timeout = handle_timeout_trip(dial, start);
            continue;
        }
 
        /* Find relative dial channel */
        if (!chan || !IS_CALLER(chan, who))
            channel = find_relative_dial_channel(dial, who);
 
        /* See if this channel has been forwarded elsewhere */
        if (!ast_strlen_zero(ast_channel_call_forward(who))) {
            handle_call_forward(dial, channel, chan);
            continue;
        }
 
        /* Attempt to read in a frame */
        if (!(fr = ast_read(who))) {
            /* If this is the caller then we switch state to hangup and stop */
            if (chan && IS_CALLER(chan, who)) {
                set_state(dial, AST_DIAL_RESULT_HANGUP);
                break;
            }
            ast_channel_publish_dial(chan, who, channel->device, ast_hangup_cause_to_dial_status(ast_channel_hangupcause(who)));
            ast_hangup(who);
            channel->owner = NULL;
            continue;
        }
 
        /* Process the frame */
        handle_frame(dial, channel, fr, chan);
 
        /* Free the received frame and start all over */
        ast_frfree(fr);
    }
 
    /* Do post-processing from loop */
    if (dial->state == AST_DIAL_RESULT_ANSWERED) {
        /* Hangup everything except that which answered */
        AST_LIST_LOCK(&dial->channels);
        AST_LIST_TRAVERSE(&dial->channels, channel, list) {
            if (!channel->owner || channel->owner == who)
                continue;
            ast_channel_publish_dial(chan, channel->owner, channel->device, "CANCEL");
            ast_hangup(channel->owner);
            channel->cause = AST_CAUSE_ANSWERED_ELSEWHERE;
            channel->owner = NULL;
        }
        AST_LIST_UNLOCK(&dial->channels);
        /* If ANSWER_EXEC is enabled as an option, execute application on answered channel */
        if ((channel = find_relative_dial_channel(dial, who)) && (answer_exec = FIND_RELATIVE_OPTION(dial, channel, AST_DIAL_OPTION_ANSWER_EXEC))) {
            channel->is_running_app = 1;
            answer_exec_run(dial, channel, answer_exec->app, answer_exec->args);
            channel->is_running_app = 0;
        }
 
        if (chan && dial->options[AST_DIAL_OPTION_MUSIC] &&
            !ast_strlen_zero(dial->options[AST_DIAL_OPTION_MUSIC])) {
            ast_moh_stop(chan);
        }
    } else if (dial->state == AST_DIAL_RESULT_HANGUP) {
        /* Hangup everything */
        AST_LIST_LOCK(&dial->channels);
        AST_LIST_TRAVERSE(&dial->channels, channel, list) {
            if (!channel->owner)
                continue;
            ast_channel_publish_dial(chan, channel->owner, channel->device, "CANCEL");
            ast_hangup(channel->owner);
            channel->cause = AST_CAUSE_NORMAL_CLEARING;
            channel->owner = NULL;
        }
        AST_LIST_UNLOCK(&dial->channels);
    }
 
    if (dial->options[AST_DIAL_OPTION_SELF_DESTROY]) {
        enum ast_dial_result state = dial->state;
 
        ast_dial_destroy(dial);
        return state;
    }
 
    return dial->state;
}

References ast_dial::actual_timeout, answer_exec_run(), answer_exec_struct::app, answer_exec_struct::args, AST_CAUSE_ANSWERED_ELSEWHERE, AST_CAUSE_NORMAL_CLEARING, ast_channel_call_forward(), ast_channel_hangupcause(), ast_channel_musicclass(), ast_channel_publish_dial(), AST_CONTROL_RINGING, ast_dial_destroy(), AST_DIAL_OPTION_ANSWER_EXEC, AST_DIAL_OPTION_MUSIC, AST_DIAL_OPTION_RINGING, AST_DIAL_OPTION_SELF_DESTROY, AST_DIAL_RESULT_ANSWERED, AST_DIAL_RESULT_HANGUP, AST_DIAL_RESULT_RINGING, AST_DIAL_RESULT_TIMEOUT, AST_DIAL_RESULT_TRYING, AST_DIAL_RESULT_UNANSWERED, ast_frfree, ast_hangup(), ast_hangup_cause_to_dial_status(), ast_indicate(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, AST_MAX_WATCHERS, ast_moh_start(), ast_moh_stop(), AST_PTHREADT_STOP, ast_read(), ast_strdupa, ast_strlen_zero(), ast_tvnow(), ast_waitfor_n(), ast_dial_channel::cause, ast_dial::channels, ast_dial_channel::device, find_relative_dial_channel(), FIND_RELATIVE_OPTION, handle_call_forward(), handle_frame(), handle_timeout_trip(), IS_CALLER, ast_dial_channel::is_running_app, NULL, ast_dial::options, ast_dial_channel::owner, set_state(), ast_dial::state, ast_dial::thread, and ast_dial_channel::timeout.

Referenced by ast_dial_run(), and async_dial().

music_disable()

static int music_disable ( void *  data )

static

Definition at line 139 of file dial.c.

{
    if (!data)
        return -1;
 
    ast_free(data);
 
    return 0;
}

References ast_free.

music_enable()

static void * music_enable ( void *  data )

static

Definition at line 134 of file dial.c.

{
    return ast_strdup(data);
}

References ast_strdup.

predial_disable()

static int predial_disable ( void *  data )

static

Definition at line 154 of file dial.c.

{
    if (!data) {
        return -1;
    }
 
    ast_free(data);
 
    return 0;
}

References ast_free.

predial_enable()

static void * predial_enable ( void *  data )

static

Definition at line 149 of file dial.c.

{
    return ast_strdup(data);
}

References ast_strdup.

set_state()

static void set_state ( struct ast_dial *  dial, enum ast_dial_result  state  )

static

Definition at line 571 of file dial.c.

{
    dial->state = state;
 
    if (dial->state_callback)
        dial->state_callback(dial);
}

References ast_dial::state, and ast_dial::state_callback.

Referenced by handle_frame(), handle_timeout_trip(), and monitor_dial().

Variable Documentation

option_types

const struct ast_option_types option_types[]

static

Map options to respective handlers (enable/disable).

Note

This list MUST be perfectly kept in order with enum ast_dial_option, or else madness will happen.

Definition at line 199 of file dial.c.

                                                      {
    { AST_DIAL_OPTION_RINGING, NULL, NULL },                                  /*!< Always indicate ringing to caller */
    { AST_DIAL_OPTION_ANSWER_EXEC, answer_exec_enable, answer_exec_disable }, /*!< Execute application upon answer in async mode */
    { AST_DIAL_OPTION_MUSIC, music_enable, music_disable },                   /*!< Play music to the caller instead of ringing */
    { AST_DIAL_OPTION_DISABLE_CALL_FORWARDING, NULL, NULL },                  /*!< Disable call forwarding on channels */
    { AST_DIAL_OPTION_PREDIAL, predial_enable, predial_disable },             /*!< Execute a subroutine on the outbound channels prior to dialing */
    { AST_DIAL_OPTION_DIAL_REPLACES_SELF, NULL, NULL },                       /*!< The dial operation is a replacement for the requester */
    { AST_DIAL_OPTION_SELF_DESTROY, NULL, NULL},                              /*!< Destroy self at end of ast_dial_run */
    { AST_DIAL_OPTION_MAX, NULL, NULL },                                      /*!< Terminator of list */
};

Referenced by ast_dial_destroy(), ast_dial_option_disable(), ast_dial_option_enable(), ast_dial_option_global_disable(), and ast_dial_option_global_enable().