dial.h File Reference

Dialing API. More...

This graph shows which files directly or indirectly include this file:

Typedefs
typedef void(*	ast_dial_state_callback )(struct ast_dial *)
Enumerations
enum	ast_dial_option { AST_DIAL_OPTION_RINGING, AST_DIAL_OPTION_ANSWER_EXEC, AST_DIAL_OPTION_MUSIC, AST_DIAL_OPTION_DISABLE_CALL_FORWARDING, AST_DIAL_OPTION_MAX }
	List of options that are applicable either globally or per dialed channel. More...
enum	ast_dial_result { AST_DIAL_RESULT_INVALID, AST_DIAL_RESULT_FAILED, AST_DIAL_RESULT_TRYING, AST_DIAL_RESULT_RINGING, AST_DIAL_RESULT_PROGRESS, AST_DIAL_RESULT_PROCEEDING, AST_DIAL_RESULT_ANSWERED, AST_DIAL_RESULT_TIMEOUT, AST_DIAL_RESULT_HANGUP, AST_DIAL_RESULT_UNANSWERED }
	List of return codes for dial run API calls. More...
Functions
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)
	Append a channel.
struct ast_dial *	ast_dial_create (void)
	New dialing structure.
int	ast_dial_destroy (struct ast_dial *dial)
	Destroys a dialing 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.
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.
enum ast_dial_result	ast_dial_state (struct ast_dial *dial)
	Return state of dial.

Detailed Description

Dialing API.

Definition in file dial.h.

Typedef Documentation

typedef void(* ast_dial_state_callback)(struct ast_dial *)

Definition at line 36 of file dial.h.

Enumeration Type Documentation

enum ast_dial_option

List of options that are applicable either globally or per dialed channel.

Enumerator:

AST_DIAL_OPTION_RINGING	Always indicate ringing to caller
AST_DIAL_OPTION_ANSWER_EXEC	Execute application upon answer in async mode
AST_DIAL_OPTION_MUSIC	Play music on hold instead of ringing to the calling channel
AST_DIAL_OPTION_DISABLE_CALL_FORWARDING	Disable call forwarding on channels
AST_DIAL_OPTION_MAX	End terminator -- must always remain last

Definition at line 39 of file dial.h.

00039                      {
00040    AST_DIAL_OPTION_RINGING,                 /*!< Always indicate ringing to caller */
00041    AST_DIAL_OPTION_ANSWER_EXEC,             /*!< Execute application upon answer in async mode */
00042    AST_DIAL_OPTION_MUSIC,                   /*!< Play music on hold instead of ringing to the calling channel */
00043    AST_DIAL_OPTION_DISABLE_CALL_FORWARDING, /*!< Disable call forwarding on channels */
00044    AST_DIAL_OPTION_MAX,                     /*!< End terminator -- must always remain last */
00045 };

enum ast_dial_result

List of return codes for dial run API calls.

Enumerator:

AST_DIAL_RESULT_INVALID	Invalid options were passed to run function
AST_DIAL_RESULT_FAILED	Attempts to dial failed before reaching critical state
AST_DIAL_RESULT_TRYING	Currently trying to dial
AST_DIAL_RESULT_RINGING	Dial is presently ringing
AST_DIAL_RESULT_PROGRESS	Dial is presently progressing
AST_DIAL_RESULT_PROCEEDING	Dial is presently proceeding
AST_DIAL_RESULT_ANSWERED	A channel was answered
AST_DIAL_RESULT_TIMEOUT	Timeout was tripped, nobody answered
AST_DIAL_RESULT_HANGUP	Caller hung up
AST_DIAL_RESULT_UNANSWERED	Nobody answered

Definition at line 48 of file dial.h.

00048                      {
00049    AST_DIAL_RESULT_INVALID,     /*!< Invalid options were passed to run function */
00050    AST_DIAL_RESULT_FAILED,      /*!< Attempts to dial failed before reaching critical state */
00051    AST_DIAL_RESULT_TRYING,      /*!< Currently trying to dial */
00052    AST_DIAL_RESULT_RINGING,     /*!< Dial is presently ringing */
00053    AST_DIAL_RESULT_PROGRESS,    /*!< Dial is presently progressing */
00054    AST_DIAL_RESULT_PROCEEDING,  /*!< Dial is presently proceeding */
00055    AST_DIAL_RESULT_ANSWERED,    /*!< A channel was answered */
00056    AST_DIAL_RESULT_TIMEOUT,     /*!< Timeout was tripped, nobody answered */
00057    AST_DIAL_RESULT_HANGUP,      /*!< Caller hung up */
00058    AST_DIAL_RESULT_UNANSWERED,  /*!< Nobody answered */
00059 };

