Fri Feb 10 06:35:56 2012

Asterisk developer's documentation

dial.h File Reference

Dialing API. More...

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

Go to the source code of 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 756 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().

00757 {
00758    if (!dial)
00759       return NULL;
00760 
00761    return ((dial->state == AST_DIAL_RESULT_ANSWERED) ? AST_LIST_FIRST(&dial->channels)->owner : NULL);
00762 }

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

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

Referenced by do_notify().

00769 {
00770    struct ast_channel *chan = NULL;
00771 
00772    if (!dial)
00773       return NULL;
00774 
00775    if (dial->state == AST_DIAL_RESULT_ANSWERED) {
00776       chan = AST_LIST_FIRST(&dial->channels)->owner;
00777       AST_LIST_FIRST(&dial->channels)->owner = NULL;
00778    }
00779 
00780    return chan;
00781 }

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 218 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(), do_notify(), page_exec(), and sla_ring_station().

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

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 190 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(), do_notify(), page_exec(), and sla_ring_station().

00191 {
00192    struct ast_dial *dial = NULL;
00193 
00194    /* Allocate new memory for structure */
00195    if (!(dial = ast_calloc(1, sizeof(*dial))))
00196       return NULL;
00197 
00198    /* Initialize list of channels */
00199    AST_LIST_HEAD_INIT(&dial->channels);
00200 
00201    /* Initialize thread to NULL */
00202    dial->thread = AST_PTHREADT_NULL;
00203 
00204    /* No timeout exists... yet */
00205    dial->timeout = -1;
00206    dial->actual_timeout = -1;
00207 
00208    /* Can't forget about the lock */
00209    ast_mutex_init(&dial->lock);
00210 
00211    return dial;
00212 }

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 868 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(), do_notify(), page_exec(), run_station(), sla_hangup_stations(), sla_ring_station(), and sla_stop_ringing_station().

00869 {
00870    int i = 0;
00871    struct ast_dial_channel *channel = NULL;
00872 
00873    if (!dial)
00874       return -1;
00875    
00876    /* Hangup and deallocate all the dialed channels */
00877    AST_LIST_LOCK(&dial->channels);
00878    AST_LIST_TRAVERSE_SAFE_BEGIN(&dial->channels, channel, list) {
00879       /* Disable any enabled options */
00880       for (i = 0; i < AST_DIAL_OPTION_MAX; i++) {
00881          if (!channel->options[i])
00882             continue;
00883          if (option_types[i].disable)
00884             option_types[i].disable(channel->options[i]);
00885          channel->options[i] = NULL;
00886       }
00887       /* Hang up channel if need be */
00888       if (channel->owner) {
00889          ast_hangup(channel->owner);
00890          channel->owner = NULL;
00891       }
00892       /* Free structure */
00893       ast_free(channel->tech);
00894       ast_free(channel->device);
00895       AST_LIST_REMOVE_CURRENT(list);
00896       ast_free(channel);
00897    }
00898    AST_LIST_TRAVERSE_SAFE_END;
00899    AST_LIST_UNLOCK(&dial->channels);
00900  
00901    /* Disable any enabled options globally */
00902    for (i = 0; i < AST_DIAL_OPTION_MAX; i++) {
00903       if (!dial->options[i])
00904          continue;
00905       if (option_types[i].disable)
00906          option_types[i].disable(dial->options[i]);
00907       dial->options[i] = NULL;
00908    }
00909 
00910    /* Lock be gone! */
00911    ast_mutex_destroy(&dial->lock);
00912 
00913    /* Free structure */
00914    ast_free(dial);
00915 
00916    return 0;
00917 }

void ast_dial_hangup ( struct ast_dial *  dial  ) 

Hangup channels.

Note:
Hangup all active channels
Parameters:
dial Dialing structure

Definition at line 844 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().

00845 {
00846    struct ast_dial_channel *channel = NULL;
00847 
00848    if (!dial)
00849       return;
00850    
00851    AST_LIST_LOCK(&dial->channels);
00852    AST_LIST_TRAVERSE(&dial->channels, channel, list) {
00853       if (channel->owner) {
00854          ast_hangup(channel->owner);
00855          channel->owner = NULL;
00856       }
00857    }
00858    AST_LIST_UNLOCK(&dial->channels);
00859 
00860    return;
00861 }

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 796 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, 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().

00797 {
00798    pthread_t thread;
00799 
00800    /* If the dial structure is not running in async, return failed */
00801    if (dial->thread == AST_PTHREADT_NULL)
00802       return AST_DIAL_RESULT_FAILED;
00803 
00804    /* Record thread */
00805    thread = dial->thread;
00806 
00807    /* Boom, commence locking */
00808    ast_mutex_lock(&dial->lock);
00809 
00810    /* Stop the thread */
00811    dial->thread = AST_PTHREADT_STOP;
00812 
00813    /* If the answered channel is running an application we have to soft hangup it, can't just poke the thread */
00814    AST_LIST_LOCK(&dial->channels);
00815    if (AST_LIST_FIRST(&dial->channels)->is_running_app) {
00816       struct ast_channel *chan = AST_LIST_FIRST(&dial->channels)->owner;
00817       if (chan) {
00818          ast_channel_lock(chan);
00819          ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
00820          ast_channel_unlock(chan);
00821       }
00822    } else {
00823       /* Now we signal it with SIGURG so it will break out of it's waitfor */
00824       pthread_kill(thread, SIGURG);
00825    }
00826    AST_LIST_UNLOCK(&dial->channels);
00827 
00828    /* Yay done with it */
00829    ast_mutex_unlock(&dial->lock);
00830 
00831    /* Finally wait for the thread to exit */
00832    pthread_join(thread, NULL);
00833 
00834    /* Yay thread is all gone */
00835    dial->thread = AST_PTHREADT_NULL;
00836 
00837    return dial->state;
00838 }

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 1020 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.