Function Documentation

struct ast_channel* ast_dial_answered ( struct ast_dial * dial ) [read]

Return channel that answered.

Note:: Returns the Asterisk channel that answered

Parameters:

dial

Dialing structure

Definition at line 738 of file dial.c.

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

Referenced by dial_trunk(), and sla_handle_dial_state_event().

00739 {
00740    if (!dial)
00741       return NULL;
00742 
00743    return ((dial->state == AST_DIAL_RESULT_ANSWERED) ? AST_LIST_FIRST(&dial->channels)->owner : NULL);
00744 }

struct ast_channel* ast_dial_answered_steal ( struct ast_dial * dial ) [read]

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 750 of file dial.c.

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

00751 {
00752    struct ast_channel *chan = NULL;
00753 
00754    if (!dial)
00755       return NULL;
00756 
00757    if (dial->state == AST_DIAL_RESULT_ANSWERED) {
00758       chan = AST_LIST_FIRST(&dial->channels)->owner;
00759       AST_LIST_FIRST(&dial->channels)->owner = NULL;
00760    }
00761 
00762    return chan;
00763 }

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

Append a channel.

Note:: Appends a channel to a dialing structure

Returns:: Returns channel reference number on success, -1 on failure

Definition at line 226 of file dial.c.

References ast_atomic_fetchadd_int(), ast_calloc, AST_LIST_INSERT_TAIL, ast_strdup, ast_dial::channels, ast_dial_channel::device, ast_dial_channel::list, ast_dial::num, ast_dial_channel::num, ast_dial_channel::tech, and ast_dial_channel::timeout.

Referenced by dial_trunk(), page_exec(), and sla_ring_station().

00227 {
00228    struct ast_dial_channel *channel = NULL;
00229 
00230    /* Make sure we have required arguments */
00231    if (!dial || !tech || !device)
00232       return -1;
00233 
00234    /* Allocate new memory for dialed channel structure */
00235    if (!(channel = ast_calloc(1, sizeof(*channel))))
00236       return -1;
00237 
00238    /* Record technology and device for when we actually dial */
00239    channel->tech = ast_strdup(tech);
00240    channel->device = ast_strdup(device);
00241 
00242    /* Grab reference number from dial structure */
00243    channel->num = ast_atomic_fetchadd_int(&dial->num, +1);
00244 
00245    /* No timeout exists... yet */
00246    channel->timeout = -1;
00247 
00248    /* Insert into channels list */
00249    AST_LIST_INSERT_TAIL(&dial->channels, channel, list);
00250 
00251    return channel->num;
00252 }

struct ast_dial* ast_dial_create ( void ) [read]

New dialing structure.

Note:: Create a dialing structure

Returns:: Returns a calloc'd ast_dial structure, NULL on failure

Definition at line 198 of file dial.c.

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

Referenced by dial_trunk(), page_exec(), and sla_ring_station().

00199 {
00200    struct ast_dial *dial = NULL;
00201 
00202    /* Allocate new memory for structure */
00203    if (!(dial = ast_calloc(1, sizeof(*dial))))
00204       return NULL;
00205 
00206    /* Initialize list of channels */
00207    AST_LIST_HEAD_INIT(&dial->channels);
00208 
00209    /* Initialize thread to NULL */
00210    dial->thread = AST_PTHREADT_NULL;
00211 
00212    /* No timeout exists... yet */
00213    dial->timeout = -1;
00214    dial->actual_timeout = -1;
00215 
00216    /* Can't forget about the lock */
00217    ast_mutex_init(&dial->lock);
00218 
00219    return dial;
00220 }

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

Returns:: Returns 0 on success, -1 on failure

Note:: Destroys (free's) the given ast_dial structure

Parameters:

dial

Dialing structure to free

Returns:: Returns 0 on success, -1 on failure

Definition at line 850 of file dial.c.

References 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, option_types, ast_dial::options, ast_dial_channel::options, ast_dial_channel::owner, and ast_dial_channel::tech.

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

00852 00853 00854 00855 00856 00857 00858 00859 00860 00861 00862 00863 00864 00865 00866 00867 00868       } 00869 00870 00871 00872 00873       } 00874 00875 00876 00877 00878 00879    } 00880 00881 00882 00883 00884 00885 00886 00887 00888 00889 00890    } 00891 00892 00893 00894 00895 00896 00897 00898 00899 }

class="fragment">00851 { 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 */ if (channel->owner) { ast_hangup(channel->owner); channel->owner = NULL; /* Free structure */ ast_free(channel->tech); ast_free(channel->device); 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;

void ast_dial_hangup ( struct ast_dial * dial )

Hangup channels.

Note:: Hangup all active channels

Parameters:

dial

Dialing structure

Definition at line 826 of file dial.c.

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

Referenced by ast_dial_run(), and page_exec().

00827 {
00828    struct ast_dial_channel *channel = NULL;
00829 
00830    if (!dial)
00831       return;
00832    
00833    AST_LIST_LOCK(&dial->channels);
00834    AST_LIST_TRAVERSE(&dial->channels, channel, list) {
00835       if (channel->owner) {
00836          ast_hangup(channel->owner);
00837          channel->owner = NULL;
00838       }
00839    }
00840    AST_LIST_UNLOCK(&dial->channels);
00841 
00842    return;
00843 }

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 778 of file dial.c.

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

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

00779 {
00780    pthread_t thread;
00781 
00782    /* If the dial structure is not running in async, return failed */
00783    if (dial->thread == AST_PTHREADT_NULL)
00784       return AST_DIAL_RESULT_FAILED;
00785 
00786    /* Record thread */
00787    thread = dial->thread;
00788 
00789    /* Boom, commence locking */
00790    ast_mutex_lock(&dial->lock);
00791 
00792    /* Stop the thread */
00793    dial->thread = AST_PTHREADT_STOP;
00794 
00795    /* If the answered channel is running an application we have to soft hangup it, can't just poke the thread */
00796    AST_LIST_LOCK(&dial->channels);
00797    if (AST_LIST_FIRST(&dial->channels)->is_running_app) {
00798       struct ast_channel *chan = AST_LIST_FIRST(&dial->channels)->owner;
00799       if (chan) {
00800          ast_channel_lock(chan);
00801          ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
00802          ast_channel_unlock(chan);
00803       }
00804    } else {
00805       /* Now we signal it with SIGURG so it will break out of it's waitfor */
00806       pthread_kill(thread, SIGURG);
00807    }
00808    AST_LIST_UNLOCK(&dial->channels);
00809 
00810    /* Yay done with it */
00811    ast_mutex_unlock(&dial->lock);
00812 
00813    /* Finally wait for the thread to exit */
00814    pthread_join(thread, NULL);
00815 
00816    /* Yay thread is all gone */
00817    dial->thread = AST_PTHREADT_NULL;
00818 
00819    return dial->state;
00820 }

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

Returns:: Returns 0 on success, -1 on failure

Definition at line 1002 of file dial.c.

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

01003 {
01004    struct ast_dial_channel *channel = NULL;
01005 
01006    /* Ensure we have required arguments */
01007    if (!dial || AST_LIST_EMPTY(&dial->channels))
01008       return -1;
01009 
01010    if (!(channel = find_dial_channel(dial, num)))
01011       return -1;
01012 
01013    /* If the option is not enabled, return failure */
01014    if (!channel->options[option])
01015       return -1;
01016 
01017    /* Execute callback of option to disable it if it exists */
01018    if (option_types[option].disable)
01019       option_types[option].disable(channel->options[option]);
01020 
01021    /* Finally disable the option on the structure */
01022    channel->options[option] = NULL;
01023 
01024    return 0;
01025 }

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)

Returns:: Returns 0 on success, -1 on failure

Definition at line 950 of file dial.c.

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

00951 {
00952    struct ast_dial_channel *channel = NULL;
00953 
00954    /* Ensure we have required arguments */
00955    if (!dial || AST_LIST_EMPTY(&dial->channels))
00956       return -1;
00957 
00958    if (!(channel = find_dial_channel(dial, num)))
00959       return -1;
00960 
00961    /* If the option is already enabled, return failure */
00962    if (channel->options[option])
00963       return -1;
00964 
00965    /* Execute enable callback if it exists, if not simply make sure the value is set */
00966    if (option_types[option].enable)
00967       channel->options[option] = option_types[option].enable(data);
00968    else
00969       channel->options[option] = (void*)1;
00970 
00971    return 0;
00972 }

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

Returns:: Returns 0 on success, -1 on failure

Definition at line 979 of file dial.c.

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

00980 {
00981    /* If the option is not enabled, return failure */
00982    if (!dial->options[option]) {
00983       return -1;
00984    }
00985 
00986    /* Execute callback of option to disable if it exists */
00987    if (option_types[option].disable)
00988       option_types[option].disable(dial->options[option]);
00989 
00990    /* Finally disable option on the structure */
00991    dial->options[option] = NULL;
00992 
00993    return 0;
00994 }

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)