01021 {
01022    struct ast_dial_channel *channel = NULL;
01023 
01024    /* Ensure we have required arguments */
01025    if (!dial || AST_LIST_EMPTY(&dial->channels))
01026       return -1;
01027 
01028    if (!(channel = find_dial_channel(dial, num)))
01029       return -1;
01030 
01031    /* If the option is not enabled, return failure */
01032    if (!channel->options[option])
01033       return -1;
01034 
01035    /* Execute callback of option to disable it if it exists */
01036    if (option_types[option].disable)
01037       option_types[option].disable(channel->options[option]);
01038 
01039    /* Finally disable the option on the structure */
01040    channel->options[option] = NULL;
01041 
01042    return 0;
01043 }

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 968 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.

00969 {
00970    struct ast_dial_channel *channel = NULL;
00971 
00972    /* Ensure we have required arguments */
00973    if (!dial || AST_LIST_EMPTY(&dial->channels))
00974       return -1;
00975 
00976    if (!(channel = find_dial_channel(dial, num)))
00977       return -1;
00978 
00979    /* If the option is already enabled, return failure */
00980    if (channel->options[option])
00981       return -1;
00982 
00983    /* Execute enable callback if it exists, if not simply make sure the value is set */
00984    if (option_types[option].enable)
00985       channel->options[option] = option_types[option].enable(data);
00986    else
00987       channel->options[option] = (void*)1;
00988 
00989    return 0;
00990 }

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

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

00998 {
00999    /* If the option is not enabled, return failure */
01000    if (!dial->options[option]) {
01001       return -1;
01002    }
01003 
01004    /* Execute callback of option to disable if it exists */
01005    if (option_types[option].disable)
01006       option_types[option].disable(dial->options[option]);
01007 
01008    /* Finally disable option on the structure */
01009    dial->options[option] = NULL;
01010 
01011    return 0;
01012 }

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

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

Referenced by do_notify(), and page_exec().

00926 {
00927    /* If the option is already enabled, return failure */
00928    if (dial->options[option])
00929       return -1;
00930 
00931    /* Execute enable callback if it exists, if not simply make sure the value is set */
00932    if (option_types[option].enable)
00933       dial->options[option] = option_types[option].enable(data);
00934    else
00935       dial->options[option] = (void*)1;
00936 
00937    return 0;
00938 }

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 716 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(), do_notify(), page_exec(), and sla_ring_station().

00717 {
00718    enum ast_dial_result res = AST_DIAL_RESULT_TRYING;
00719 
00720    /* Ensure required arguments are passed */
00721    if (!dial || (!chan && !async)) {
00722       ast_debug(1, "invalid #1\n");
00723       return AST_DIAL_RESULT_INVALID;
00724    }
00725 
00726    /* If there are no channels to dial we can't very well try to dial them */
00727    if (AST_LIST_EMPTY(&dial->channels)) {
00728       ast_debug(1, "invalid #2\n");
00729       return AST_DIAL_RESULT_INVALID;
00730    }
00731 
00732    /* Dial each requested channel */
00733    if (!begin_dial(dial, chan))
00734       return AST_DIAL_RESULT_FAILED;
00735 
00736    /* If we are running async spawn a thread and send it away... otherwise block here */
00737    if (async) {
00738       dial->state = AST_DIAL_RESULT_TRYING;
00739       /* Try to create a thread */
00740       if (ast_pthread_create(&dial->thread, NULL, async_dial, dial)) {
00741          /* Failed to create the thread - hangup all dialed channels and return failed */
00742          ast_dial_hangup(dial);
00743          res = AST_DIAL_RESULT_FAILED;
00744       }
00745    } else {
00746       res = monitor_dial(dial, chan);
00747    }
00748 
00749    return res;
00750 }

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

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

Referenced by do_notify(), and page_exec().

01056 {
01057    dial->timeout = timeout;
01058 
01059    if (dial->timeout > 0 && (dial->actual_timeout > dial->timeout || dial->actual_timeout == -1))
01060       dial->actual_timeout = dial->timeout;
01061 
01062    return;
01063 }

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

References ast_dial::state_callback.

Referenced by sla_ring_station().

01046 {
01047    dial->state_callback = callback;
01048 }

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

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

01072 {
01073    struct ast_dial_channel *channel = NULL;
01074 
01075    if (!(channel = find_dial_channel(dial, num)))
01076       return;
01077 
01078    channel->timeout = timeout;
01079 
01080    if (channel->timeout > 0 && (dial->actual_timeout > channel->timeout || dial->actual_timeout == -1))
01081       dial->actual_timeout = channel->timeout;
01082 
01083    return;
01084 }

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

References ast_dial::state.

Referenced by dial_trunk(), and sla_handle_dial_state_event().

00788 {
00789    return dial->state;
00790 }

Generated on Fri Feb 10 06:35:56 2012 for Asterisk - The Open Source Telephony Project by  doxygen 1.5.6