Returns:: Returns 0 on success, -1 on failure

Definition at line 907 of file dial.c.

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

Referenced by page_exec().

00908 {
00909    /* If the option is already enabled, return failure */
00910    if (dial->options[option])
00911       return -1;
00912 
00913    /* Execute enable callback if it exists, if not simply make sure the value is set */
00914    if (option_types[option].enable)
00915       dial->options[option] = option_types[option].enable(data);
00916    else
00917       dial->options[option] = (void*)1;
00918 
00919    return 0;
00920 }

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 698 of file dial.c.

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

Referenced by dial_trunk(), page_exec(), and sla_ring_station().

00699 {
00700    enum ast_dial_result res = AST_DIAL_RESULT_TRYING;
00701 
00702    /* Ensure required arguments are passed */
00703    if (!dial || (!chan && !async)) {
00704       ast_debug(1, "invalid #1\n");
00705       return AST_DIAL_RESULT_INVALID;
00706    }
00707 
00708    /* If there are no channels to dial we can't very well try to dial them */
00709    if (AST_LIST_EMPTY(&dial->channels)) {
00710       ast_debug(1, "invalid #2\n");
00711       return AST_DIAL_RESULT_INVALID;
00712    }
00713 
00714    /* Dial each requested channel */
00715    if (!begin_dial(dial, chan))
00716       return AST_DIAL_RESULT_FAILED;
00717 
00718    /* If we are running async spawn a thread and send it away... otherwise block here */
00719    if (async) {
00720       dial->state = AST_DIAL_RESULT_TRYING;
00721       /* Try to create a thread */
00722       if (ast_pthread_create(&dial->thread, NULL, async_dial, dial)) {
00723          /* Failed to create the thread - hangup all dialed channels and return failed */
00724          ast_dial_hangup(dial);
00725          res = AST_DIAL_RESULT_FAILED;
00726       }
00727    } else {
00728       res = monitor_dial(dial, chan);
00729    }
00730 
00731    return res;
00732 }

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

Returns:: nothing

Parameters:

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

Returns:: nothing

Definition at line 1037 of file dial.c.

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

Referenced by page_exec().

01038 {
01039    dial->timeout = timeout;
01040 
01041    if (dial->timeout > 0 && (dial->actual_timeout > dial->timeout || dial->actual_timeout == -1))
01042       dial->actual_timeout = dial->timeout;
01043 
01044    return;
01045 }

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

Returns:: nothing

Definition at line 1027 of file dial.c.

References ast_dial::state_callback.

Referenced by sla_ring_station().

01028 {
01029    dial->state_callback = callback;
01030 }

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

Returns:: nothing

Parameters:

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

Returns:: nothing

Definition at line 1053 of file dial.c.

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

01054 {
01055    struct ast_dial_channel *channel = NULL;
01056 
01057    if (!(channel = find_dial_channel(dial, num)))
01058       return;
01059 
01060    channel->timeout = timeout;
01061 
01062    if (channel->timeout > 0 && (dial->actual_timeout > channel->timeout || dial->actual_timeout == -1))
01063       dial->actual_timeout = channel->timeout;
01064 
01065    return;
01066 }

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 769 of file dial.c.

References ast_dial::state.

Referenced by dial_trunk(), and sla_handle_dial_state_event().

00770 {
00771    return dial->state;
00772 }

Asterisk developer's documentation

dial.h File Reference

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation