app_sla.c File Reference

Shared Line Appearances. More...

#include "asterisk.h"
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/app.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/astobj2.h"
#include "asterisk/devicestate.h"
#include "asterisk/dial.h"
#include "asterisk/causes.h"
#include "asterisk/format_compatibility.h"

Include dependency graph for app_sla.c:

Go to the source code of this file.

Data Structures
struct	dial_trunk_args
struct	run_station_args
struct	sla_event
struct	sla_failed_station
	A station that failed to be dialed. More...
struct	sla_framehook_data
	Framehook to support HOLD within the conference. More...
struct	sla_ringing_station
	A station that is ringing. More...
struct	sla_ringing_trunk
	A trunk that is ringing. More...
struct	sla_station
struct	sla_station_ref
	A reference to a station. More...
struct	sla_trunk
struct	sla_trunk_ref
	A station's reference to a trunk. More...

Macros
#define	MAX_CONFNUM   80
#define	S(e)   case e: return # e;
#define	SLA_CONFIG_FILE   "sla.conf"

Enumerations
enum	{   CONFFLAG_QUIET = (1 << 0) , CONFFLAG_MOH = (1 << 1) , CONFFLAG_MARKEDEXIT = (1 << 2) , CONFFLAG_MARKEDUSER = (1 << 3) ,   CONFFLAG_PASS_DTMF = (1 << 4) , CONFFLAG_SLA_STATION = (1 << 5) , CONFFLAG_SLA_TRUNK = (1 << 6) }
enum	{ SLA_TRUNK_OPT_MOH = (1 << 0) }
enum	{ SLA_TRUNK_OPT_ARG_MOH_CLASS = 0 , SLA_TRUNK_OPT_ARG_ARRAY_SIZE = 1 }
enum	sla_event_type { SLA_EVENT_HOLD , SLA_EVENT_DIAL_STATE , SLA_EVENT_RINGING_TRUNK }
	Event types that can be queued up for the SLA thread. More...
enum	sla_hold_access { SLA_HOLD_OPEN , SLA_HOLD_PRIVATE }
enum	sla_station_hangup { SLA_STATION_HANGUP_NORMAL , SLA_STATION_HANGUP_TIMEOUT }
enum	sla_trunk_state {   SLA_TRUNK_STATE_IDLE , SLA_TRUNK_STATE_RINGING , SLA_TRUNK_STATE_UP , SLA_TRUNK_STATE_ONHOLD ,   SLA_TRUNK_STATE_ONHOLD_BYME }
enum	sla_which_trunk_refs { ALL_TRUNK_REFS , INACTIVE_TRUNK_REFS }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static void	answer_trunk_chan (struct ast_channel *chan)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	attach_framehook (struct ast_channel *chan, const char *confname)
static int	conf_kick_all (struct ast_channel *chan, const char *confname)
static int	conf_run (struct ast_channel *chan, const char *confname, struct ast_flags *confflags, char *optargs[])
static struct sla_trunk_ref *	create_trunk_ref (struct sla_trunk *trunk)
static void *	dial_trunk (void *data)
static int	load_config (int reload)
static int	load_module (void)
	Load the module. More...
static struct sla_ringing_trunk *	queue_ringing_trunk (struct sla_trunk *trunk)
static int	reload (void)
static int	remove_framehook (struct ast_channel *chan)
static void *	run_station (void *data)
static void	sla_add_trunk_to_station (struct sla_station *station, struct ast_variable *var)
static int	sla_build_station (struct ast_config *cfg, const char *cat)
static int	sla_build_trunk (struct ast_config *cfg, const char *cat)
static int	sla_calc_station_delays (unsigned int *timeout)
	Calculate the ring delay for a station. More...
static int	sla_calc_station_timeouts (unsigned int *timeout)
	Process station ring timeouts. More...
static int	sla_calc_trunk_timeouts (unsigned int *timeout)
	Process trunk ring timeouts. More...
static void	sla_change_trunk_state (const struct sla_trunk *trunk, enum sla_trunk_state state, enum sla_which_trunk_refs inactive_only, const struct sla_trunk_ref *exclude)
static int	sla_check_device (const char *device)
static int	sla_check_failed_station (const struct sla_station *station)
	Check to see if this station has failed to be dialed in the past minute. More...
static int	sla_check_inuse_station (const struct sla_station *station)
	Check to see if a station is in use. More...
static int	sla_check_ringing_station (const struct sla_station *station)
	Check to see if this station is already ringing. More...
static int	sla_check_station_delay (struct sla_station *station, struct sla_ringing_trunk *ringing_trunk)
	Calculate the ring delay for a given ringing trunk on a station. More...
static int	sla_check_station_hold_access (const struct sla_trunk *trunk, const struct sla_station *station)
static int	sla_check_timed_out_station (const struct sla_ringing_trunk *ringing_trunk, const struct sla_station *station)
	Check to see if dialing this station already timed out for this ringing trunk. More...
static struct sla_trunk_ref *	sla_choose_idle_trunk (const struct sla_station *station)
	For a given station, choose the highest priority idle trunk. More...
static struct sla_ringing_trunk *	sla_choose_ringing_trunk (struct sla_station *station, struct sla_trunk_ref **trunk_ref, int rm)
	Choose the highest priority ringing trunk for a station. More...
static struct sla_failed_station *	sla_create_failed_station (struct sla_station *station)
static struct sla_ringing_station *	sla_create_ringing_station (struct sla_station *station)
static struct sla_station_ref *	sla_create_station_ref (struct sla_station *station)
static void	sla_destroy (void)
static void	sla_dial_state_callback (struct ast_dial *dial)
static void	sla_event_destroy (struct sla_event *event)
static void	sla_failed_station_destroy (struct sla_failed_station *failed_station)
static struct sla_station *	sla_find_station (const char *name)
static struct sla_trunk *	sla_find_trunk (const char *name)
static struct sla_trunk_ref *	sla_find_trunk_ref (const struct sla_station *station, const struct sla_trunk *trunk)
static struct sla_trunk_ref *	sla_find_trunk_ref_byname (const struct sla_station *station, const char *name)
	Find a trunk reference on a station by name. More...
static struct ast_frame *	sla_framehook (struct ast_channel *chan, struct ast_frame *f, enum ast_framehook_event event, void *data)
static int	sla_framehook_consume (void *data, enum ast_frame_type type)
	Callback function which informs upstream if we are consuming a frame of a specific type. More...
static void	sla_handle_dial_state_event (void)
static void	sla_handle_hold_event (struct sla_event *event)
static void	sla_handle_ringing_trunk_event (void)
static void	sla_hangup_stations (void)
static const char *	sla_hold_str (unsigned int hold_access)
static int	sla_in_use (void)
static int	sla_load_config (int reload)
static int	sla_process_timers (struct timespec *ts)
	Calculate the time until the next known event. More...
static void	sla_queue_event (enum sla_event_type type)
static void	sla_queue_event_conf (enum sla_event_type type, struct ast_channel *chan, const char *confname)
	Queue a SLA event from the conference. More...
static void	sla_queue_event_full (enum sla_event_type type, struct sla_trunk_ref *trunk_ref, struct sla_station *station, int lock)
static void	sla_queue_event_nolock (enum sla_event_type type)
static int	sla_ring_station (struct sla_ringing_trunk *ringing_trunk, struct sla_station *station)
	Ring a station. More...
static void	sla_ring_stations (void)
	Ring stations based on current set of ringing trunks. More...
static void	sla_ringing_station_destroy (struct sla_ringing_station *ringing_station)
static void	sla_ringing_trunk_destroy (struct sla_ringing_trunk *ringing_trunk)
static char *	sla_show_stations (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	sla_show_trunks (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static enum ast_device_state	sla_state (const char *data)
static enum ast_device_state	sla_state_to_devstate (enum sla_trunk_state state)
static int	sla_station_cmp (void *obj, void *arg, int flags)
static void	sla_station_destructor (void *obj)
static int	sla_station_exec (struct ast_channel *chan, const char *data)
static int	sla_station_is_marked (void *obj, void *arg, int flags)
static int	sla_station_mark (void *obj, void *arg, int flags)
static void	sla_station_ref_destructor (void *obj)
static int	sla_station_release_refs (void *obj, void *arg, int flags)
static void	sla_stop_ringing_station (struct sla_ringing_station *ringing_station, enum sla_station_hangup hangup)
static void	sla_stop_ringing_trunk (struct sla_ringing_trunk *ringing_trunk)
static void *	sla_thread (void *data)
static int	sla_trunk_cmp (void *obj, void *arg, int flags)
static void	sla_trunk_destructor (void *obj)
static int	sla_trunk_exec (struct ast_channel *chan, const char *data)
static int	sla_trunk_is_marked (void *obj, void *arg, int flags)
static int	sla_trunk_mark (void *obj, void *arg, int flags)
static void	sla_trunk_ref_destructor (void *obj)
static int	sla_trunk_release_refs (void *obj, void *arg, int flags)
static const char *	trunkstate2str (enum sla_trunk_state state)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Shared Line Appearances" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_DEVSTATE_PROVIDER, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_sla []
struct {
unsigned int   attempt_callerid:1
ast_cond_t   cond
struct {
struct sla_event *   first
struct sla_event *   last
}   event_q
struct {
struct sla_failed_station *   first
struct sla_failed_station *   last
}   failed_stations
ast_mutex_t   lock
struct {
struct sla_ringing_station *   first
struct sla_ringing_station *   last
}   ringing_stations
struct {
struct sla_ringing_trunk *   first
struct sla_ringing_trunk *   last
}   ringing_trunks
unsigned int   stop:1
pthread_t   thread
}	sla
	A structure for data used by the sla thread. More...
static const struct ast_datastore_info	sla_framehook_datastore
static const char	sla_registrar [] = "SLA"
static struct ao2_container *	sla_stations
static const struct ast_app_option	sla_trunk_opts [128] = { [ 'M' ] = { .flag = SLA_TRUNK_OPT_MOH , .arg_index = SLA_TRUNK_OPT_ARG_MOH_CLASS + 1 }, }
static struct ao2_container *	sla_trunks
static const char *const	slastation_app = "SLAStation"
static const char *const	slatrunk_app = "SLATrunk"

Detailed Description

Shared Line Appearances.

Author

Naveen Albert aster.nosp@m.isk@.nosp@m.phrea.nosp@m.knet.nosp@m..org

Definition in file app_sla.c.

Macro Definition Documentation

MAX_CONFNUM

#define MAX_CONFNUM   80

Definition at line 131 of file app_sla.c.

S

#define S

(

e

)

case e: return # e;

SLA_CONFIG_FILE

#define SLA_CONFIG_FILE   "sla.conf"

Definition at line 130 of file app_sla.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
CONFFLAG_QUIET	If set there will be no enter or leave sounds
CONFFLAG_MOH	Set to have music on hold when user is alone in conference
CONFFLAG_MARKEDEXIT	If set, the channel will leave the conference if all marked users leave
CONFFLAG_MARKEDUSER	If set, the user will be marked
CONFFLAG_PASS_DTMF	Pass DTMF through the conference
CONFFLAG_SLA_STATION
CONFFLAG_SLA_TRUNK

Definition at line 136 of file app_sla.c.

     {
    /*! If set there will be no enter or leave sounds */
    CONFFLAG_QUIET = (1 << 0),
    /*! Set to have music on hold when user is alone in conference */
    CONFFLAG_MOH = (1 << 1),
    /*! If set, the channel will leave the conference if all marked users leave */
    CONFFLAG_MARKEDEXIT = (1 << 2),
    /*! If set, the user will be marked */
    CONFFLAG_MARKEDUSER = (1 << 3),
    /*! Pass DTMF through the conference */
    CONFFLAG_PASS_DTMF = (1 << 4),
    CONFFLAG_SLA_STATION = (1 << 5),
    CONFFLAG_SLA_TRUNK = (1 << 6),
};

anonymous enum

anonymous enum

Enumerator
SLA_TRUNK_OPT_MOH

Definition at line 151 of file app_sla.c.

     {
    SLA_TRUNK_OPT_MOH = (1 << 0),
};

anonymous enum

anonymous enum

Enumerator
SLA_TRUNK_OPT_ARG_MOH_CLASS
SLA_TRUNK_OPT_ARG_ARRAY_SIZE

Definition at line 155 of file app_sla.c.

     {
    SLA_TRUNK_OPT_ARG_MOH_CLASS = 0,
    SLA_TRUNK_OPT_ARG_ARRAY_SIZE = 1,
};

sla_event_type

enum sla_event_type

Event types that can be queued up for the SLA thread.

Enumerator
SLA_EVENT_HOLD	A station has put the call on hold
SLA_EVENT_DIAL_STATE	The state of a dial has changed
SLA_EVENT_RINGING_TRUNK	The state of a ringing trunk has changed

Definition at line 284 of file app_sla.c.

                    {
    /*! A station has put the call on hold */
    SLA_EVENT_HOLD,
    /*! The state of a dial has changed */
    SLA_EVENT_DIAL_STATE,
    /*! The state of a ringing trunk has changed */
    SLA_EVENT_RINGING_TRUNK,
};

sla_hold_access

enum sla_hold_access

Enumerator
SLA_HOLD_OPEN	This means that any station can put it on hold, and any station can retrieve the call from hold.
SLA_HOLD_PRIVATE	This means that only the station that put the call on hold may retrieve it from hold.

Definition at line 177 of file app_sla.c.

                     {
    /*! This means that any station can put it on hold, and any station
     * can retrieve the call from hold. */
    SLA_HOLD_OPEN,
    /*! This means that only the station that put the call on hold may
     * retrieve it from hold. */
    SLA_HOLD_PRIVATE,
};

sla_station_hangup

enum sla_station_hangup

Enumerator
SLA_STATION_HANGUP_NORMAL
SLA_STATION_HANGUP_TIMEOUT

Definition at line 317 of file app_sla.c.

                        {
    SLA_STATION_HANGUP_NORMAL,
    SLA_STATION_HANGUP_TIMEOUT,
};

sla_trunk_state

enum sla_trunk_state

Enumerator
SLA_TRUNK_STATE_IDLE
SLA_TRUNK_STATE_RINGING
SLA_TRUNK_STATE_UP
SLA_TRUNK_STATE_ONHOLD
SLA_TRUNK_STATE_ONHOLD_BYME

Definition at line 169 of file app_sla.c.

                     {
    SLA_TRUNK_STATE_IDLE,
    SLA_TRUNK_STATE_RINGING,
    SLA_TRUNK_STATE_UP,
    SLA_TRUNK_STATE_ONHOLD,
    SLA_TRUNK_STATE_ONHOLD_BYME,
};

sla_which_trunk_refs

enum sla_which_trunk_refs

Enumerator
ALL_TRUNK_REFS
INACTIVE_TRUNK_REFS

Definition at line 164 of file app_sla.c.

                          {
    ALL_TRUNK_REFS,
    INACTIVE_TRUNK_REFS,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2881 of file app_sla.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2881 of file app_sla.c.

answer_trunk_chan()

static void answer_trunk_chan ( struct ast_channel *  chan )

static

Definition at line 917 of file app_sla.c.

{
    ast_raw_answer(chan); /* Do NOT use ast_answer since that waits for media using ast_waitfor_nandfds. */
    ast_indicate(chan, -1);
}

References ast_indicate(), ast_raw_answer(), and sla_trunk_ref::chan.

Referenced by run_station(), sla_handle_dial_state_event(), and sla_station_exec().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 2881 of file app_sla.c.

attach_framehook()

static int attach_framehook ( struct ast_channel *  chan, const char *  confname  )

static

Definition at line 666 of file app_sla.c.

{
    struct ast_datastore *datastore;
    struct sla_framehook_data *data;
    static struct ast_framehook_interface sla_framehook_interface = {
        .version = AST_FRAMEHOOK_INTERFACE_VERSION,
        .event_cb = sla_framehook,
        .consume_cb = sla_framehook_consume,
        .disable_inheritance = 1,
    };
    SCOPED_CHANNELLOCK(chan_lock, chan);
 
    datastore = ast_channel_datastore_find(chan, &sla_framehook_datastore, NULL);
    if (datastore) {
        ast_log(AST_LOG_WARNING, "SLA framehook already set on '%s'\n", ast_channel_name(chan));
        return 0;
    }
 
    datastore = ast_datastore_alloc(&sla_framehook_datastore, NULL);
    if (!datastore) {
        return -1;
    }
 
    data = ast_calloc(1, sizeof(*data));
    if (!data) {
        ast_datastore_free(datastore);
        return -1;
    }
 
    data->framehook_id = ast_framehook_attach(chan, &sla_framehook_interface);
    data->confname = ast_strdup(confname);
    if (!data->confname || data->framehook_id < 0) {
        ast_log(AST_LOG_WARNING, "Failed to attach SLA framehook to '%s'\n", ast_channel_name(chan));
        ast_datastore_free(datastore);
        ast_free(data);
        return -1;
    }
    datastore->data = data;
 
    ast_channel_datastore_add(chan, datastore);
    return 0;
}

References ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_channel_name(), ast_datastore_alloc, ast_datastore_free(), ast_framehook_attach(), AST_FRAMEHOOK_INTERFACE_VERSION, ast_free, ast_log, AST_LOG_WARNING, ast_strdup, ast_datastore::data, ast_framehook_interface::data, NULL, SCOPED_CHANNELLOCK, sla_framehook(), sla_framehook_consume(), sla_framehook_datastore, and ast_framehook_interface::version.

Referenced by conf_run().

conf_kick_all()

static int conf_kick_all ( struct ast_channel *  chan, const char *  confname  )

static

Definition at line 958 of file app_sla.c.

{
    char confkick_args[256];
 
    snprintf(confkick_args, sizeof(confkick_args), "%s,all", confname);
    ast_debug(2, "Kicking all participants from conference %s\n", confname);
 
    if (chan) {
        return ast_pbx_exec_application(chan, "ConfKick", confkick_args);
    } else {
        /* We might not have a channel available to us, use a dummy channel in that case. */
        chan = ast_dummy_channel_alloc();
        if (!chan) {
            ast_log(LOG_WARNING, "Failed to allocate dummy channel\n");
            return -1;
        } else {
            int res = ast_pbx_exec_application(chan, "ConfKick", confkick_args);
            ast_channel_unref(chan);
            return res;
        }
    }
}

References ast_channel_unref, ast_debug, ast_dummy_channel_alloc, ast_log, ast_pbx_exec_application(), sla_trunk_ref::chan, and LOG_WARNING.

Referenced by run_station(), sla_station_exec(), and sla_stop_ringing_trunk().

conf_run()

static int conf_run ( struct ast_channel *  chan, const char *  confname, struct ast_flags *  confflags, char *  optargs[]  )

static

Definition at line 923 of file app_sla.c.

{
    char confbridge_args[256];
    int res = 0;
 
    snprintf(confbridge_args, sizeof(confbridge_args), "%s", confname);
 
    res |= ast_func_write(chan, "CONFBRIDGE(user,quiet)", ast_test_flag(confflags, CONFFLAG_QUIET) ? "1" : "0");
    res |= ast_func_write(chan, "CONFBRIDGE(user,dtmf_passthrough)", ast_test_flag(confflags, CONFFLAG_PASS_DTMF) ? "1" : "0");
    res |= ast_func_write(chan, "CONFBRIDGE(user,marked)", ast_test_flag(confflags, CONFFLAG_MARKEDUSER) ? "1" : "0");
    res |= ast_func_write(chan, "CONFBRIDGE(user,end_marked)", ast_test_flag(confflags, CONFFLAG_MARKEDEXIT) ? "1" : "0");
    res |= ast_func_write(chan, "CONFBRIDGE(user,music_on_hold_when_empty)", ast_test_flag(confflags, CONFFLAG_MOH) ? "1" : "0");
    if (ast_test_flag(confflags, CONFFLAG_MOH) && !ast_strlen_zero(optargs[SLA_TRUNK_OPT_ARG_MOH_CLASS])) {
        res |= ast_func_write(chan, "CONFBRIDGE(user,music_on_hold_class)", optargs[SLA_TRUNK_OPT_ARG_MOH_CLASS]);
    }
 
    if (res) {
        ast_log(LOG_ERROR, "Failed to set up conference, aborting\n");
        return -1;
    }
 
    /* Attach a framehook that we'll use to process HOLD from stations. */
    if (ast_test_flag(confflags, CONFFLAG_SLA_STATION) && attach_framehook(chan, confname)) {
        return -1;
    }
 
    ast_debug(2, "Channel %s is running ConfBridge(%s)\n", ast_channel_name(chan), confbridge_args);
    res = ast_pbx_exec_application(chan, "ConfBridge", confbridge_args);
 
    if (ast_test_flag(confflags, CONFFLAG_SLA_STATION)) {
        remove_framehook(chan);
    }
    return res;
}

References ast_channel_name(), ast_debug, ast_func_write(), ast_log, ast_pbx_exec_application(), ast_strlen_zero(), ast_test_flag, attach_framehook(), sla_trunk_ref::chan, CONFFLAG_MARKEDEXIT, CONFFLAG_MARKEDUSER, CONFFLAG_MOH, CONFFLAG_PASS_DTMF, CONFFLAG_QUIET, CONFFLAG_SLA_STATION, LOG_ERROR, remove_framehook(), and SLA_TRUNK_OPT_ARG_MOH_CLASS.

Referenced by dial_trunk(), run_station(), sla_station_exec(), and sla_trunk_exec().

create_trunk_ref()

static struct sla_trunk_ref * create_trunk_ref ( struct sla_trunk *  trunk )

static

Definition at line 2112 of file app_sla.c.

{
    struct sla_trunk_ref *trunk_ref;
 
    if (!(trunk_ref = ao2_alloc(sizeof(*trunk_ref), sla_trunk_ref_destructor))) {
        return NULL;
    }
 
    ao2_ref(trunk, 1);
    trunk_ref->trunk = trunk;
 
    return trunk_ref;
}

References ao2_alloc, ao2_ref, NULL, sla_trunk_ref_destructor(), and sla_trunk_ref::trunk.

Referenced by sla_add_trunk_to_station().

dial_trunk()

static void * dial_trunk ( void *  data )

static

Definition at line 1800 of file app_sla.c.

{
    struct dial_trunk_args *args = data;
    struct ast_dial *dial;
    char *tech, *tech_data;
    enum ast_dial_result dial_res;
    char conf_name[MAX_CONFNUM];
    struct ast_flags conf_flags = { 0 };
    RAII_VAR(struct sla_trunk_ref *, trunk_ref, args->trunk_ref, ao2_cleanup);
    RAII_VAR(struct sla_station *, station, args->station, ao2_cleanup);
    int caller_is_saved;
    struct ast_party_caller caller;
    int last_state = 0;
    int current_state = 0;
 
    if (!(dial = ast_dial_create())) {
        ast_mutex_lock(args->cond_lock);
        ast_cond_signal(args->cond);
        ast_mutex_unlock(args->cond_lock);
        return NULL;
    }
 
    tech_data = ast_strdupa(trunk_ref->trunk->device);
    tech = strsep(&tech_data, "/");
    if (ast_dial_append(dial, tech, tech_data, NULL) == -1) {
        ast_mutex_lock(args->cond_lock);
        ast_cond_signal(args->cond);
        ast_mutex_unlock(args->cond_lock);
        ast_dial_destroy(dial);
        return NULL;
    }
 
    /* Do we need to save of the caller ID data? */
    caller_is_saved = 0;
    if (!sla.attempt_callerid) {
        caller_is_saved = 1;
        caller = *ast_channel_caller(trunk_ref->chan);
        ast_party_caller_init(ast_channel_caller(trunk_ref->chan));
    }
 
    dial_res = ast_dial_run(dial, trunk_ref->chan, 1);
 
    /* Restore saved caller ID */
    if (caller_is_saved) {
        ast_party_caller_free(ast_channel_caller(trunk_ref->chan));
        ast_channel_caller_set(trunk_ref->chan, &caller);
    }
 
    if (dial_res != AST_DIAL_RESULT_TRYING) {
        ast_mutex_lock(args->cond_lock);
        ast_cond_signal(args->cond);
        ast_mutex_unlock(args->cond_lock);
        ast_dial_destroy(dial);
        return NULL;
    }
 
    /* Wait for dial to end, while servicing the channel */
    while (ast_waitfor(trunk_ref->chan, 100)) {
        unsigned int done = 0;
        struct ast_frame *fr = ast_read(trunk_ref->chan);
 
        if (!fr) {
            ast_debug(1, "Channel %s did not return a frame, must have hung up\n", ast_channel_name(trunk_ref->chan));
            done = 1;
            break;
        }
        ast_frfree(fr); /* Ignore while dialing */
 
        switch ((dial_res = ast_dial_state(dial))) {
        case AST_DIAL_RESULT_ANSWERED:
            trunk_ref->trunk->chan = ast_dial_answered(dial);
        case AST_DIAL_RESULT_HANGUP:
        case AST_DIAL_RESULT_INVALID:
        case AST_DIAL_RESULT_FAILED:
        case AST_DIAL_RESULT_TIMEOUT:
        case AST_DIAL_RESULT_UNANSWERED:
            done = 1;
            break;
        case AST_DIAL_RESULT_TRYING:
            current_state = AST_CONTROL_PROGRESS;
            break;
        case AST_DIAL_RESULT_RINGING:
        case AST_DIAL_RESULT_PROGRESS:
        case AST_DIAL_RESULT_PROCEEDING:
            current_state = AST_CONTROL_RINGING;
            break;
        }
        if (done) {
            break;
        }
 
        /* check that SLA station that originated trunk call is still alive */
        if (station && ast_device_state(station->device) == AST_DEVICE_NOT_INUSE) {
            ast_debug(3, "Originating station device %s no longer active\n", station->device);
            trunk_ref->trunk->chan = NULL;
            break;
        }
 
        /* If trunk line state changed, send indication back to originating SLA Station channel */
        if (current_state != last_state) {
            ast_debug(3, "Indicating State Change %d to channel %s\n", current_state, ast_channel_name(trunk_ref->chan));
            ast_indicate(trunk_ref->chan, current_state);
            last_state = current_state;
        }
    }
 
    if (!trunk_ref->trunk->chan) {
        ast_mutex_lock(args->cond_lock);
        ast_cond_signal(args->cond);
        ast_mutex_unlock(args->cond_lock);
        ast_dial_join(dial);
        ast_dial_destroy(dial);
        return NULL;
    }
 
    snprintf(conf_name, sizeof(conf_name), "SLA_%s", trunk_ref->trunk->name);
    ast_set_flag(&conf_flags, CONFFLAG_QUIET | CONFFLAG_MARKEDEXIT | CONFFLAG_MARKEDUSER | CONFFLAG_PASS_DTMF | CONFFLAG_SLA_TRUNK);
 
    ast_mutex_lock(args->cond_lock);
    ast_cond_signal(args->cond);
    ast_mutex_unlock(args->cond_lock);
 
    ast_debug(2, "Trunk dial %s joining conference %s\n", trunk_ref->trunk->name, conf_name);
    conf_run(trunk_ref->trunk->chan, conf_name, &conf_flags, NULL);
 
    /* If the trunk is going away, it is definitely now IDLE. */
    sla_change_trunk_state(trunk_ref->trunk, SLA_TRUNK_STATE_IDLE, ALL_TRUNK_REFS, NULL);
 
    trunk_ref->trunk->chan = NULL;
    trunk_ref->trunk->on_hold = 0;
 
    ast_dial_join(dial);
    ast_dial_destroy(dial);
 
    return NULL;
}

References ALL_TRUNK_REFS, ao2_cleanup, args, ast_channel_caller(), ast_channel_caller_set(), ast_channel_name(), ast_cond_signal, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, ast_debug, AST_DEVICE_NOT_INUSE, ast_dial_answered(), ast_dial_append(), ast_dial_create(), ast_dial_destroy(), ast_dial_join(), AST_DIAL_RESULT_ANSWERED, AST_DIAL_RESULT_FAILED, AST_DIAL_RESULT_HANGUP, AST_DIAL_RESULT_INVALID, AST_DIAL_RESULT_PROCEEDING, AST_DIAL_RESULT_PROGRESS, AST_DIAL_RESULT_RINGING, AST_DIAL_RESULT_TIMEOUT, AST_DIAL_RESULT_TRYING, AST_DIAL_RESULT_UNANSWERED, ast_dial_run(), ast_dial_state(), ast_frfree, ast_indicate(), ast_mutex_lock, ast_mutex_unlock, ast_party_caller_free(), ast_party_caller_init(), ast_read(), ast_set_flag, ast_strdupa, ast_waitfor(), conf_run(), CONFFLAG_MARKEDEXIT, CONFFLAG_MARKEDUSER, CONFFLAG_PASS_DTMF, CONFFLAG_QUIET, CONFFLAG_SLA_TRUNK, done, MAX_CONFNUM, NULL, RAII_VAR, sla, sla_change_trunk_state(), SLA_TRUNK_STATE_IDLE, and strsep().

Referenced by sla_station_exec().

load_config()

static int load_config ( int  reload )

static

Definition at line 2825 of file app_sla.c.

{
    return sla_load_config(reload);
}

References reload(), and sla_load_config().

Referenced by load_module(), and reload().

load_module()

static int load_module ( void  )

static

Load the module.

Module loading including tests for configuration or dependencies. This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE, or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails tests return AST_MODULE_LOAD_FAILURE. If the module can not load the configuration file or other non-critical problem return AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.

Definition at line 2855 of file app_sla.c.

{
    int res = 0;
 
    res |= load_config(0);
 
    ast_cli_register_multiple(cli_sla, ARRAY_LEN(cli_sla));
    res |= ast_register_application_xml(slastation_app, sla_station_exec);
    res |= ast_register_application_xml(slatrunk_app, sla_trunk_exec);
 
    res |= ast_devstate_prov_add("SLA", sla_state);
 
    return res;
}

References ARRAY_LEN, ast_cli_register_multiple, ast_devstate_prov_add(), ast_register_application_xml, cli_sla, load_config(), sla_state(), sla_station_exec(), sla_trunk_exec(), slastation_app, and slatrunk_app.

queue_ringing_trunk()

static struct sla_ringing_trunk * queue_ringing_trunk ( struct sla_trunk *  trunk )

static

Definition at line 2126 of file app_sla.c.

{
    struct sla_ringing_trunk *ringing_trunk;
 
    if (!(ringing_trunk = ast_calloc(1, sizeof(*ringing_trunk)))) {
        return NULL;
    }
 
    ao2_ref(trunk, 1);
    ringing_trunk->trunk = trunk;
    ringing_trunk->ring_begin = ast_tvnow();
 
    sla_change_trunk_state(trunk, SLA_TRUNK_STATE_RINGING, ALL_TRUNK_REFS, NULL);
 
    ast_mutex_lock(&sla.lock);
    AST_LIST_INSERT_HEAD(&sla.ringing_trunks, ringing_trunk, entry);
    ast_mutex_unlock(&sla.lock);
 
    sla_queue_event(SLA_EVENT_RINGING_TRUNK);
 
    return ringing_trunk;
}

References ALL_TRUNK_REFS, ao2_ref, ast_calloc, AST_LIST_INSERT_HEAD, ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), sla_ringing_trunk::entry, NULL, sla_ringing_trunk::ring_begin, sla, sla_change_trunk_state(), SLA_EVENT_RINGING_TRUNK, sla_queue_event(), SLA_TRUNK_STATE_RINGING, and sla_ringing_trunk::trunk.

Referenced by sla_trunk_exec().

reload()

static int reload ( void  )

static

Definition at line 2870 of file app_sla.c.

{
    return load_config(1);
}

References load_config().

Referenced by load_config(), and sla_load_config().

remove_framehook()

static int remove_framehook ( struct ast_channel *  chan )

static

Definition at line 620 of file app_sla.c.

{
    struct ast_datastore *datastore = NULL;
    struct sla_framehook_data *data;
    SCOPED_CHANNELLOCK(chan_lock, chan);
 
    datastore = ast_channel_datastore_find(chan, &sla_framehook_datastore, NULL);
    if (!datastore) {
        ast_log(AST_LOG_WARNING, "Cannot remove framehook from %s: HOLD_INTERCEPT not currently enabled\n", ast_channel_name(chan));
        return -1;
    }
    data = datastore->data;
 
    ast_free(data->confname);
 
    if (ast_framehook_detach(chan, data->framehook_id)) {
        ast_log(AST_LOG_WARNING, "Failed to remove framehook from channel %s\n", ast_channel_name(chan));
        return -1;
    }
    if (ast_channel_datastore_remove(chan, datastore)) {
        ast_log(AST_LOG_WARNING, "Failed to remove datastore from channel %s\n", ast_channel_name(chan));
        return -1;
    }
    ast_datastore_free(datastore);
 
    return 0;
}

References ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_name(), ast_datastore_free(), ast_framehook_detach(), ast_free, ast_log, AST_LOG_WARNING, sla_framehook_data::confname, ast_datastore::data, sla_framehook_data::framehook_id, NULL, SCOPED_CHANNELLOCK, and sla_framehook_datastore.

Referenced by conf_run().

run_station()

static void * run_station ( void *  data )

static

Definition at line 981 of file app_sla.c.

{
    RAII_VAR(struct sla_station *, station, NULL, ao2_cleanup);
    RAII_VAR(struct sla_trunk_ref *, trunk_ref, NULL, ao2_cleanup);
    struct ast_str *conf_name = ast_str_create(16);
    struct ast_flags conf_flags = { 0 };
 
    {
        struct run_station_args *args = data;
        station = args->station;
        trunk_ref = args->trunk_ref;
        ast_mutex_lock(args->cond_lock);
        ast_cond_signal(args->cond);
        ast_mutex_unlock(args->cond_lock);
        /* args is no longer valid here. */
    }
 
    ast_atomic_fetchadd_int((int *) &trunk_ref->trunk->active_stations, 1);
    ast_str_set(&conf_name, 0, "SLA_%s", trunk_ref->trunk->name);
    ast_set_flag(&conf_flags, CONFFLAG_QUIET | CONFFLAG_MARKEDEXIT | CONFFLAG_PASS_DTMF | CONFFLAG_SLA_STATION);
    answer_trunk_chan(trunk_ref->chan);
 
    ast_debug(2, "Station %s joining conference %s\n", station->name, ast_str_buffer(conf_name));
    conf_run(trunk_ref->chan, ast_str_buffer(conf_name), &conf_flags, NULL);
 
    trunk_ref->chan = NULL;
    if (ast_atomic_dec_and_test((int *) &trunk_ref->trunk->active_stations) &&
        trunk_ref->state != SLA_TRUNK_STATE_ONHOLD_BYME) {
        conf_kick_all(NULL, ast_str_buffer(conf_name));
        trunk_ref->trunk->hold_stations = 0;
        sla_change_trunk_state(trunk_ref->trunk, SLA_TRUNK_STATE_IDLE, ALL_TRUNK_REFS, NULL);
    }
 
    ast_dial_join(station->dial);
    ast_dial_destroy(station->dial);
    station->dial = NULL;
    ast_free(conf_name);
 
    return NULL;
}

References sla_trunk::active_stations, ALL_TRUNK_REFS, answer_trunk_chan(), ao2_cleanup, args, ast_atomic_dec_and_test(), ast_atomic_fetchadd_int(), ast_cond_signal, ast_debug, ast_dial_destroy(), ast_dial_join(), ast_free, ast_mutex_lock, ast_mutex_unlock, ast_set_flag, ast_str_buffer(), ast_str_create, ast_str_set(), sla_trunk_ref::chan, conf_kick_all(), conf_run(), CONFFLAG_MARKEDEXIT, CONFFLAG_PASS_DTMF, CONFFLAG_QUIET, CONFFLAG_SLA_STATION, sla_station::dial, sla_trunk::hold_stations, sla_trunk::name, NULL, RAII_VAR, sla_change_trunk_state(), SLA_TRUNK_STATE_IDLE, SLA_TRUNK_STATE_ONHOLD_BYME, sla_trunk_ref::state, run_station_args::station, sla_trunk_ref::trunk, and run_station_args::trunk_ref.

Referenced by sla_handle_dial_state_event().

sla_add_trunk_to_station()

static void sla_add_trunk_to_station ( struct sla_station *  station, struct ast_variable *  var  )

static

Definition at line 2478 of file app_sla.c.

{
    RAII_VAR(struct sla_trunk *, trunk, NULL, ao2_cleanup);
    struct sla_trunk_ref *trunk_ref = NULL;
    struct sla_station_ref *station_ref;
    char *trunk_name, *options, *cur;
    int existing_trunk_ref = 0;
    int existing_station_ref = 0;
 
    options = ast_strdupa(var->value);
    trunk_name = strsep(&options, ",");
 
    trunk = sla_find_trunk(trunk_name);
    if (!trunk) {
        ast_log(LOG_ERROR, "Trunk '%s' not found!\n", var->value);
        return;
    }
 
    AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
        if (trunk_ref->trunk == trunk) {
            trunk_ref->mark = 0;
            existing_trunk_ref = 1;
            break;
        }
    }
 
    if (!trunk_ref && !(trunk_ref = create_trunk_ref(trunk))) {
        return;
    }
 
    trunk_ref->state = SLA_TRUNK_STATE_IDLE;
 
    while ((cur = strsep(&options, ","))) {
        char *name, *value = cur;
        name = strsep(&value, "=");
        if (!strcasecmp(name, "ringtimeout")) {
            if (sscanf(value, "%30u", &trunk_ref->ring_timeout) != 1) {
                ast_log(LOG_WARNING, "Invalid ringtimeout value '%s' for trunk '%s' on station '%s'\n", value, trunk->name, station->name);
                trunk_ref->ring_timeout = 0;
            }
        } else if (!strcasecmp(name, "ringdelay")) {
            if (sscanf(value, "%30u", &trunk_ref->ring_delay) != 1) {
                ast_log(LOG_WARNING, "Invalid ringdelay value '%s' for trunk '%s' on station '%s'\n", value, trunk->name, station->name);
                trunk_ref->ring_delay = 0;
            }
        } else {
            ast_log(LOG_WARNING, "Invalid option '%s' for trunk '%s' on station '%s'\n", name, trunk->name, station->name);
        }
    }
 
    AST_LIST_TRAVERSE(&trunk->stations, station_ref, entry) {
        if (station_ref->station == station) {
            station_ref->mark = 0;
            existing_station_ref = 1;
            break;
        }
    }
 
    if (!station_ref && !(station_ref = sla_create_station_ref(station))) {
        if (!existing_trunk_ref) {
            ao2_ref(trunk_ref, -1);
        } else {
            trunk_ref->mark = 1;
        }
        return;
    }
 
    if (!existing_station_ref) {
        ao2_lock(trunk);
        AST_LIST_INSERT_TAIL(&trunk->stations, station_ref, entry);
        ast_atomic_fetchadd_int((int *) &trunk->num_stations, 1);
        ao2_unlock(trunk);
    }
 
    if (!existing_trunk_ref) {
        ao2_lock(station);
        AST_LIST_INSERT_TAIL(&station->trunks, trunk_ref, entry);
        ao2_unlock(station);
    }
}

References ao2_cleanup, ao2_lock, ao2_ref, ao2_unlock, ast_atomic_fetchadd_int(), AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log, ast_strdupa, create_trunk_ref(), sla_station_ref::entry, LOG_ERROR, LOG_WARNING, sla_station_ref::mark, sla_trunk_ref::mark, name, NULL, options, RAII_VAR, sla_trunk_ref::ring_delay, sla_trunk_ref::ring_timeout, sla_create_station_ref(), sla_find_trunk(), SLA_TRUNK_STATE_IDLE, sla_trunk_ref::state, sla_station_ref::station, strsep(), sla_trunk_ref::trunk, sla_station::trunks, value, and var.

Referenced by sla_build_station().

sla_build_station()

static int sla_build_station ( struct ast_config *  cfg, const char *  cat  )

static

Definition at line 2559 of file app_sla.c.

{
    RAII_VAR(struct sla_station *, station, NULL, ao2_cleanup);
    struct ast_variable *var;
    const char *dev;
    int existing_station = 0;
 
    if (!(dev = ast_variable_retrieve(cfg, cat, "device"))) {
        ast_log(LOG_ERROR, "SLA Station '%s' defined with no device!\n", cat);
        return -1;
    }
 
    if ((station = sla_find_station(cat))) {
        station->mark = 0;
        existing_station = 1;
    } else if ((station = ao2_alloc(sizeof(*station), sla_station_destructor))) {
        if (ast_string_field_init(station, 32)) {
            return -1;
        }
        ast_string_field_set(station, name, cat);
    } else {
        return -1;
    }
 
    ao2_lock(station);
 
    ast_string_field_set(station, device, dev);
 
    for (var = ast_variable_browse(cfg, cat); var; var = var->next) {
        if (!strcasecmp(var->name, "trunk")) {
            ao2_unlock(station);
            sla_add_trunk_to_station(station, var);
            ao2_lock(station);
        } else if (!strcasecmp(var->name, "autocontext")) {
            ast_string_field_set(station, autocontext, var->value);
        } else if (!strcasecmp(var->name, "ringtimeout")) {
            if (sscanf(var->value, "%30u", &station->ring_timeout) != 1) {
                ast_log(LOG_WARNING, "Invalid ringtimeout '%s' specified for station '%s'\n", var->value, station->name);
                station->ring_timeout = 0;
            }
        } else if (!strcasecmp(var->name, "ringdelay")) {
            if (sscanf(var->value, "%30u", &station->ring_delay) != 1) {
                ast_log(LOG_WARNING, "Invalid ringdelay '%s' specified for station '%s'\n", var->value, station->name);
                station->ring_delay = 0;
            }
        } else if (!strcasecmp(var->name, "hold")) {
            if (!strcasecmp(var->value, "private")) {
                station->hold_access = SLA_HOLD_PRIVATE;
            } else if (!strcasecmp(var->value, "open")) {
                station->hold_access = SLA_HOLD_OPEN;
            } else {
                ast_log(LOG_WARNING, "Invalid value '%s' for hold on station %s\n", var->value, station->name);
            }
        } else if (strcasecmp(var->name, "type") && strcasecmp(var->name, "device")) {
            ast_log(LOG_ERROR, "Invalid option '%s' specified at line %d of %s!\n", var->name, var->lineno, SLA_CONFIG_FILE);
        }
    }
 
    ao2_unlock(station);
 
    if (!ast_strlen_zero(station->autocontext)) {
        struct sla_trunk_ref *trunk_ref;
 
        if (!ast_context_find_or_create(NULL, NULL, station->autocontext, sla_registrar)) {
            ast_log(LOG_ERROR, "Failed to automatically find or create context '%s' for SLA!\n", station->autocontext);
            return -1;
        }
        /* The extension for when the handset goes off-hook.
         * exten => station1,1,SLAStation(station1) */
        if (ast_add_extension(station->autocontext, 0 /* don't replace */, station->name, 1,
            NULL, NULL, slastation_app, ast_strdup(station->name), ast_free_ptr, sla_registrar)) {
            ast_log(LOG_ERROR, "Failed to automatically create extension for trunk '%s'!\n", station->name);
            return -1;
        }
        AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
            char exten[AST_MAX_EXTENSION];
            char hint[AST_MAX_EXTENSION + 5];
            snprintf(exten, sizeof(exten), "%s_%s", station->name, trunk_ref->trunk->name);
            snprintf(hint, sizeof(hint), "SLA:%s", exten);
            /* Extension for this line button
             * exten => station1_line1,1,SLAStation(station1_line1) */
            if (ast_add_extension(station->autocontext, 0 /* don't replace */, exten, 1,
                NULL, NULL, slastation_app, ast_strdup(exten), ast_free_ptr, sla_registrar)) {
                ast_log(LOG_ERROR, "Failed to automatically create extension for trunk '%s'!\n", station->name);
                return -1;
            }
            /* Hint for this line button
             * exten => station1_line1,hint,SLA:station1_line1 */
            if (ast_add_extension(station->autocontext, 0 /* don't replace */, exten, PRIORITY_HINT,
                NULL, NULL, hint, NULL, NULL, sla_registrar)) {
                ast_log(LOG_ERROR, "Failed to automatically create hint for trunk '%s'!\n", station->name);
                return -1;
            }
        }
    }
 
    if (!existing_station) {
        ao2_link(sla_stations, station);
    }
 
    return 0;
}

References ao2_alloc, ao2_cleanup, ao2_link, ao2_lock, ao2_unlock, ast_add_extension(), ast_context_find_or_create(), ast_free_ptr(), AST_LIST_TRAVERSE, ast_log, AST_MAX_EXTENSION, ast_strdup, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_variable_browse(), ast_variable_retrieve(), sla_trunk_ref::entry, LOG_ERROR, LOG_WARNING, name, sla_trunk::name, NULL, PRIORITY_HINT, RAII_VAR, sla_add_trunk_to_station(), SLA_CONFIG_FILE, sla_find_station(), SLA_HOLD_OPEN, SLA_HOLD_PRIVATE, sla_registrar, sla_station_destructor(), sla_stations, slastation_app, sla_station_ref::station, sla_trunk_ref::trunk, and var.

Referenced by sla_load_config().

sla_build_trunk()

static int sla_build_trunk ( struct ast_config *  cfg, const char *  cat  )

static

Definition at line 2396 of file app_sla.c.

{
    RAII_VAR(struct sla_trunk *, trunk, NULL, ao2_cleanup);
    struct ast_variable *var;
    const char *dev;
    int existing_trunk = 0;
 
    if (!(dev = ast_variable_retrieve(cfg, cat, "device"))) {
        ast_log(LOG_ERROR, "SLA Trunk '%s' defined with no device!\n", cat);
        return -1;
    }
 
    if (sla_check_device(dev)) {
        ast_log(LOG_ERROR, "SLA Trunk '%s' defined with invalid device '%s'!\n", cat, dev);
        return -1;
    }
 
    if ((trunk = sla_find_trunk(cat))) {
        trunk->mark = 0;
        existing_trunk = 1;
    } else if ((trunk = ao2_alloc(sizeof(*trunk), sla_trunk_destructor))) {
        if (ast_string_field_init(trunk, 32)) {
            return -1;
        }
        ast_string_field_set(trunk, name, cat);
    } else {
        return -1;
    }
 
    ao2_lock(trunk);
 
    ast_string_field_set(trunk, device, dev);
 
    for (var = ast_variable_browse(cfg, cat); var; var = var->next) {
        if (!strcasecmp(var->name, "autocontext")) {
            ast_string_field_set(trunk, autocontext, var->value);
        } else if (!strcasecmp(var->name, "ringtimeout")) {
            if (sscanf(var->value, "%30u", &trunk->ring_timeout) != 1) {
                ast_log(LOG_WARNING, "Invalid ringtimeout '%s' specified for trunk '%s'\n", var->value, trunk->name);
                trunk->ring_timeout = 0;
            }
        } else if (!strcasecmp(var->name, "barge")) {
            trunk->barge_disabled = ast_false(var->value);
        } else if (!strcasecmp(var->name, "hold")) {
            if (!strcasecmp(var->value, "private")) {
                trunk->hold_access = SLA_HOLD_PRIVATE;
            } else if (!strcasecmp(var->value, "open")) {
                trunk->hold_access = SLA_HOLD_OPEN;
            } else {
                ast_log(LOG_WARNING, "Invalid value '%s' for hold on trunk %s\n", var->value, trunk->name);
            }
        } else if (strcasecmp(var->name, "type") && strcasecmp(var->name, "device")) {
            ast_log(LOG_ERROR, "Invalid option '%s' specified at line %d of %s!\n", var->name, var->lineno, SLA_CONFIG_FILE);
        }
    }
 
    ao2_unlock(trunk);
 
    if (!ast_strlen_zero(trunk->autocontext)) {
        if (!ast_context_find_or_create(NULL, NULL, trunk->autocontext, sla_registrar)) {
            ast_log(LOG_ERROR, "Failed to automatically find or create context '%s' for SLA!\n", trunk->autocontext);
            return -1;
        }
 
        if (ast_add_extension(trunk->autocontext, 0 /* don't replace */, "s", 1,
            NULL, NULL, slatrunk_app, ast_strdup(trunk->name), ast_free_ptr, sla_registrar)) {
            ast_log(LOG_ERROR, "Failed to automatically create extension for trunk '%s'!\n", trunk->name);
            return -1;
        }
    }
 
    if (!existing_trunk) {
        ao2_link(sla_trunks, trunk);
    }
 
    return 0;
}

References ao2_alloc, ao2_cleanup, ao2_link, ao2_lock, ao2_unlock, ast_add_extension(), ast_context_find_or_create(), ast_false(), ast_free_ptr(), ast_log, ast_strdup, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_variable_browse(), ast_variable_retrieve(), LOG_ERROR, LOG_WARNING, name, NULL, RAII_VAR, sla_check_device(), SLA_CONFIG_FILE, sla_find_trunk(), SLA_HOLD_OPEN, SLA_HOLD_PRIVATE, sla_registrar, sla_trunk_destructor(), sla_trunks, slatrunk_app, and var.

Referenced by sla_load_config().

sla_calc_station_delays()

static int sla_calc_station_delays ( unsigned int *  timeout )

static

Calculate the ring delay for a station.

Note

Assumes sla.lock is locked

Definition at line 1631 of file app_sla.c.

{
    struct sla_station *station;
    int res = 0;
    struct ao2_iterator i;
 
    i = ao2_iterator_init(sla_stations, 0);
    for (; (station = ao2_iterator_next(&i)); ao2_ref(station, -1)) {
        struct sla_ringing_trunk *ringing_trunk;
        int time_left;
 
        /* Ignore stations already ringing */
        if (sla_check_ringing_station(station)) {
            continue;
        }
 
        /* Ignore stations already on a call */
        if (sla_check_inuse_station(station)) {
            continue;
        }
 
        /* Ignore stations that don't have one of their trunks ringing */
        if (!(ringing_trunk = sla_choose_ringing_trunk(station, NULL, 0))) {
            continue;
        }
 
        if ((time_left = sla_check_station_delay(station, ringing_trunk)) == INT_MAX) {
            continue;
        }
 
        /* If there is no time left, then the station needs to start ringing.
         * Return non-zero so that an event will be queued up an event to
         * make that happen. */
        if (time_left <= 0) {
            res = 1;
            continue;
        }
 
        if (time_left < *timeout) {
            *timeout = time_left;
        }
    }
    ao2_iterator_destroy(&i);
 
    return res;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, NULL, sla_check_inuse_station(), sla_check_ringing_station(), sla_check_station_delay(), sla_choose_ringing_trunk(), and sla_stations.

Referenced by sla_process_timers().

sla_calc_station_timeouts()

static int sla_calc_station_timeouts ( unsigned int *  timeout )

static

Process station ring timeouts.

Note

Called with sla.lock locked

Returns

non-zero if a change to the ringing stations was made

Definition at line 1539 of file app_sla.c.

{
    struct sla_ringing_trunk *ringing_trunk;
    struct sla_ringing_station *ringing_station;
    int res = 0;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&sla.ringing_stations, ringing_station, entry) {
        unsigned int ring_timeout = 0;
        int time_elapsed, time_left = INT_MAX, final_trunk_time_left = INT_MIN;
        struct sla_trunk_ref *trunk_ref;
 
        /* If there are any ring timeouts specified for a specific trunk
         * on the station, then use the highest per-trunk ring timeout.
         * Otherwise, use the ring timeout set for the entire station. */
        AST_LIST_TRAVERSE(&ringing_station->station->trunks, trunk_ref, entry) {
            struct sla_station_ref *station_ref;
            int trunk_time_elapsed, trunk_time_left;
 
            AST_LIST_TRAVERSE(&sla.ringing_trunks, ringing_trunk, entry) {
                if (ringing_trunk->trunk == trunk_ref->trunk) {
                    break;
                }
            }
            if (!ringing_trunk) {
                continue;
            }
 
            /* If there is a trunk that is ringing without a timeout, then the
             * only timeout that could matter is a global station ring timeout. */
            if (!trunk_ref->ring_timeout) {
                break;
            }
 
            /* This trunk on this station is ringing and has a timeout.
             * However, make sure this trunk isn't still ringing from a
             * previous timeout.  If so, don't consider it. */
            AST_LIST_TRAVERSE(&ringing_trunk->timed_out_stations, station_ref, entry) {
                if (station_ref->station == ringing_station->station) {
                    break;
                }
            }
            if (station_ref) {
                continue;
            }
 
            trunk_time_elapsed = ast_tvdiff_ms(ast_tvnow(), ringing_trunk->ring_begin);
            trunk_time_left = (trunk_ref->ring_timeout * 1000) - trunk_time_elapsed;
            if (trunk_time_left > final_trunk_time_left) {
                final_trunk_time_left = trunk_time_left;
            }
        }
 
        /* No timeout was found for ringing trunks, and no timeout for the entire station */
        if (final_trunk_time_left == INT_MIN && !ringing_station->station->ring_timeout) {
            continue;
        }
 
        /* Compute how much time is left for a global station timeout */
        if (ringing_station->station->ring_timeout) {
            ring_timeout = ringing_station->station->ring_timeout;
            time_elapsed = ast_tvdiff_ms(ast_tvnow(), ringing_station->ring_begin);
            time_left = (ring_timeout * 1000) - time_elapsed;
        }
 
        /* If the time left based on the per-trunk timeouts is smaller than the
         * global station ring timeout, use that. */
        if (final_trunk_time_left > INT_MIN && final_trunk_time_left < time_left) {
            time_left = final_trunk_time_left;
        }
 
        /* If there is no time left, the station needs to stop ringing */
        if (time_left <= 0) {
            AST_LIST_REMOVE_CURRENT(entry);
            sla_stop_ringing_station(ringing_station, SLA_STATION_HANGUP_TIMEOUT);
            res = 1;
            continue;
        }
 
        /* There is still some time left for this station to ring, so save that
         * timeout if it is the first event scheduled to occur */
        if (time_left < *timeout) {
            *timeout = time_left;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    return res;
}

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_tvdiff_ms(), ast_tvnow(), sla_station_ref::entry, sla_trunk_ref::entry, sla_ringing_station::entry, sla_ringing_trunk::ring_begin, sla_ringing_station::ring_begin, sla_station::ring_timeout, sla_trunk_ref::ring_timeout, sla, SLA_STATION_HANGUP_TIMEOUT, sla_stop_ringing_station(), sla_station_ref::station, sla_ringing_station::station, sla_ringing_trunk::timed_out_stations, sla_trunk_ref::trunk, sla_ringing_trunk::trunk, and sla_station::trunks.

Referenced by sla_process_timers().

sla_calc_trunk_timeouts()

static int sla_calc_trunk_timeouts ( unsigned int *  timeout )

static

Process trunk ring timeouts.

Note

Called with sla.lock locked

Returns

non-zero if a change to the ringing trunks was made

Definition at line 1507 of file app_sla.c.

{
    struct sla_ringing_trunk *ringing_trunk;
    int res = 0;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&sla.ringing_trunks, ringing_trunk, entry) {
        int time_left, time_elapsed;
        if (!ringing_trunk->trunk->ring_timeout) {
            continue;
        }
        time_elapsed = ast_tvdiff_ms(ast_tvnow(), ringing_trunk->ring_begin);
        time_left = (ringing_trunk->trunk->ring_timeout * 1000) - time_elapsed;
        if (time_left <= 0) {
            pbx_builtin_setvar_helper(ringing_trunk->trunk->chan, "SLATRUNK_STATUS", "RINGTIMEOUT");
            AST_LIST_REMOVE_CURRENT(entry);
            sla_stop_ringing_trunk(ringing_trunk);
            res = 1;
            continue;
        }
        if (time_left < *timeout) {
            *timeout = time_left;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    return res;
}

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_tvdiff_ms(), ast_tvnow(), sla_trunk::chan, sla_ringing_trunk::entry, pbx_builtin_setvar_helper(), sla_ringing_trunk::ring_begin, sla_trunk::ring_timeout, sla, sla_stop_ringing_trunk(), and sla_ringing_trunk::trunk.

Referenced by sla_process_timers().

sla_change_trunk_state()

static void sla_change_trunk_state ( const struct sla_trunk *  trunk, enum sla_trunk_state  state, enum sla_which_trunk_refs  inactive_only, const struct sla_trunk_ref *  exclude  )

static

Definition at line 886 of file app_sla.c.

{
    struct sla_station *station;
    struct sla_trunk_ref *trunk_ref;
    struct ao2_iterator i;
 
    i = ao2_iterator_init(sla_stations, 0);
    while ((station = ao2_iterator_next(&i))) {
        ao2_lock(station);
        AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
            if (trunk_ref->trunk != trunk || (inactive_only ? trunk_ref->chan : 0) || trunk_ref == exclude) {
                continue;
            }
            trunk_ref->state = state;
            ast_devstate_changed(sla_state_to_devstate(state), AST_DEVSTATE_CACHABLE, "SLA:%s_%s", station->name, trunk->name);
            break;
        }
        ao2_unlock(station);
        ao2_ref(station, -1);
    }
    ao2_iterator_destroy(&i);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), AST_LIST_TRAVERSE, sla_trunk_ref::chan, sla_trunk::name, sla_state_to_devstate(), sla_stations, sla_trunk_ref::state, state, sla_trunk_ref::trunk, and sla_station::trunks.

Referenced by dial_trunk(), queue_ringing_trunk(), run_station(), sla_handle_dial_state_event(), sla_handle_hold_event(), sla_station_exec(), sla_stop_ringing_trunk(), and sla_trunk_exec().

sla_check_device()

static int sla_check_device ( const char *  device )

static

Definition at line 2367 of file app_sla.c.

{
    char *tech, *tech_data;
 
    tech_data = ast_strdupa(device);
    tech = strsep(&tech_data, "/");
 
    if (ast_strlen_zero(tech) || ast_strlen_zero(tech_data)) {
        return -1;
    }
 
    return 0;
}

References ast_strdupa, ast_strlen_zero(), and strsep().

Referenced by sla_build_trunk().

sla_check_failed_station()

static int sla_check_failed_station ( const struct sla_station *  station )

static

Check to see if this station has failed to be dialed in the past minute.

Note

assumes sla.lock is locked

Definition at line 1245 of file app_sla.c.

{
    struct sla_failed_station *failed_station;
    int res = 0;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&sla.failed_stations, failed_station, entry) {
        if (station != failed_station->station) {
            continue;
        }
        if (ast_tvdiff_ms(ast_tvnow(), failed_station->last_try) > 1000) {
            AST_LIST_REMOVE_CURRENT(entry);
            sla_failed_station_destroy(failed_station);
            break;
        }
        res = 1;
    }
    AST_LIST_TRAVERSE_SAFE_END
 
    return res;
}

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_tvdiff_ms(), ast_tvnow(), sla_failed_station::entry, sla_failed_station::last_try, sla, sla_failed_station_destroy(), and sla_failed_station::station.

Referenced by sla_ring_stations().

sla_check_inuse_station()

static int sla_check_inuse_station ( const struct sla_station *  station )

static

Check to see if a station is in use.

Definition at line 1330 of file app_sla.c.

{
    struct sla_trunk_ref *trunk_ref;
 
    AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
        if (trunk_ref->chan) {
            return 1;
        }
    }
 
    return 0;
}

References AST_LIST_TRAVERSE, sla_trunk_ref::chan, sla_trunk_ref::entry, and sla_station::trunks.

Referenced by sla_calc_station_delays(), and sla_ring_stations().

sla_check_ringing_station()

static int sla_check_ringing_station ( const struct sla_station *  station )

static

Check to see if this station is already ringing.

Note

Assumes sla.lock is locked

Definition at line 1229 of file app_sla.c.

{
    struct sla_ringing_station *ringing_station;
 
    AST_LIST_TRAVERSE(&sla.ringing_stations, ringing_station, entry) {
        if (station == ringing_station->station) {
            return 1;
        }
    }
 
    return 0;
}

References AST_LIST_TRAVERSE, sla_ringing_station::entry, sla, and sla_ringing_station::station.

Referenced by sla_calc_station_delays(), and sla_ring_stations().

sla_check_station_delay()

static int sla_check_station_delay ( struct sla_station *  station, struct sla_ringing_trunk *  ringing_trunk  )

static

Calculate the ring delay for a given ringing trunk on a station.

Parameters

station	the station
ringing_trunk	the trunk. If NULL, the highest priority ringing trunk will be used

Returns

the number of ms left before the delay is complete, or INT_MAX if there is no delay

Definition at line 1363 of file app_sla.c.

{
    RAII_VAR(struct sla_trunk_ref *, trunk_ref, NULL, ao2_cleanup);
    unsigned int delay = UINT_MAX;
    int time_left, time_elapsed;
 
    if (!ringing_trunk) {
        ringing_trunk = sla_choose_ringing_trunk(station, &trunk_ref, 0);
    } else {
        trunk_ref = sla_find_trunk_ref(station, ringing_trunk->trunk);
    }
 
    if (!ringing_trunk || !trunk_ref) {
        return delay;
    }
 
    /* If this station has a ring delay specific to the highest priority
     * ringing trunk, use that.  Otherwise, use the ring delay specified
     * globally for the station. */
    delay = trunk_ref->ring_delay;
    if (!delay) {
        delay = station->ring_delay;
    }
    if (!delay) {
        return INT_MAX;
    }
 
    time_elapsed = ast_tvdiff_ms(ast_tvnow(), ringing_trunk->ring_begin);
    time_left = (delay * 1000) - time_elapsed;
 
    return time_left;
}

References ao2_cleanup, ast_tvdiff_ms(), ast_tvnow(), NULL, RAII_VAR, sla_ringing_trunk::ring_begin, sla_station::ring_delay, sla_choose_ringing_trunk(), sla_find_trunk_ref(), and sla_ringing_trunk::trunk.

Referenced by sla_calc_station_delays(), and sla_ring_stations().

sla_check_station_hold_access()

static int sla_check_station_hold_access ( const struct sla_trunk *  trunk, const struct sla_station *  station  )

static

Definition at line 735 of file app_sla.c.

{
    struct sla_station_ref *station_ref;
    struct sla_trunk_ref *trunk_ref;
 
    /* For each station that has this call on hold, check for private hold. */
    AST_LIST_TRAVERSE(&trunk->stations, station_ref, entry) {
        AST_LIST_TRAVERSE(&station_ref->station->trunks, trunk_ref, entry) {
            if (trunk_ref->trunk != trunk || station_ref->station == station) {
                continue;
            }
            if (trunk_ref->state == SLA_TRUNK_STATE_ONHOLD_BYME && station_ref->station->hold_access == SLA_HOLD_PRIVATE) {
                return 1;
            }
            return 0;
        }
    }
 
    return 0;
}

References AST_LIST_TRAVERSE, sla_trunk_ref::entry, sla_station::hold_access, SLA_HOLD_PRIVATE, SLA_TRUNK_STATE_ONHOLD_BYME, sla_trunk_ref::state, sla_station_ref::station, sla_trunk::stations, sla_trunk_ref::trunk, and sla_station::trunks.

Referenced by sla_find_trunk_ref_byname().

sla_check_timed_out_station()

static int sla_check_timed_out_station ( const struct sla_ringing_trunk *  ringing_trunk, const struct sla_station *  station  )

static

Check to see if dialing this station already timed out for this ringing trunk.

Note

Assumes sla.lock is locked

Definition at line 1084 of file app_sla.c.

{
    struct sla_station_ref *timed_out_station;
 
    AST_LIST_TRAVERSE(&ringing_trunk->timed_out_stations, timed_out_station, entry) {
        if (station == timed_out_station->station) {
            return 1;
        }
    }
 
    return 0;
}

References AST_LIST_TRAVERSE, sla_station_ref::entry, sla_station_ref::station, and sla_ringing_trunk::timed_out_stations.

Referenced by sla_choose_ringing_trunk(), and sla_ring_stations().

sla_choose_idle_trunk()

static struct sla_trunk_ref * sla_choose_idle_trunk ( const struct sla_station *  station )

static

For a given station, choose the highest priority idle trunk.

Precondition

sla_station is locked

Definition at line 1941 of file app_sla.c.

{
    struct sla_trunk_ref *trunk_ref = NULL;
 
    AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
        if (trunk_ref->state == SLA_TRUNK_STATE_IDLE) {
            ao2_ref(trunk_ref, 1);
            break;
        }
    }
 
    return trunk_ref;
}

References ao2_ref, AST_LIST_TRAVERSE, sla_trunk_ref::entry, NULL, SLA_TRUNK_STATE_IDLE, sla_trunk_ref::state, and sla_station::trunks.

Referenced by sla_station_exec().

sla_choose_ringing_trunk()

static struct sla_ringing_trunk * sla_choose_ringing_trunk ( struct sla_station *  station, struct sla_trunk_ref **  trunk_ref, int  rm  )

static

Choose the highest priority ringing trunk for a station.

Parameters

station	the station
rm	remove the ringing trunk once selected
trunk_ref	a place to store the pointer to this stations reference to the selected trunk

Returns

a pointer to the selected ringing trunk, or NULL if none found

Note

Assumes that sla.lock is locked

Definition at line 1105 of file app_sla.c.

{
    struct sla_trunk_ref *s_trunk_ref;
    struct sla_ringing_trunk *ringing_trunk = NULL;
 
    AST_LIST_TRAVERSE(&station->trunks, s_trunk_ref, entry) {
        AST_LIST_TRAVERSE_SAFE_BEGIN(&sla.ringing_trunks, ringing_trunk, entry) {
            /* Make sure this is the trunk we're looking for */
            if (s_trunk_ref->trunk != ringing_trunk->trunk) {
                continue;
            }
 
            /* This trunk on the station is ringing.  But, make sure this station
             * didn't already time out while this trunk was ringing. */
            if (sla_check_timed_out_station(ringing_trunk, station)) {
                continue;
            }
 
            if (rm) {
                AST_LIST_REMOVE_CURRENT(entry);
            }
 
            if (trunk_ref) {
                ao2_ref(s_trunk_ref, 1);
                *trunk_ref = s_trunk_ref;
            }
 
            break;
        }
        AST_LIST_TRAVERSE_SAFE_END;
 
        if (ringing_trunk) {
            break;
        }
    }
 
    return ringing_trunk;
}

References ao2_ref, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, sla_ringing_trunk::entry, NULL, sla, sla_check_timed_out_station(), sla_trunk_ref::trunk, sla_ringing_trunk::trunk, and sla_station::trunks.

Referenced by sla_calc_station_delays(), sla_check_station_delay(), and sla_handle_dial_state_event().

sla_create_failed_station()

static struct sla_failed_station * sla_create_failed_station ( struct sla_station *  station )

static

Definition at line 844 of file app_sla.c.

{
    struct sla_failed_station *failed_station;
 
    if (!(failed_station = ast_calloc(1, sizeof(*failed_station)))) {
        return NULL;
    }
 
    ao2_ref(station, 1);
    failed_station->station = station;
    failed_station->last_try = ast_tvnow();
 
    return failed_station;
}

References ao2_ref, ast_calloc, ast_tvnow(), sla_failed_station::last_try, NULL, and sla_failed_station::station.

Referenced by sla_ring_station().

sla_create_ringing_station()

static struct sla_ringing_station * sla_create_ringing_station ( struct sla_station *  station )

static

Definition at line 819 of file app_sla.c.

{
    struct sla_ringing_station *ringing_station;
 
    if (!(ringing_station = ast_calloc(1, sizeof(*ringing_station)))) {
        return NULL;
    }
 
    ao2_ref(station, 1);
    ringing_station->station = station;
    ringing_station->ring_begin = ast_tvnow();
 
    return ringing_station;
}

References ao2_ref, ast_calloc, ast_tvnow(), NULL, sla_ringing_station::ring_begin, and sla_ringing_station::station.

Referenced by sla_ring_station().

sla_create_station_ref()

static struct sla_station_ref * sla_create_station_ref ( struct sla_station *  station )

static

Definition at line 805 of file app_sla.c.

{
    struct sla_station_ref *station_ref;
 
    if (!(station_ref = ao2_alloc(sizeof(*station_ref), sla_station_ref_destructor))) {
        return NULL;
    }
 
    ao2_ref(station, 1);
    station_ref->station = station;
 
    return station_ref;
}

References ao2_alloc, ao2_ref, NULL, sla_station_ref_destructor(), and sla_station_ref::station.

Referenced by sla_add_trunk_to_station(), and sla_stop_ringing_station().

sla_destroy()

static void sla_destroy ( void  )

static

Definition at line 2341 of file app_sla.c.

{
    if (sla.thread != AST_PTHREADT_NULL) {
        ast_mutex_lock(&sla.lock);
        sla.stop = 1;
        ast_cond_signal(&sla.cond);
        ast_mutex_unlock(&sla.lock);
        pthread_join(sla.thread, NULL);
    }
 
    /* Drop any created contexts from the dialplan */
    ast_context_destroy(NULL, sla_registrar);
 
    ast_mutex_destroy(&sla.lock);
    ast_cond_destroy(&sla.cond);
 
    ao2_callback(sla_trunks, 0, sla_trunk_release_refs, NULL);
    ao2_callback(sla_stations, 0, sla_station_release_refs, NULL);
 
    ao2_ref(sla_trunks, -1);
    sla_trunks = NULL;
 
    ao2_ref(sla_stations, -1);
    sla_stations = NULL;
}

References ao2_callback, ao2_ref, ast_cond_destroy, ast_cond_signal, ast_context_destroy(), ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, NULL, sla, sla_registrar, sla_station_release_refs(), sla_stations, sla_trunk_release_refs(), and sla_trunks.

Referenced by unload_module().

sla_dial_state_callback()

static void sla_dial_state_callback ( struct ast_dial *  dial )

static

Definition at line 1076 of file app_sla.c.

{
    sla_queue_event(SLA_EVENT_DIAL_STATE);
}

References SLA_EVENT_DIAL_STATE, and sla_queue_event().

Referenced by sla_ring_station().

sla_event_destroy()

static void sla_event_destroy ( struct sla_event *  event )

static

Definition at line 1720 of file app_sla.c.

{
    if (event->trunk_ref) {
        ao2_ref(event->trunk_ref, -1);
        event->trunk_ref = NULL;
    }
 
    if (event->station) {
        ao2_ref(event->station, -1);
        event->station = NULL;
    }
 
    ast_free(event);
}

References ao2_ref, ast_free, and NULL.

Referenced by sla_thread().

sla_failed_station_destroy()

static void sla_failed_station_destroy ( struct sla_failed_station *  failed_station )

static

Definition at line 859 of file app_sla.c.

{
    if (failed_station->station) {
        ao2_ref(failed_station->station, -1);
        failed_station->station = NULL;
    }
 
    ast_free(failed_station);
}

References ao2_ref, ast_free, NULL, and sla_failed_station::station.

Referenced by sla_check_failed_station(), and sla_thread().

sla_find_station()

static struct sla_station * sla_find_station ( const char *  name )

static

Definition at line 726 of file app_sla.c.

{
    struct sla_station tmp_station = {
        .name = name,
    };
 
    return ao2_find(sla_stations, &tmp_station, OBJ_POINTER);
}

References ao2_find, name, OBJ_POINTER, and sla_stations.

Referenced by sla_build_station(), sla_state(), and sla_station_exec().

sla_find_trunk()

static struct sla_trunk * sla_find_trunk ( const char *  name )

static

Definition at line 713 of file app_sla.c.

{
    struct sla_trunk tmp_trunk = {
        .name = name,
    };
 
    return ao2_find(sla_trunks, &tmp_trunk, OBJ_POINTER);
}

References ao2_find, name, sla_trunk::name, OBJ_POINTER, and sla_trunks.

Referenced by sla_add_trunk_to_station(), sla_build_trunk(), and sla_trunk_exec().

sla_find_trunk_ref()

static struct sla_trunk_ref * sla_find_trunk_ref ( const struct sla_station *  station, const struct sla_trunk *  trunk  )

static

Definition at line 1343 of file app_sla.c.

{
    struct sla_trunk_ref *trunk_ref = NULL;
 
    AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
        if (trunk_ref->trunk == trunk) {
            break;
        }
    }
 
    ao2_ref(trunk_ref, 1);
 
    return trunk_ref;
}

References ao2_ref, AST_LIST_TRAVERSE, sla_trunk_ref::entry, NULL, sla_trunk_ref::trunk, and sla_station::trunks.

Referenced by sla_check_station_delay().

sla_find_trunk_ref_byname()

static struct sla_trunk_ref * sla_find_trunk_ref_byname ( const struct sla_station *  station, const char *  name  )

static

Find a trunk reference on a station by name.

Parameters

station	the station
name	the trunk's name

Precondition

sla_station is locked

Returns

a pointer to the station's trunk reference. If the trunk is not found, it is not idle and barge is disabled, or if it is on hold and private hold is set, then NULL will be returned.

Definition at line 765 of file app_sla.c.

{
    struct sla_trunk_ref *trunk_ref = NULL;
 
    AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
        if (strcasecmp(trunk_ref->trunk->name, name)) {
            continue;
        }
 
        if (trunk_ref->trunk->barge_disabled && trunk_ref->state == SLA_TRUNK_STATE_UP) {
            ast_debug(2, "Barge disabled, trunk not available\n");
            trunk_ref = NULL;
        } else if (trunk_ref->trunk->hold_stations && trunk_ref->trunk->hold_access == SLA_HOLD_PRIVATE && trunk_ref->state != SLA_TRUNK_STATE_ONHOLD_BYME) {
            ast_debug(2, "Private hold by another station\n");
            trunk_ref = NULL;
        } else if (sla_check_station_hold_access(trunk_ref->trunk, station)) {
            ast_debug(2, "No hold access\n");
            trunk_ref = NULL;
        }
 
        break;
    }
 
    if (trunk_ref) {
        ao2_ref(trunk_ref, 1);
    }
 
    return trunk_ref;
}

References ao2_ref, ast_debug, AST_LIST_TRAVERSE, sla_trunk::barge_disabled, sla_trunk_ref::entry, sla_trunk::hold_access, sla_trunk::hold_stations, name, sla_trunk::name, NULL, sla_check_station_hold_access(), SLA_HOLD_PRIVATE, SLA_TRUNK_STATE_ONHOLD_BYME, SLA_TRUNK_STATE_UP, sla_trunk_ref::state, sla_trunk_ref::trunk, and sla_station::trunks.

Referenced by sla_station_exec().

sla_framehook()

static struct ast_frame * sla_framehook ( struct ast_channel *  chan, struct ast_frame *  f, enum ast_framehook_event  event, void *  data  )

static

Definition at line 648 of file app_sla.c.

{
    struct sla_framehook_data *sla_data = data;
    if (!f || (event != AST_FRAMEHOOK_EVENT_WRITE)) {
        return f;
    }
    if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_HOLD) {
        sla_queue_event_conf(SLA_EVENT_HOLD, chan, sla_data->confname);
    }
    return f;
}

References AST_CONTROL_HOLD, AST_FRAME_CONTROL, AST_FRAMEHOOK_EVENT_WRITE, sla_framehook_data::confname, ast_frame::frametype, ast_frame_subclass::integer, SLA_EVENT_HOLD, sla_queue_event_conf(), and ast_frame::subclass.

Referenced by attach_framehook().

sla_framehook_consume()

static int sla_framehook_consume ( void *  data, enum ast_frame_type  type  )

static

Callback function which informs upstream if we are consuming a frame of a specific type.

Definition at line 661 of file app_sla.c.

{
    return (type == AST_FRAME_CONTROL ? 1 : 0);
}

References AST_FRAME_CONTROL, and type.

Referenced by attach_framehook().

sla_handle_dial_state_event()

static void sla_handle_dial_state_event ( void  )

static

Definition at line 1144 of file app_sla.c.

{
    struct sla_ringing_station *ringing_station;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&sla.ringing_stations, ringing_station, entry) {
        RAII_VAR(struct sla_trunk_ref *, s_trunk_ref, NULL, ao2_cleanup);
        struct sla_ringing_trunk *ringing_trunk = NULL;
        struct run_station_args args;
        enum ast_dial_result dial_res;
        pthread_t dont_care;
        ast_mutex_t cond_lock;
        ast_cond_t cond;
 
        switch ((dial_res = ast_dial_state(ringing_station->station->dial))) {
        case AST_DIAL_RESULT_HANGUP:
        case AST_DIAL_RESULT_INVALID:
        case AST_DIAL_RESULT_FAILED:
        case AST_DIAL_RESULT_TIMEOUT:
        case AST_DIAL_RESULT_UNANSWERED:
            AST_LIST_REMOVE_CURRENT(entry);
            sla_stop_ringing_station(ringing_station, SLA_STATION_HANGUP_NORMAL);
            break;
        case AST_DIAL_RESULT_ANSWERED:
            AST_LIST_REMOVE_CURRENT(entry);
            /* Find the appropriate trunk to answer. */
            ast_mutex_lock(&sla.lock);
            ringing_trunk = sla_choose_ringing_trunk(ringing_station->station, &s_trunk_ref, 1);
            ast_mutex_unlock(&sla.lock);
            if (!ringing_trunk) {
                /* This case happens in a bit of a race condition.  If two stations answer
                 * the outbound call at the same time, the first one will get connected to
                 * the trunk.  When the second one gets here, it will not see any trunks
                 * ringing so we have no idea what to conect it to.  So, we just hang up
                 * on it. */
                ast_debug(1, "Found no ringing trunk for station '%s' to answer!\n", ringing_station->station->name);
                ast_dial_join(ringing_station->station->dial);
                ast_dial_destroy(ringing_station->station->dial);
                ringing_station->station->dial = NULL;
                sla_ringing_station_destroy(ringing_station);
                break;
            }
            /* Track the channel that answered this trunk */
            s_trunk_ref->chan = ast_dial_answered(ringing_station->station->dial);
            /* Actually answer the trunk */
            answer_trunk_chan(ringing_trunk->trunk->chan);
            sla_change_trunk_state(ringing_trunk->trunk, SLA_TRUNK_STATE_UP, ALL_TRUNK_REFS, NULL);
            /* Now, start a thread that will connect this station to the trunk.  The rest of
             * the code here sets up the thread and ensures that it is able to save the arguments
             * before they are no longer valid since they are allocated on the stack. */
            ao2_ref(s_trunk_ref, 1);
            args.trunk_ref = s_trunk_ref;
            ao2_ref(ringing_station->station, 1);
            args.station = ringing_station->station;
            args.cond = &cond;
            args.cond_lock = &cond_lock;
            sla_ringing_trunk_destroy(ringing_trunk);
            sla_ringing_station_destroy(ringing_station);
            ast_mutex_init(&cond_lock);
            ast_cond_init(&cond, NULL);
            ast_mutex_lock(&cond_lock);
            ast_pthread_create_detached_background(&dont_care, NULL, run_station, &args);
            ast_cond_wait(&cond, &cond_lock);
            ast_mutex_unlock(&cond_lock);
            ast_mutex_destroy(&cond_lock);
            ast_cond_destroy(&cond);
            break;
        case AST_DIAL_RESULT_TRYING:
        case AST_DIAL_RESULT_RINGING:
        case AST_DIAL_RESULT_PROGRESS:
        case AST_DIAL_RESULT_PROCEEDING:
            break;
        }
        if (dial_res == AST_DIAL_RESULT_ANSWERED) {
            /* Queue up reprocessing ringing trunks, and then ringing stations again */
            sla_queue_event(SLA_EVENT_RINGING_TRUNK);
            sla_queue_event(SLA_EVENT_DIAL_STATE);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
}

References ALL_TRUNK_REFS, answer_trunk_chan(), ao2_cleanup, ao2_ref, args, ast_cond_destroy, ast_cond_init, ast_cond_wait, ast_debug, ast_dial_answered(), ast_dial_destroy(), ast_dial_join(), AST_DIAL_RESULT_ANSWERED, AST_DIAL_RESULT_FAILED, AST_DIAL_RESULT_HANGUP, AST_DIAL_RESULT_INVALID, AST_DIAL_RESULT_PROCEEDING, AST_DIAL_RESULT_PROGRESS, AST_DIAL_RESULT_RINGING, AST_DIAL_RESULT_TIMEOUT, AST_DIAL_RESULT_TRYING, AST_DIAL_RESULT_UNANSWERED, ast_dial_state(), AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_pthread_create_detached_background, sla_trunk::chan, cond, run_station_args::cond_lock, sla_station::dial, sla_ringing_station::entry, NULL, RAII_VAR, run_station(), sla, sla_change_trunk_state(), sla_choose_ringing_trunk(), SLA_EVENT_DIAL_STATE, SLA_EVENT_RINGING_TRUNK, sla_queue_event(), sla_ringing_station_destroy(), sla_ringing_trunk_destroy(), SLA_STATION_HANGUP_NORMAL, sla_stop_ringing_station(), SLA_TRUNK_STATE_UP, sla_ringing_station::station, and sla_ringing_trunk::trunk.

Referenced by sla_thread().

sla_handle_hold_event()

static void sla_handle_hold_event ( struct sla_event *  event )

static

Definition at line 1485 of file app_sla.c.

{
    ast_atomic_fetchadd_int((int *) &event->trunk_ref->trunk->hold_stations, 1);
    event->trunk_ref->state = SLA_TRUNK_STATE_ONHOLD_BYME;
    ast_devstate_changed(AST_DEVICE_ONHOLD, AST_DEVSTATE_CACHABLE, "SLA:%s_%s", event->station->name, event->trunk_ref->trunk->name);
    sla_change_trunk_state(event->trunk_ref->trunk, SLA_TRUNK_STATE_ONHOLD, INACTIVE_TRUNK_REFS, event->trunk_ref);
 
    if (event->trunk_ref->trunk->active_stations == 1) {
        /* The station putting it on hold is the only one on the call, so start
         * Music on hold to the trunk. */
        event->trunk_ref->trunk->on_hold = 1;
        ast_indicate(event->trunk_ref->trunk->chan, AST_CONTROL_HOLD);
    }
 
    ast_softhangup(event->trunk_ref->chan, AST_SOFTHANGUP_DEV);
    event->trunk_ref->chan = NULL;
}

References ast_atomic_fetchadd_int(), AST_CONTROL_HOLD, AST_DEVICE_ONHOLD, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_indicate(), ast_softhangup(), AST_SOFTHANGUP_DEV, INACTIVE_TRUNK_REFS, NULL, sla_change_trunk_state(), SLA_TRUNK_STATE_ONHOLD, and SLA_TRUNK_STATE_ONHOLD_BYME.

Referenced by sla_thread().

sla_handle_ringing_trunk_event()

static void sla_handle_ringing_trunk_event ( void  )

static

Definition at line 1475 of file app_sla.c.

{
    ast_mutex_lock(&sla.lock);
    sla_ring_stations();
    ast_mutex_unlock(&sla.lock);
 
    /* Find stations that shouldn't be ringing anymore. */
    sla_hangup_stations();
}

References ast_mutex_lock, ast_mutex_unlock, sla, sla_hangup_stations(), and sla_ring_stations().

Referenced by sla_thread().

sla_hangup_stations()

static void sla_hangup_stations ( void  )

static

Definition at line 1445 of file app_sla.c.

{
    struct sla_trunk_ref *trunk_ref;
    struct sla_ringing_station *ringing_station;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&sla.ringing_stations, ringing_station, entry) {
        AST_LIST_TRAVERSE(&ringing_station->station->trunks, trunk_ref, entry) {
            struct sla_ringing_trunk *ringing_trunk;
            ast_mutex_lock(&sla.lock);
            AST_LIST_TRAVERSE(&sla.ringing_trunks, ringing_trunk, entry) {
                if (trunk_ref->trunk == ringing_trunk->trunk) {
                    break;
                }
            }
            ast_mutex_unlock(&sla.lock);
            if (ringing_trunk) {
                break;
            }
        }
        if (!trunk_ref) {
            AST_LIST_REMOVE_CURRENT(entry);
            ast_dial_join(ringing_station->station->dial);
            ast_dial_destroy(ringing_station->station->dial);
            ringing_station->station->dial = NULL;
            sla_ringing_station_destroy(ringing_station);
        }
    }
    AST_LIST_TRAVERSE_SAFE_END
}

References ast_dial_destroy(), ast_dial_join(), AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_mutex_lock, ast_mutex_unlock, sla_station::dial, sla_ringing_trunk::entry, sla_ringing_station::entry, NULL, sla, sla_ringing_station_destroy(), sla_ringing_station::station, sla_trunk_ref::trunk, sla_ringing_trunk::trunk, and sla_station::trunks.

Referenced by sla_handle_ringing_trunk_event().

sla_hold_str()

static const char * sla_hold_str ( unsigned int  hold_access )

static

Definition at line 350 of file app_sla.c.

{
    const char *hold = "Unknown";
 
    switch (hold_access) {
    case SLA_HOLD_OPEN:
        hold = "Open";
        break;
    case SLA_HOLD_PRIVATE:
        hold = "Private";
    default:
        break;
    }
 
    return hold;
}

References hold(), SLA_HOLD_OPEN, and SLA_HOLD_PRIVATE.

Referenced by sla_show_stations(), and sla_show_trunks().

sla_in_use()

static int sla_in_use ( void  )

static

Definition at line 2754 of file app_sla.c.

{
    return ao2_container_count(sla_trunks) || ao2_container_count(sla_stations);
}

References ao2_container_count(), sla_stations, and sla_trunks.

Referenced by sla_load_config().

sla_load_config()

static int sla_load_config ( int  reload )

static

Definition at line 2759 of file app_sla.c.

{
    struct ast_config *cfg;
    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    const char *cat = NULL;
    int res = 0;
    const char *val;
 
    if (!reload) {
        ast_mutex_init(&sla.lock);
        ast_cond_init(&sla.cond, NULL);
        sla_trunks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, sla_trunk_cmp);
        sla_stations = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, sla_station_cmp);
    }
 
    if (!(cfg = ast_config_load(SLA_CONFIG_FILE, config_flags))) {
        return 0; /* Treat no config as normal */
    } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        return 0;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Config file " SLA_CONFIG_FILE " is in an invalid format.  Aborting.\n");
        return 0;
    }
 
    if (reload) {
        ao2_callback(sla_trunks, 0, sla_trunk_mark, NULL);
        ao2_callback(sla_stations, 0, sla_station_mark, NULL);
    }
 
    if ((val = ast_variable_retrieve(cfg, "general", "attemptcallerid"))) {
        sla.attempt_callerid = ast_true(val);
    }
 
    while ((cat = ast_category_browse(cfg, cat)) && !res) {
        const char *type;
        if (!strcasecmp(cat, "general")) {
            continue;
        }
        if (!(type = ast_variable_retrieve(cfg, cat, "type"))) {
            ast_log(LOG_WARNING, "Invalid entry in %s defined with no type!\n", SLA_CONFIG_FILE);
            continue;
        }
        if (!strcasecmp(type, "trunk")) {
            res = sla_build_trunk(cfg, cat);
        } else if (!strcasecmp(type, "station")) {
            res = sla_build_station(cfg, cat);
        } else {
            ast_log(LOG_WARNING, "Entry in %s defined with invalid type '%s'!\n", SLA_CONFIG_FILE, type);
        }
    }
 
    ast_config_destroy(cfg);
 
    if (reload) {
        ao2_callback(sla_trunks, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, sla_trunk_is_marked, NULL);
        ao2_callback(sla_stations, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, sla_station_is_marked, NULL);
    }
 
    /* Start SLA event processing thread once SLA has been configured. */
    if (sla.thread == AST_PTHREADT_NULL && sla_in_use()) {
        ast_pthread_create(&sla.thread, NULL, sla_thread, NULL);
    }
 
    return res;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_callback, ao2_container_alloc_list, ast_category_browse(), ast_cond_init, ast_config_destroy(), ast_config_load, ast_log, ast_mutex_init, ast_pthread_create, AST_PTHREADT_NULL, ast_true(), ast_variable_retrieve(), CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, LOG_ERROR, LOG_WARNING, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, reload(), sla, sla_build_station(), sla_build_trunk(), SLA_CONFIG_FILE, sla_in_use(), sla_station_cmp(), sla_station_is_marked(), sla_station_mark(), sla_stations, sla_thread(), sla_trunk_cmp(), sla_trunk_is_marked(), sla_trunk_mark(), sla_trunks, and type.

Referenced by load_config().

sla_process_timers()

static int sla_process_timers ( struct timespec *  ts )

static

Calculate the time until the next known event.

Note

Called with sla.lock locked

Definition at line 1680 of file app_sla.c.

{
    unsigned int timeout = UINT_MAX;
    struct timeval wait;
    unsigned int change_made = 0;
 
    /* Check for ring timeouts on ringing trunks */
    if (sla_calc_trunk_timeouts(&timeout)) {
        change_made = 1;
    }
 
    /* Check for ring timeouts on ringing stations */
    if (sla_calc_station_timeouts(&timeout)) {
        change_made = 1;
    }
 
    /* Check for station ring delays */
    if (sla_calc_station_delays(&timeout)) {
        change_made = 1;
    }
 
    /* queue reprocessing of ringing trunks */
    if (change_made) {
        sla_queue_event_nolock(SLA_EVENT_RINGING_TRUNK);
    }
 
    /* No timeout */
    if (timeout == UINT_MAX) {
        return 0;
    }
 
    if (ts) {
        wait = ast_tvadd(ast_tvnow(), ast_samp2tv(timeout, 1000));
        ts->tv_sec = wait.tv_sec;
        ts->tv_nsec = wait.tv_usec * 1000;
    }
 
    return 1;
}

References ast_samp2tv(), ast_tvadd(), ast_tvnow(), sla_calc_station_delays(), sla_calc_station_timeouts(), sla_calc_trunk_timeouts(), SLA_EVENT_RINGING_TRUNK, and sla_queue_event_nolock().

Referenced by sla_thread().

sla_queue_event()

static void sla_queue_event ( enum sla_event_type  type )

static

Definition at line 561 of file app_sla.c.

{
    sla_queue_event_full(type, NULL, NULL, 1);
}

References NULL, sla_queue_event_full(), and type.

Referenced by queue_ringing_trunk(), sla_dial_state_callback(), sla_handle_dial_state_event(), sla_station_exec(), and sla_trunk_exec().

sla_queue_event_conf()

static void sla_queue_event_conf ( enum sla_event_type  type, struct ast_channel *  chan, const char *  confname  )

static

Queue a SLA event from the conference.

Definition at line 567 of file app_sla.c.

{
    struct sla_station *station;
    struct sla_trunk_ref *trunk_ref = NULL;
    char *trunk_name;
    struct ao2_iterator i;
 
    trunk_name = ast_strdupa(confname);
    strsep(&trunk_name, "_");
    if (ast_strlen_zero(trunk_name)) {
        ast_log(LOG_ERROR, "Invalid conference name for SLA - '%s'!\n", confname);
        return;
    }
 
    i = ao2_iterator_init(sla_stations, 0);
    while ((station = ao2_iterator_next(&i))) {
        ao2_lock(station);
        AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
            if (trunk_ref->chan == chan && !strcmp(trunk_ref->trunk->name, trunk_name)) {
                ao2_ref(trunk_ref, 1);
                break;
            }
        }
        ao2_unlock(station);
        if (trunk_ref) {
            /* station reference given to sla_queue_event_full() */
            break;
        }
        ao2_ref(station, -1);
    }
    ao2_iterator_destroy(&i);
 
    if (!trunk_ref) {
        ast_debug(1, "Trunk not found for event!\n");
        return;
    }
 
    sla_queue_event_full(type, trunk_ref, station, 1);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_debug, AST_LIST_TRAVERSE, ast_log, ast_strdupa, ast_strlen_zero(), sla_trunk_ref::chan, LOG_ERROR, sla_trunk::name, NULL, sla_queue_event_full(), sla_stations, strsep(), sla_trunk_ref::trunk, sla_station::trunks, and type.

Referenced by sla_framehook().

sla_queue_event_full()

static void sla_queue_event_full ( enum sla_event_type  type, struct sla_trunk_ref *  trunk_ref, struct sla_station *  station, int  lock  )

static

Definition at line 525 of file app_sla.c.

{
    struct sla_event *event;
 
    if (sla.thread == AST_PTHREADT_NULL) {
        ao2_ref(station, -1);
        ao2_ref(trunk_ref, -1);
        return;
    }
 
    if (!(event = ast_calloc(1, sizeof(*event)))) {
        ao2_ref(station, -1);
        ao2_ref(trunk_ref, -1);
        return;
    }
 
    event->type = type;
    event->trunk_ref = trunk_ref;
    event->station = station;
 
    if (!lock) {
        AST_LIST_INSERT_TAIL(&sla.event_q, event, entry);
        return;
    }
 
    ast_mutex_lock(&sla.lock);
    AST_LIST_INSERT_TAIL(&sla.event_q, event, entry);
    ast_cond_signal(&sla.cond);
    ast_mutex_unlock(&sla.lock);
}

References ao2_ref, ast_calloc, ast_cond_signal, AST_LIST_INSERT_TAIL, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, sla_event::entry, lock, sla, sla_event::station, sla_event::trunk_ref, and type.

Referenced by sla_queue_event(), sla_queue_event_conf(), and sla_queue_event_nolock().

sla_queue_event_nolock()

static void sla_queue_event_nolock ( enum sla_event_type  type )

static

Definition at line 556 of file app_sla.c.

{
    sla_queue_event_full(type, NULL, NULL, 0);
}

References NULL, sla_queue_event_full(), and type.

Referenced by sla_process_timers().

sla_ring_station()

static int sla_ring_station ( struct sla_ringing_trunk *  ringing_trunk, struct sla_station *  station  )

static

Ring a station.

Note

Assumes sla.lock is locked

Definition at line 1269 of file app_sla.c.

{
    char *tech, *tech_data;
    struct ast_dial *dial;
    struct sla_ringing_station *ringing_station;
    enum ast_dial_result res;
    int caller_is_saved;
    struct ast_party_caller caller;
 
    if (!(dial = ast_dial_create())) {
        return -1;
    }
 
    ast_dial_set_state_callback(dial, sla_dial_state_callback);
    tech_data = ast_strdupa(station->device);
    tech = strsep(&tech_data, "/");
 
    if (ast_dial_append(dial, tech, tech_data, NULL) == -1) {
        ast_dial_destroy(dial);
        return -1;
    }
 
    /* Do we need to save off the caller ID data? */
    caller_is_saved = 0;
    if (!sla.attempt_callerid) {
        caller_is_saved = 1;
        caller = *ast_channel_caller(ringing_trunk->trunk->chan);
        ast_party_caller_init(ast_channel_caller(ringing_trunk->trunk->chan));
    }
 
    res = ast_dial_run(dial, ringing_trunk->trunk->chan, 1);
 
    /* Restore saved caller ID */
    if (caller_is_saved) {
        ast_party_caller_free(ast_channel_caller(ringing_trunk->trunk->chan));
        ast_channel_caller_set(ringing_trunk->trunk->chan, &caller);
    }
 
    if (res != AST_DIAL_RESULT_TRYING) {
        struct sla_failed_station *failed_station;
        ast_dial_destroy(dial);
        if ((failed_station = sla_create_failed_station(station))) {
            AST_LIST_INSERT_HEAD(&sla.failed_stations, failed_station, entry);
        }
        return -1;
    }
    if (!(ringing_station = sla_create_ringing_station(station))) {
        ast_dial_join(dial);
        ast_dial_destroy(dial);
        return -1;
    }
 
    station->dial = dial;
 
    AST_LIST_INSERT_HEAD(&sla.ringing_stations, ringing_station, entry);
 
    return 0;
}

References ast_channel_caller(), ast_channel_caller_set(), ast_dial_append(), ast_dial_create(), ast_dial_destroy(), ast_dial_join(), AST_DIAL_RESULT_TRYING, ast_dial_run(), ast_dial_set_state_callback(), AST_LIST_INSERT_HEAD, ast_party_caller_free(), ast_party_caller_init(), ast_strdupa, sla_trunk::chan, sla_station::dial, sla_failed_station::entry, NULL, sla, sla_create_failed_station(), sla_create_ringing_station(), sla_dial_state_callback(), sla_failed_station::station, strsep(), and sla_ringing_trunk::trunk.

Referenced by sla_ring_stations().

sla_ring_stations()

static void sla_ring_stations ( void  )

static

Ring stations based on current set of ringing trunks.

Note

Assumes that sla.lock is locked

Definition at line 1399 of file app_sla.c.

{
    struct sla_station_ref *station_ref;
    struct sla_ringing_trunk *ringing_trunk;
 
    /* Make sure that every station that uses at least one of the ringing
     * trunks, is ringing. */
    AST_LIST_TRAVERSE(&sla.ringing_trunks, ringing_trunk, entry) {
        AST_LIST_TRAVERSE(&ringing_trunk->trunk->stations, station_ref, entry) {
            int time_left;
 
            /* Is this station already ringing? */
            if (sla_check_ringing_station(station_ref->station)) {
                continue;
            }
 
            /* Is this station already in a call? */
            if (sla_check_inuse_station(station_ref->station)) {
                continue;
            }
 
            /* Did we fail to dial this station earlier?  If so, has it been
             * a minute since we tried? */
            if (sla_check_failed_station(station_ref->station)) {
                continue;
            }
 
            /* If this station already timed out while this trunk was ringing,
             * do not dial it again for this ringing trunk. */
            if (sla_check_timed_out_station(ringing_trunk, station_ref->station)) {
                continue;
            }
 
            /* Check for a ring delay in progress */
            time_left = sla_check_station_delay(station_ref->station, ringing_trunk);
            if (time_left != INT_MAX && time_left > 0) {
                continue;
            }
 
            /* It is time to make this station begin to ring.  Do it! */
            sla_ring_station(ringing_trunk, station_ref->station);
        }
    }
    /* Now, all of the stations that should be ringing, are ringing. */
}

References AST_LIST_TRAVERSE, sla_ringing_trunk::entry, sla, sla_check_failed_station(), sla_check_inuse_station(), sla_check_ringing_station(), sla_check_station_delay(), sla_check_timed_out_station(), sla_ring_station(), sla_station_ref::station, sla_trunk::stations, and sla_ringing_trunk::trunk.

Referenced by sla_handle_ringing_trunk_event().

sla_ringing_station_destroy()

static void sla_ringing_station_destroy ( struct sla_ringing_station *  ringing_station )

static

Definition at line 834 of file app_sla.c.

{
    if (ringing_station->station) {
        ao2_ref(ringing_station->station, -1);
        ringing_station->station = NULL;
    }
 
    ast_free(ringing_station);
}

References ao2_ref, ast_free, NULL, and sla_ringing_station::station.

Referenced by sla_handle_dial_state_event(), sla_hangup_stations(), sla_stop_ringing_station(), and sla_thread().

sla_ringing_trunk_destroy()

static void sla_ringing_trunk_destroy ( struct sla_ringing_trunk *  ringing_trunk )

static

Definition at line 2149 of file app_sla.c.

{
    if (ringing_trunk->trunk) {
        ao2_ref(ringing_trunk->trunk, -1);
        ringing_trunk->trunk = NULL;
    }
 
    ast_free(ringing_trunk);
}

References ao2_ref, ast_free, NULL, and sla_ringing_trunk::trunk.

Referenced by sla_handle_dial_state_event(), sla_station_exec(), sla_stop_ringing_trunk(), and sla_trunk_exec().

sla_show_stations()

static char * sla_show_stations ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 441 of file app_sla.c.

{
    struct ao2_iterator i;
    struct sla_station *station;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "sla show stations";
        e->usage =
            "Usage: sla show stations\n"
            "       This will list all stations defined in sla.conf\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    ast_cli(a->fd, "\n"
                "=============================================================\n"
                "=== Configured SLA Stations =================================\n"
                "=============================================================\n"
                "===\n");
    i = ao2_iterator_init(sla_stations, 0);
    for (; (station = ao2_iterator_next(&i)); ao2_ref(station, -1)) {
        struct sla_trunk_ref *trunk_ref;
        char ring_timeout[16] = "(none)";
        char ring_delay[16] = "(none)";
 
        ao2_lock(station);
 
        if (station->ring_timeout) {
            snprintf(ring_timeout, sizeof(ring_timeout), "%u", station->ring_timeout);
        }
        if (station->ring_delay) {
            snprintf(ring_delay, sizeof(ring_delay), "%u", station->ring_delay);
        }
        ast_cli(a->fd, "=== ---------------------------------------------------------\n"
                    "=== Station Name:    %s\n"
                    "=== ==> Device:      %s\n"
                    "=== ==> AutoContext: %s\n"
                    "=== ==> RingTimeout: %s\n"
                    "=== ==> RingDelay:   %s\n"
                    "=== ==> HoldAccess:  %s\n"
                    "=== ==> Trunks ...\n",
                    station->name, station->device,
                    S_OR(station->autocontext, "(none)"),
                    ring_timeout, ring_delay,
                    sla_hold_str(station->hold_access));
        AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
            if (trunk_ref->ring_timeout) {
                snprintf(ring_timeout, sizeof(ring_timeout), "%u", trunk_ref->ring_timeout);
            } else {
                strcpy(ring_timeout, "(none)");
            }
            if (trunk_ref->ring_delay) {
                snprintf(ring_delay, sizeof(ring_delay), "%u", trunk_ref->ring_delay);
            } else {
                strcpy(ring_delay, "(none)");
            }
 
            ast_cli(a->fd, "===    ==> Trunk Name: %s\n"
                "===       ==> State:       %s\n"
                "===       ==> RingTimeout: %s\n"
                "===       ==> RingDelay:   %s\n",
                trunk_ref->trunk->name,
                trunkstate2str(trunk_ref->state),
                ring_timeout, ring_delay);
        }
        ast_cli(a->fd, "=== ---------------------------------------------------------\n"
                    "===\n");
 
        ao2_unlock(station);
    }
    ao2_iterator_destroy(&i);
    ast_cli(a->fd, "============================================================\n"
                "\n");
 
    return CLI_SUCCESS;
}

References a, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli(), AST_LIST_TRAVERSE, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, sla_trunk_ref::entry, sla_station::hold_access, sla_trunk::name, NULL, sla_station::ring_delay, sla_trunk_ref::ring_delay, sla_station::ring_timeout, sla_trunk_ref::ring_timeout, S_OR, sla_hold_str(), sla_stations, sla_trunk_ref::state, sla_trunk_ref::trunk, sla_station::trunks, trunkstate2str(), and ast_cli_entry::usage.

sla_show_trunks()

static char * sla_show_trunks ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 367 of file app_sla.c.

{
    struct ao2_iterator i;
    struct sla_trunk *trunk;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "sla show trunks";
        e->usage =
            "Usage: sla show trunks\n"
            "       This will list all trunks defined in sla.conf\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    ast_cli(a->fd, "\n"
                "=============================================================\n"
                "=== Configured SLA Trunks ===================================\n"
                "=============================================================\n"
                "===\n");
    i = ao2_iterator_init(sla_trunks, 0);
    for (; (trunk = ao2_iterator_next(&i)); ao2_ref(trunk, -1)) {
        struct sla_station_ref *station_ref;
        char ring_timeout[23] = "(none)";
 
        ao2_lock(trunk);
 
        if (trunk->ring_timeout) {
            snprintf(ring_timeout, sizeof(ring_timeout), "%u Seconds", trunk->ring_timeout);
        }
 
        ast_cli(a->fd, "=== ---------------------------------------------------------\n"
                    "=== Trunk Name:       %s\n"
                    "=== ==> Device:       %s\n"
                    "=== ==> AutoContext:  %s\n"
                    "=== ==> RingTimeout:  %s\n"
                    "=== ==> BargeAllowed: %s\n"
                    "=== ==> HoldAccess:   %s\n"
                    "=== ==> Stations ...\n",
                    trunk->name, trunk->device,
                    S_OR(trunk->autocontext, "(none)"),
                    ring_timeout,
                    trunk->barge_disabled ? "No" : "Yes",
                    sla_hold_str(trunk->hold_access));
 
        AST_LIST_TRAVERSE(&trunk->stations, station_ref, entry) {
            ast_cli(a->fd, "===    ==> Station name: %s\n", station_ref->station->name);
        }
 
        ast_cli(a->fd, "=== ---------------------------------------------------------\n===\n");
 
        ao2_unlock(trunk);
    }
    ao2_iterator_destroy(&i);
    ast_cli(a->fd, "=============================================================\n\n");
 
    return CLI_SUCCESS;
}

References a, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli(), AST_LIST_TRAVERSE, sla_trunk::autocontext, sla_trunk::barge_disabled, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, sla_trunk::device, sla_station_ref::entry, sla_trunk::hold_access, sla_trunk::name, NULL, sla_trunk::ring_timeout, S_OR, sla_hold_str(), sla_trunks, sla_station_ref::station, sla_trunk::stations, and ast_cli_entry::usage.

sla_state()

static enum ast_device_state sla_state ( const char *  data )

static

Definition at line 2250 of file app_sla.c.

{
    char *buf, *station_name, *trunk_name;
    RAII_VAR(struct sla_station *, station, NULL, ao2_cleanup);
    struct sla_trunk_ref *trunk_ref;
    enum ast_device_state res = AST_DEVICE_INVALID;
 
    trunk_name = buf = ast_strdupa(data);
    station_name = strsep(&trunk_name, "_");
 
    station = sla_find_station(station_name);
    if (station) {
        ao2_lock(station);
        AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
            if (!strcasecmp(trunk_name, trunk_ref->trunk->name)) {
                res = sla_state_to_devstate(trunk_ref->state);
                break;
            }
        }
        ao2_unlock(station);
    }
 
    if (res == AST_DEVICE_INVALID) {
        ast_log(LOG_ERROR, "Could not determine state for trunk %s on station %s!\n", trunk_name, station_name);
    }
 
    return res;
}

References ao2_cleanup, ao2_lock, ao2_unlock, AST_DEVICE_INVALID, AST_LIST_TRAVERSE, ast_log, ast_strdupa, buf, sla_trunk_ref::entry, LOG_ERROR, sla_trunk::name, NULL, RAII_VAR, sla_find_station(), sla_state_to_devstate(), sla_trunk_ref::state, strsep(), and sla_trunk_ref::trunk.

Referenced by load_module().

sla_state_to_devstate()

static enum ast_device_state sla_state_to_devstate ( enum sla_trunk_state  state )

static

Definition at line 869 of file app_sla.c.

{
    switch (state) {
    case SLA_TRUNK_STATE_IDLE:
        return AST_DEVICE_NOT_INUSE;
    case SLA_TRUNK_STATE_RINGING:
        return AST_DEVICE_RINGING;
    case SLA_TRUNK_STATE_UP:
        return AST_DEVICE_INUSE;
    case SLA_TRUNK_STATE_ONHOLD:
    case SLA_TRUNK_STATE_ONHOLD_BYME:
        return AST_DEVICE_ONHOLD;
    }
 
    return AST_DEVICE_UNKNOWN;
}

References AST_DEVICE_INUSE, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_UNKNOWN, SLA_TRUNK_STATE_IDLE, SLA_TRUNK_STATE_ONHOLD, SLA_TRUNK_STATE_ONHOLD_BYME, SLA_TRUNK_STATE_RINGING, and SLA_TRUNK_STATE_UP.

Referenced by sla_change_trunk_state(), and sla_state().

sla_station_cmp()

static int sla_station_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2334 of file app_sla.c.

{
    struct sla_station *station = obj, *station2 = arg;
 
    return !strcasecmp(station->name, station2->name) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, and CMP_STOP.

Referenced by sla_load_config().

sla_station_destructor()

static void sla_station_destructor ( void *  obj )

static

Definition at line 2303 of file app_sla.c.

{
    struct sla_station *station = obj;
 
    ast_debug(1, "sla_station destructor for '%s'\n", station->name);
 
    if (!ast_strlen_zero(station->autocontext)) {
        struct sla_trunk_ref *trunk_ref;
 
        AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
            char exten[AST_MAX_EXTENSION];
            char hint[AST_MAX_EXTENSION + 5];
            snprintf(exten, sizeof(exten), "%s_%s", station->name, trunk_ref->trunk->name);
            snprintf(hint, sizeof(hint), "SLA:%s", exten);
            ast_context_remove_extension(station->autocontext, exten, 1, sla_registrar);
            ast_context_remove_extension(station->autocontext, hint, PRIORITY_HINT, sla_registrar);
        }
    }
 
    sla_station_release_refs(station, NULL, 0);
 
    ast_string_field_free_memory(station);
}

References ast_context_remove_extension(), ast_debug, AST_LIST_TRAVERSE, AST_MAX_EXTENSION, ast_string_field_free_memory, ast_strlen_zero(), sla_trunk_ref::entry, sla_trunk::name, NULL, PRIORITY_HINT, sla_registrar, sla_station_release_refs(), sla_trunk_ref::trunk, and sla_station::trunks.

Referenced by sla_build_station().

sla_station_exec()

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

static

Definition at line 1955 of file app_sla.c.

{
    char *station_name, *trunk_name;
    RAII_VAR(struct sla_station *, station, NULL, ao2_cleanup);
    RAII_VAR(struct sla_trunk_ref *, trunk_ref, NULL, ao2_cleanup);
    char conf_name[MAX_CONFNUM];
    struct ast_flags conf_flags = { 0 };
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "Invalid Arguments to SLAStation!\n");
        pbx_builtin_setvar_helper(chan, "SLASTATION_STATUS", "FAILURE");
        return 0;
    }
 
    trunk_name = ast_strdupa(data);
    station_name = strsep(&trunk_name, "_");
 
    if (ast_strlen_zero(station_name)) {
        ast_log(LOG_WARNING, "Invalid Arguments to SLAStation!\n");
        pbx_builtin_setvar_helper(chan, "SLASTATION_STATUS", "FAILURE");
        return 0;
    }
 
    station = sla_find_station(station_name);
 
    if (!station) {
        ast_log(LOG_WARNING, "Station '%s' not found!\n", station_name);
        pbx_builtin_setvar_helper(chan, "SLASTATION_STATUS", "FAILURE");
        return 0;
    }
 
    ao2_lock(station);
    if (!ast_strlen_zero(trunk_name)) {
        trunk_ref = sla_find_trunk_ref_byname(station, trunk_name);
    } else {
        trunk_ref = sla_choose_idle_trunk(station);
    }
    ao2_unlock(station);
 
    if (!trunk_ref) {
        if (ast_strlen_zero(trunk_name)) {
            ast_log(LOG_NOTICE, "No trunks available for call.\n");
        } else {
            ast_log(LOG_NOTICE, "Can't join existing call on trunk '%s' due to access controls.\n", trunk_name);
        }
        pbx_builtin_setvar_helper(chan, "SLASTATION_STATUS", "CONGESTION");
        return 0;
    }
 
    if (trunk_ref->state == SLA_TRUNK_STATE_ONHOLD_BYME) {
        if (ast_atomic_dec_and_test((int *) &trunk_ref->trunk->hold_stations) == 1) {
            sla_change_trunk_state(trunk_ref->trunk, SLA_TRUNK_STATE_UP, ALL_TRUNK_REFS, NULL);
        } else {
            trunk_ref->state = SLA_TRUNK_STATE_UP;
            ast_devstate_changed(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, "SLA:%s_%s", station->name, trunk_ref->trunk->name);
        }
    } else if (trunk_ref->state == SLA_TRUNK_STATE_RINGING) {
        struct sla_ringing_trunk *ringing_trunk;
 
        ast_mutex_lock(&sla.lock);
        AST_LIST_TRAVERSE_SAFE_BEGIN(&sla.ringing_trunks, ringing_trunk, entry) {
            if (ringing_trunk->trunk == trunk_ref->trunk) {
                AST_LIST_REMOVE_CURRENT(entry);
                break;
            }
        }
        AST_LIST_TRAVERSE_SAFE_END
        ast_mutex_unlock(&sla.lock);
 
        if (ringing_trunk) {
            answer_trunk_chan(ringing_trunk->trunk->chan);
            sla_change_trunk_state(ringing_trunk->trunk, SLA_TRUNK_STATE_UP, ALL_TRUNK_REFS, NULL);
 
            sla_ringing_trunk_destroy(ringing_trunk);
 
            /* Queue up reprocessing ringing trunks, and then ringing stations again */
            sla_queue_event(SLA_EVENT_RINGING_TRUNK);
            sla_queue_event(SLA_EVENT_DIAL_STATE);
        }
    }
 
    trunk_ref->chan = chan;
 
    if (!trunk_ref->trunk->chan) {
        ast_mutex_t cond_lock;
        ast_cond_t cond;
        pthread_t dont_care;
        struct dial_trunk_args args = {
            .trunk_ref = trunk_ref,
            .station = station,
            .cond_lock = &cond_lock,
            .cond = &cond,
        };
        ao2_ref(trunk_ref, 1);
        ao2_ref(station, 1);
        sla_change_trunk_state(trunk_ref->trunk, SLA_TRUNK_STATE_UP, ALL_TRUNK_REFS, NULL);
        /* Create a thread to dial the trunk and dump it into the conference.
         * However, we want to wait until the trunk has been dialed and the
         * conference is created before continuing on here.
         * Don't autoservice the channel or we'll have multiple threads
         * handling it. dial_trunk services the channel.
         */
        ast_mutex_init(&cond_lock);
        ast_cond_init(&cond, NULL);
        ast_mutex_lock(&cond_lock);
        ast_pthread_create_detached_background(&dont_care, NULL, dial_trunk, &args);
        ast_cond_wait(&cond, &cond_lock);
        ast_mutex_unlock(&cond_lock);
        ast_mutex_destroy(&cond_lock);
        ast_cond_destroy(&cond);
 
        if (!trunk_ref->trunk->chan) {
            ast_debug(1, "Trunk didn't get created. chan: %lx\n", (unsigned long) trunk_ref->trunk->chan);
            pbx_builtin_setvar_helper(chan, "SLASTATION_STATUS", "CONGESTION");
            sla_change_trunk_state(trunk_ref->trunk, SLA_TRUNK_STATE_IDLE, ALL_TRUNK_REFS, NULL);
            trunk_ref->chan = NULL;
            return 0;
        }
    }
 
    if (ast_atomic_fetchadd_int((int *) &trunk_ref->trunk->active_stations, 1) == 0 &&
        trunk_ref->trunk->on_hold) {
        trunk_ref->trunk->on_hold = 0;
        ast_indicate(trunk_ref->trunk->chan, AST_CONTROL_UNHOLD);
        sla_change_trunk_state(trunk_ref->trunk, SLA_TRUNK_STATE_UP, ALL_TRUNK_REFS, NULL);
    }
 
    snprintf(conf_name, sizeof(conf_name), "SLA_%s", trunk_ref->trunk->name);
    ast_set_flag(&conf_flags, CONFFLAG_QUIET | CONFFLAG_MARKEDEXIT | CONFFLAG_PASS_DTMF | CONFFLAG_SLA_STATION);
    ast_answer(chan);
 
    ast_debug(2, "Station %s joining conference %s\n", station->name, conf_name);
    conf_run(chan, conf_name, &conf_flags, NULL);
 
    trunk_ref->chan = NULL;
    if (ast_atomic_dec_and_test((int *) &trunk_ref->trunk->active_stations) &&
        trunk_ref->state != SLA_TRUNK_STATE_ONHOLD_BYME) {
        conf_kick_all(chan, conf_name);
        trunk_ref->trunk->hold_stations = 0;
        sla_change_trunk_state(trunk_ref->trunk, SLA_TRUNK_STATE_IDLE, ALL_TRUNK_REFS, NULL);
    }
 
    pbx_builtin_setvar_helper(chan, "SLASTATION_STATUS", "SUCCESS");
 
    return 0;
}

References sla_trunk::active_stations, ALL_TRUNK_REFS, answer_trunk_chan(), ao2_cleanup, ao2_lock, ao2_ref, ao2_unlock, args, ast_answer(), ast_atomic_dec_and_test(), ast_atomic_fetchadd_int(), ast_cond_destroy, ast_cond_init, ast_cond_wait, AST_CONTROL_UNHOLD, ast_debug, AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_indicate(), AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_pthread_create_detached_background, ast_set_flag, ast_strdupa, ast_strlen_zero(), sla_trunk::chan, sla_trunk_ref::chan, cond, dial_trunk_args::cond_lock, conf_kick_all(), conf_run(), CONFFLAG_MARKEDEXIT, CONFFLAG_PASS_DTMF, CONFFLAG_QUIET, CONFFLAG_SLA_STATION, dial_trunk(), sla_ringing_trunk::entry, sla_trunk::hold_stations, LOG_NOTICE, LOG_WARNING, MAX_CONFNUM, sla_trunk::name, NULL, sla_trunk::on_hold, pbx_builtin_setvar_helper(), RAII_VAR, sla, sla_change_trunk_state(), sla_choose_idle_trunk(), SLA_EVENT_DIAL_STATE, SLA_EVENT_RINGING_TRUNK, sla_find_station(), sla_find_trunk_ref_byname(), sla_queue_event(), sla_ringing_trunk_destroy(), SLA_TRUNK_STATE_IDLE, SLA_TRUNK_STATE_ONHOLD_BYME, SLA_TRUNK_STATE_RINGING, SLA_TRUNK_STATE_UP, sla_trunk_ref::state, dial_trunk_args::station, strsep(), sla_trunk_ref::trunk, sla_ringing_trunk::trunk, and dial_trunk_args::trunk_ref.

Referenced by load_module().

sla_station_is_marked()

static int sla_station_is_marked ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2726 of file app_sla.c.

{
    struct sla_station *station = obj;
 
    ao2_lock(station);
 
    if (station->mark) {
        /* Only remove all of the trunk references if the station itself is going away */
        sla_station_release_refs(station, NULL, 0);
    } else {
        struct sla_trunk_ref *trunk_ref;
 
        /* Otherwise only remove references to trunks no longer in the config */
        AST_LIST_TRAVERSE_SAFE_BEGIN(&station->trunks, trunk_ref, entry) {
            if (!trunk_ref->mark) {
                continue;
            }
            AST_LIST_REMOVE_CURRENT(entry);
            ao2_ref(trunk_ref, -1);
        }
        AST_LIST_TRAVERSE_SAFE_END
    }
 
    ao2_unlock(station);
 
    return station->mark ? CMP_MATCH : 0;
}

References ao2_lock, ao2_ref, ao2_unlock, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, CMP_MATCH, sla_trunk_ref::entry, sla_station::mark, sla_trunk_ref::mark, NULL, sla_station_release_refs(), and sla_station::trunks.

Referenced by sla_load_config().

sla_station_mark()

static int sla_station_mark ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2680 of file app_sla.c.

{
    struct sla_station *station = obj;
    struct sla_trunk_ref *trunk_ref;
 
    ao2_lock(station);
 
    station->mark = 1;
 
    AST_LIST_TRAVERSE(&station->trunks, trunk_ref, entry) {
        trunk_ref->mark = 1;
    }
 
    ao2_unlock(station);
 
    return 0;
}

References ao2_lock, ao2_unlock, AST_LIST_TRAVERSE, sla_trunk_ref::entry, sla_station::mark, sla_trunk_ref::mark, and sla_station::trunks.

Referenced by sla_load_config().

sla_station_ref_destructor()

static void sla_station_ref_destructor ( void *  obj )

static

Definition at line 795 of file app_sla.c.

{
    struct sla_station_ref *station_ref = obj;
 
    if (station_ref->station) {
        ao2_ref(station_ref->station, -1);
        station_ref->station = NULL;
    }
}

References ao2_ref, NULL, and sla_station_ref::station.

Referenced by sla_create_station_ref().

sla_station_release_refs()

static int sla_station_release_refs ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2291 of file app_sla.c.

{
    struct sla_station *station = obj;
    struct sla_trunk_ref *trunk_ref;
 
    while ((trunk_ref = AST_LIST_REMOVE_HEAD(&station->trunks, entry))) {
        ao2_ref(trunk_ref, -1);
    }
 
    return 0;
}

References ao2_ref, AST_LIST_REMOVE_HEAD, sla_trunk_ref::entry, and sla_station::trunks.

Referenced by sla_destroy(), sla_station_destructor(), and sla_station_is_marked().

sla_stop_ringing_station()

static void sla_stop_ringing_station ( struct sla_ringing_station *  ringing_station, enum sla_station_hangup  hangup  )

static

Definition at line 1038 of file app_sla.c.

{
    struct sla_ringing_trunk *ringing_trunk;
    struct sla_trunk_ref *trunk_ref;
    struct sla_station_ref *station_ref;
 
    ast_dial_join(ringing_station->station->dial);
    ast_dial_destroy(ringing_station->station->dial);
    ringing_station->station->dial = NULL;
 
    if (hangup == SLA_STATION_HANGUP_NORMAL) {
        goto done;
    }
 
    /* If the station is being hung up because of a timeout, then add it to the
     * list of timed out stations on each of the ringing trunks.  This is so
     * that when doing further processing to figure out which stations should be
     * ringing, which trunk to answer, determining timeouts, etc., we know which
     * ringing trunks we should ignore. */
    AST_LIST_TRAVERSE(&sla.ringing_trunks, ringing_trunk, entry) {
        AST_LIST_TRAVERSE(&ringing_station->station->trunks, trunk_ref, entry) {
            if (ringing_trunk->trunk == trunk_ref->trunk) {
                break;
            }
        }
        if (!trunk_ref) {
            continue;
        }
        if (!(station_ref = sla_create_station_ref(ringing_station->station))) {
            continue;
        }
        AST_LIST_INSERT_TAIL(&ringing_trunk->timed_out_stations, station_ref, entry);
    }
 
done:
    sla_ringing_station_destroy(ringing_station);
}

References ast_dial_destroy(), ast_dial_join(), AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, sla_station::dial, done, sla_station_ref::entry, hangup(), NULL, sla, sla_create_station_ref(), sla_ringing_station_destroy(), SLA_STATION_HANGUP_NORMAL, sla_ringing_station::station, sla_ringing_trunk::timed_out_stations, sla_trunk_ref::trunk, sla_ringing_trunk::trunk, and sla_station::trunks.

Referenced by sla_calc_station_timeouts(), and sla_handle_dial_state_event().

sla_stop_ringing_trunk()

static void sla_stop_ringing_trunk ( struct sla_ringing_trunk *  ringing_trunk )

static

Definition at line 1024 of file app_sla.c.

{
    struct sla_station_ref *station_ref;
 
    conf_kick_all(ringing_trunk->trunk->chan, ringing_trunk->trunk->name);
    sla_change_trunk_state(ringing_trunk->trunk, SLA_TRUNK_STATE_IDLE, ALL_TRUNK_REFS, NULL);
 
    while ((station_ref = AST_LIST_REMOVE_HEAD(&ringing_trunk->timed_out_stations, entry))) {
        ao2_ref(station_ref, -1);
    }
 
    sla_ringing_trunk_destroy(ringing_trunk);
}

References ALL_TRUNK_REFS, ao2_ref, AST_LIST_REMOVE_HEAD, sla_trunk::chan, conf_kick_all(), sla_station_ref::entry, sla_trunk::name, NULL, sla_change_trunk_state(), sla_ringing_trunk_destroy(), SLA_TRUNK_STATE_IDLE, sla_ringing_trunk::timed_out_stations, and sla_ringing_trunk::trunk.

Referenced by sla_calc_trunk_timeouts().

sla_thread()

static void * sla_thread ( void *  data )

static

Definition at line 1735 of file app_sla.c.

{
    struct sla_failed_station *failed_station;
    struct sla_ringing_station *ringing_station;
 
    ast_mutex_lock(&sla.lock);
 
    while (!sla.stop) {
        struct sla_event *event;
        struct timespec ts = { 0, };
        unsigned int have_timeout = 0;
 
        if (AST_LIST_EMPTY(&sla.event_q)) {
            if ((have_timeout = sla_process_timers(&ts))) {
                ast_cond_timedwait(&sla.cond, &sla.lock, &ts);
            } else {
                ast_cond_wait(&sla.cond, &sla.lock);
            }
            if (sla.stop) {
                break;
            }
        }
 
        if (have_timeout) {
            sla_process_timers(NULL);
        }
 
        while ((event = AST_LIST_REMOVE_HEAD(&sla.event_q, entry))) {
            ast_mutex_unlock(&sla.lock);
            switch (event->type) {
            case SLA_EVENT_HOLD:
                sla_handle_hold_event(event);
                break;
            case SLA_EVENT_DIAL_STATE:
                sla_handle_dial_state_event();
                break;
            case SLA_EVENT_RINGING_TRUNK:
                sla_handle_ringing_trunk_event();
                break;
            }
            sla_event_destroy(event);
            ast_mutex_lock(&sla.lock);
        }
    }
 
    ast_mutex_unlock(&sla.lock);
 
    while ((ringing_station = AST_LIST_REMOVE_HEAD(&sla.ringing_stations, entry))) {
        sla_ringing_station_destroy(ringing_station);
    }
 
    while ((failed_station = AST_LIST_REMOVE_HEAD(&sla.failed_stations, entry))) {
        sla_failed_station_destroy(failed_station);
    }
 
    return NULL;
}

References ast_cond_timedwait, ast_cond_wait, AST_LIST_EMPTY, AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, NULL, sla, sla_event_destroy(), SLA_EVENT_DIAL_STATE, SLA_EVENT_HOLD, SLA_EVENT_RINGING_TRUNK, sla_failed_station_destroy(), sla_handle_dial_state_event(), sla_handle_hold_event(), sla_handle_ringing_trunk_event(), sla_process_timers(), and sla_ringing_station_destroy().

Referenced by sla_load_config().

sla_trunk_cmp()

static int sla_trunk_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2327 of file app_sla.c.

{
    struct sla_trunk *trunk = obj, *trunk2 = arg;
 
    return !strcasecmp(trunk->name, trunk2->name) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, and sla_trunk::name.

Referenced by sla_load_config().

sla_trunk_destructor()

static void sla_trunk_destructor ( void *  obj )

static

Definition at line 2381 of file app_sla.c.

{
    struct sla_trunk *trunk = obj;
 
    ast_debug(1, "sla_trunk destructor for '%s'\n", trunk->name);
 
    if (!ast_strlen_zero(trunk->autocontext)) {
        ast_context_remove_extension(trunk->autocontext, "s", 1, sla_registrar);
    }
 
    sla_trunk_release_refs(trunk, NULL, 0);
 
    ast_string_field_free_memory(trunk);
}

References ast_context_remove_extension(), ast_debug, ast_string_field_free_memory, ast_strlen_zero(), sla_trunk::autocontext, sla_trunk::name, NULL, sla_registrar, and sla_trunk_release_refs().

Referenced by sla_build_trunk().

sla_trunk_exec()

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

static

Definition at line 2159 of file app_sla.c.

{
    char conf_name[MAX_CONFNUM];
    struct ast_flags conf_flags = { 0 };
    RAII_VAR(struct sla_trunk *, trunk, NULL, ao2_cleanup);
    struct sla_ringing_trunk *ringing_trunk;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(trunk_name);
        AST_APP_ARG(options);
    );
    char *opts[SLA_TRUNK_OPT_ARG_ARRAY_SIZE] = { NULL, };
    struct ast_flags opt_flags = { 0 };
    char *parse;
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "The SLATrunk application requires an argument, the trunk name\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
    if (args.argc == 2) {
        if (ast_app_parse_options(sla_trunk_opts, &opt_flags, opts, args.options)) {
            ast_log(LOG_ERROR, "Error parsing options for SLATrunk\n");
            return -1;
        }
    }
 
    trunk = sla_find_trunk(args.trunk_name);
 
    if (!trunk) {
        ast_log(LOG_ERROR, "SLA Trunk '%s' not found!\n", args.trunk_name);
        pbx_builtin_setvar_helper(chan, "SLATRUNK_STATUS", "FAILURE");
        return 0;
    }
 
    if (trunk->chan) {
        ast_log(LOG_ERROR, "Call came in on %s, but the trunk is already in use!\n", args.trunk_name);
        pbx_builtin_setvar_helper(chan, "SLATRUNK_STATUS", "FAILURE");
        return 0;
    }
 
    trunk->chan = chan;
 
    if (!(ringing_trunk = queue_ringing_trunk(trunk))) {
        pbx_builtin_setvar_helper(chan, "SLATRUNK_STATUS", "FAILURE");
        return 0;
    }
 
    snprintf(conf_name, sizeof(conf_name), "SLA_%s", args.trunk_name);
    ast_set_flag(&conf_flags, CONFFLAG_QUIET | CONFFLAG_MARKEDEXIT | CONFFLAG_MARKEDUSER | CONFFLAG_PASS_DTMF);
 
    if (ast_test_flag(&opt_flags, SLA_TRUNK_OPT_MOH)) {
        ast_indicate(chan, -1);
        ast_set_flag(&conf_flags, CONFFLAG_MOH);
    } else {
        ast_indicate(chan, AST_CONTROL_RINGING);
    }
 
    ast_debug(2, "Trunk %s joining conference %s\n", args.trunk_name, conf_name);
    conf_run(chan, conf_name, &conf_flags, opts);
    trunk->chan = NULL;
    trunk->on_hold = 0;
 
    sla_change_trunk_state(trunk, SLA_TRUNK_STATE_IDLE, ALL_TRUNK_REFS, NULL);
 
    if (!pbx_builtin_getvar_helper(chan, "SLATRUNK_STATUS")) {
        pbx_builtin_setvar_helper(chan, "SLATRUNK_STATUS", "SUCCESS");
    }
 
    /* Remove the entry from the list of ringing trunks if it is still there. */
    ast_mutex_lock(&sla.lock);
    AST_LIST_TRAVERSE_SAFE_BEGIN(&sla.ringing_trunks, ringing_trunk, entry) {
        if (ringing_trunk->trunk == trunk) {
            AST_LIST_REMOVE_CURRENT(entry);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
    ast_mutex_unlock(&sla.lock);
    if (ringing_trunk) {
        sla_ringing_trunk_destroy(ringing_trunk);
        pbx_builtin_setvar_helper(chan, "SLATRUNK_STATUS", "UNANSWERED");
        /* Queue reprocessing of ringing trunks to make stations stop ringing
         * that shouldn't be ringing after this trunk stopped. */
        sla_queue_event(SLA_EVENT_RINGING_TRUNK);
    }
 
    return 0;
}

References ALL_TRUNK_REFS, ao2_cleanup, args, AST_APP_ARG, ast_app_parse_options(), AST_CONTROL_RINGING, ast_debug, AST_DECLARE_APP_ARGS, ast_indicate(), AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_set_flag, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_test_flag, conf_run(), CONFFLAG_MARKEDEXIT, CONFFLAG_MARKEDUSER, CONFFLAG_MOH, CONFFLAG_PASS_DTMF, CONFFLAG_QUIET, LOG_ERROR, MAX_CONFNUM, NULL, options, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), queue_ringing_trunk(), RAII_VAR, sla, sla_change_trunk_state(), SLA_EVENT_RINGING_TRUNK, sla_find_trunk(), sla_queue_event(), sla_ringing_trunk_destroy(), SLA_TRUNK_OPT_ARG_ARRAY_SIZE, SLA_TRUNK_OPT_MOH, sla_trunk_opts, SLA_TRUNK_STATE_IDLE, and sla_ringing_trunk::trunk.

Referenced by load_module().

sla_trunk_is_marked()

static int sla_trunk_is_marked ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2698 of file app_sla.c.

{
    struct sla_trunk *trunk = obj;
 
    ao2_lock(trunk);
 
    if (trunk->mark) {
        /* Only remove all of the station references if the trunk itself is going away */
        sla_trunk_release_refs(trunk, NULL, 0);
    } else {
        struct sla_station_ref *station_ref;
 
        /* Otherwise only remove references to stations no longer in the config */
        AST_LIST_TRAVERSE_SAFE_BEGIN(&trunk->stations, station_ref, entry) {
            if (!station_ref->mark) {
                continue;
            }
            AST_LIST_REMOVE_CURRENT(entry);
            ao2_ref(station_ref, -1);
        }
        AST_LIST_TRAVERSE_SAFE_END
    }
 
    ao2_unlock(trunk);
 
    return trunk->mark ? CMP_MATCH : 0;
}

References ao2_lock, ao2_ref, ao2_unlock, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, CMP_MATCH, sla_station_ref::entry, sla_station_ref::mark, sla_trunk::mark, NULL, sla_trunk_release_refs(), and sla_trunk::stations.

Referenced by sla_load_config().

sla_trunk_mark()

static int sla_trunk_mark ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2662 of file app_sla.c.

{
    struct sla_trunk *trunk = obj;
    struct sla_station_ref *station_ref;
 
    ao2_lock(trunk);
 
    trunk->mark = 1;
 
    AST_LIST_TRAVERSE(&trunk->stations, station_ref, entry) {
        station_ref->mark = 1;
    }
 
    ao2_unlock(trunk);
 
    return 0;
}

References ao2_lock, ao2_unlock, AST_LIST_TRAVERSE, sla_station_ref::entry, sla_station_ref::mark, sla_trunk::mark, and sla_trunk::stations.

Referenced by sla_load_config().

sla_trunk_ref_destructor()

static void sla_trunk_ref_destructor ( void *  obj )

static

Definition at line 2102 of file app_sla.c.

{
    struct sla_trunk_ref *trunk_ref = obj;
 
    if (trunk_ref->trunk) {
        ao2_ref(trunk_ref->trunk, -1);
        trunk_ref->trunk = NULL;
    }
}

References ao2_ref, NULL, and sla_trunk_ref::trunk.

Referenced by create_trunk_ref().

sla_trunk_release_refs()

static int sla_trunk_release_refs ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2279 of file app_sla.c.

{
    struct sla_trunk *trunk = obj;
    struct sla_station_ref *station_ref;
 
    while ((station_ref = AST_LIST_REMOVE_HEAD(&trunk->stations, entry))) {
        ao2_ref(station_ref, -1);
    }
 
    return 0;
}

References ao2_ref, AST_LIST_REMOVE_HEAD, sla_station_ref::entry, and sla_trunk::stations.

Referenced by sla_destroy(), sla_trunk_destructor(), and sla_trunk_is_marked().

trunkstate2str()

static const char * trunkstate2str ( enum sla_trunk_state  state )

static

Definition at line 427 of file app_sla.c.

{
#define S(e) case e: return # e;
    switch (state) {
    S(SLA_TRUNK_STATE_IDLE)
    S(SLA_TRUNK_STATE_RINGING)
    S(SLA_TRUNK_STATE_UP)
    S(SLA_TRUNK_STATE_ONHOLD)
    S(SLA_TRUNK_STATE_ONHOLD_BYME)
    }
    return "Unknown State";
#undef S
}

References S, SLA_TRUNK_STATE_IDLE, SLA_TRUNK_STATE_ONHOLD, SLA_TRUNK_STATE_ONHOLD_BYME, SLA_TRUNK_STATE_RINGING, and SLA_TRUNK_STATE_UP.

Referenced by sla_show_stations().

unload_module()

static int unload_module ( void  )

static

Definition at line 2830 of file app_sla.c.

{
    int res = 0;
 
    ast_cli_unregister_multiple(cli_sla, ARRAY_LEN(cli_sla));
    res |= ast_unregister_application(slastation_app);
    res |= ast_unregister_application(slatrunk_app);
 
    ast_devstate_prov_del("SLA");
 
    sla_destroy();
 
    return res;
}

References ARRAY_LEN, ast_cli_unregister_multiple(), ast_devstate_prov_del(), ast_unregister_application(), cli_sla, sla_destroy(), slastation_app, and slatrunk_app.

Variable Documentation

__mod_info

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

static

Definition at line 2881 of file app_sla.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2881 of file app_sla.c.

attempt_callerid

unsigned int attempt_callerid

Attempt to handle CallerID, even though it is known not to work properly in some situations.

Definition at line 345 of file app_sla.c.

cli_sla

struct ast_cli_entry cli_sla[]

static

Initial value:

= {
    { .handler =  sla_show_trunks , .summary =  "Show SLA Trunks" ,},
    { .handler =  sla_show_stations , .summary =  "Show SLA Stations" ,},
}

Definition at line 520 of file app_sla.c.

Referenced by load_module(), and unload_module().

cond

ast_cond_t cond

Definition at line 336 of file app_sla.c.

Referenced by __ast_cond_broadcast(), __ast_cond_destroy(), __ast_cond_init(), __ast_cond_signal(), __ast_cond_timedwait(), __ast_cond_wait(), ast_bridge_impart(), ast_safe_sleep_conditional(), bridge_channel_impart_add(), bridge_channel_impart_ds_head_signal(), bridge_channel_impart_wait(), bridge_impart_internal(), console_indicate(), gosubif_exec(), safe_sleep_conditional(), signal_condition(), sla_handle_dial_state_event(), and sla_station_exec().

struct { ... } event_q

struct { ... } failed_stations

first

struct sla_event* first

Definition at line 338 of file app_sla.c.

Referenced by _ast_xmldoc_build_seealso(), _ast_xmldoc_build_since(), ast_category_get_templates(), ast_fax_caps_to_str(), ast_format_str_reduce(), ast_pbx_hangup_handler_show(), ast_print_group(), ast_print_namedgroups(), AST_TEST_DEFINE(), bridge_channel_update_accountcodes_leaving(), check_goto(), context_merge(), decode_(), func_read(), gen_prios(), generate_filenames_string(), get_goto_target(), get_history_info_header(), get_pattern_node(), h261_encap(), h263_encap(), h263p_encap(), h264_encap(), handle_missing_table(), listfilter(), log_jack_status(), mpeg4_encap(), npval2(), pgsql_log(), pitsyn_(), pjsip_aor_function_read(), realtime_arguments_to_fields2(), realtime_sqlite3_destroy(), realtime_sqlite3_helper(), realtime_sqlite3_store(), realtime_sqlite3_update(), realtime_sqlite3_update2(), realtimefield_read(), update2_mysql(), update2_pgsql(), update2_prepare(), xmldoc_get_syntax_cmd(), and xmldoc_parse_cmd_enumlist().

last

struct sla_event* last

Definition at line 338 of file app_sla.c.

Referenced by add_email_attachment(), add_extensions(), adsi_generate(), ast_config_engine_deregister(), ast_db_freetree(), AST_TEST_DEFINE(), build_calendar(), config_mysql(), config_odbc(), config_pgsql(), do_monitor(), function_db_keycount(), function_db_keys(), get_pattern_node(), lintocodec2_frameout(), lintogsm_frameout(), lintoilbc_frameout(), lintolpc10_frameout(), lintospeex_frameout(), load_password(), npval2(), try_firmware(), update_last(), and update_scoreboard().

lock

ast_mutex_t lock

Definition at line 337 of file app_sla.c.

Referenced by __ast_bucket_scheme_register(), __ast_cli_generator(), __ast_codec_register_with_format(), __ast_format_interface_register(), __ast_named_lock_get(), action_lock_unlock_helper(), add_headers_to_message(), add_masquerade_store(), add_transferer_role(), aeap_transport_read(), aeap_transport_write(), after_bridge_cb_find(), after_bridge_cb_setup(), aor_alloc(), ari_ws_session_reset(), ast_aeap_connect(), ast_ari_add_handler(), ast_bridge_basic_set_flags(), ast_bridge_read_after_goto(), ast_bridge_transfer_attended(), ast_bridge_transfer_blind(), ast_cdr_fork(), ast_channel_move(), ast_clear_mixmonitor_methods(), ast_config_engine_deregister(), ast_config_engine_register(), ast_endpoint_snapshot_create(), ast_format_cache_set(), ast_get_extension_for_mime_type(), ast_get_format_for_file_ext(), ast_localtime_wakeup_monitor(), ast_realtime_is_mapping_defined(), ast_serializer_shutdown_group_join(), ast_set_mixmonitor_methods(), ast_sip_format_endpoint_ami(), ast_sip_identify_endpoint(), ast_sip_publish_client_remove(), ast_sip_publish_client_send(), ast_sip_register_endpoint_formatter(), ast_sip_register_endpoint_identifier_with_name(), ast_sip_register_event_publisher_handler(), ast_sip_register_supplement(), ast_sip_session_add_supplements(), ast_sip_session_register_sdp_handler(), ast_sip_session_register_supplement_with_module(), ast_sip_session_unregister_supplement(), ast_sip_unregister_endpoint_formatter(), ast_sip_unregister_endpoint_identifier(), ast_sip_unregister_event_publisher_handler(), ast_sip_unregister_supplement(), ast_spinlock_destroy(), ast_spinlock_init(), ast_spinlock_lock(), ast_spinlock_trylock(), ast_spinlock_unlock(), ast_start_mixmonitor(), ast_stop_mixmonitor(), ast_taskprocessor_set_local(), AST_TEST_DEFINE(), ast_threadpool_push(), ast_threadpool_set_size(), ast_unreal_channel_push_to_bridge(), bridge_base_init(), bridge_basic_change_personality(), bridge_register(), bucket_file_wizard_retrieve(), bucket_wizard_retrieve(), builtin_feature_get_exten(), cancel_and_unpublish(), channel_get_external_vars(), clear_stimulus_queue(), cli_show_channels(), cli_show_endpoint_identifiers(), complex_task(), conf_announce_channel_push(), consumer_exec(), consumer_exec_sync(), consumer_should_stay(), consumer_wait_for(), consumer_wait_for_completion(), expire_contact(), find_engine(), find_route(), generic_lock_unlock_helper(), get_park_common_datastore_copy(), get_publishes_and_update_state(), get_root_handler(), get_wait_bridge_wrapper(), handle_bridge_enter(), handle_cli_core_show_config_mappings(), handle_local_optimization_begin(), handle_local_optimization_end(), has_complex_started(), has_masquerade_store(), internal_feature_read(), internal_feature_write(), internal_featuremap_read(), internal_featuremap_write(), load_module(), load_task(), lock_it(), lock_thread(), message_sink_cb(), mid_test_sync(), one_protocol(), persistent_endpoint_find_or_create(), playback_cancel(), playback_final_update(), playback_first_update(), playback_forward(), playback_pause(), playback_restart(), playback_reverse(), playback_stop(), playback_unpause(), poke_worker(), prometheus_callback_register(), prometheus_callback_unregister(), prometheus_last_scrape_time_get(), prometheus_metric_register(), prometheus_metric_registered_count(), prometheus_metric_unregister(), publisher_client_send(), recording_set_state(), reload_module(), remove_hooks_on_personality_change(), remove_masquerade_store(), remove_stasis_subscriptions(), report_fax_status(), report_receive_fax_status(), report_send_fax_status(), set_touch_variables(), shutdown_has_completed(), shutdown_poke(), shutdown_task_exec(), shutdown_waitfor_completion(), shutdown_waitfor_start(), signal_condition(), simple_task(), sip_outbound_publish_callback(), sip_publisher_service_queue(), sla_queue_event_full(), snoop_determine_format(), sorcery_observer_created(), sorcery_observer_deleted(), sorcery_observer_loaded(), sorcery_observer_updated(), stasis_app_control_record(), stasis_app_playback_get_state(), stasis_app_playback_operation(), stasis_app_recording_operation(), stasis_message_sink_dtor(), stasis_message_sink_should_stay(), stasis_message_sink_wait_for(), stasis_message_sink_wait_for_count(), task(), task_wait(), test_emptied(), test_state_changed(), test_sub(), test_task_pushed(), threadpool_active_thread_idle(), threadpool_idle_thread_dead(), threadpool_tps_emptied(), threadpool_tps_task_pushed(), threadpool_zombie_thread_dead(), unload_module(), unlock_it(), wait_for_completion(), wait_for_complex_completion(), wait_for_complex_start(), wait_for_empty_notice(), wait_for_stimulus(), wait_for_task_pushed(), wait_until_thread_state(), and worker_set_state().

struct { ... } ringing_stations

struct { ... } ringing_trunks

struct { ... } sla

Initial value:

= {
    .thread = AST_PTHREADT_NULL,
}

A structure for data used by the sla thread.

Referenced by dial_trunk(), queue_ringing_trunk(), sla_calc_station_timeouts(), sla_calc_trunk_timeouts(), sla_check_failed_station(), sla_check_ringing_station(), sla_choose_ringing_trunk(), sla_destroy(), sla_handle_dial_state_event(), sla_handle_ringing_trunk_event(), sla_hangup_stations(), sla_load_config(), sla_queue_event_full(), sla_ring_station(), sla_ring_stations(), sla_station_exec(), sla_stop_ringing_station(), sla_thread(), and sla_trunk_exec().

sla_framehook_datastore

const struct ast_datastore_info sla_framehook_datastore

static

Initial value:

= {
    .type = "app_sla",
}

Definition at line 616 of file app_sla.c.

Referenced by attach_framehook(), and remove_framehook().

sla_registrar

const char sla_registrar[] = "SLA"

static

Definition at line 281 of file app_sla.c.

Referenced by sla_build_station(), sla_build_trunk(), sla_destroy(), sla_station_destructor(), and sla_trunk_destructor().

sla_stations

struct ao2_container* sla_stations

static

Definition at line 278 of file app_sla.c.

Referenced by sla_build_station(), sla_calc_station_delays(), sla_change_trunk_state(), sla_destroy(), sla_find_station(), sla_in_use(), sla_load_config(), sla_queue_event_conf(), and sla_show_stations().

sla_trunk_opts

const struct ast_app_option sla_trunk_opts[128] = { [ 'M' ] = { .flag = SLA_TRUNK_OPT_MOH , .arg_index = SLA_TRUNK_OPT_ARG_MOH_CLASS + 1 }, }

static

Definition at line 162 of file app_sla.c.

Referenced by sla_trunk_exec().

sla_trunks

struct ao2_container* sla_trunks

static

Definition at line 279 of file app_sla.c.

Referenced by sla_build_trunk(), sla_destroy(), sla_find_trunk(), sla_in_use(), sla_load_config(), and sla_show_trunks().

slastation_app

const char* const slastation_app = "SLAStation"

static

Definition at line 133 of file app_sla.c.

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

slatrunk_app

const char* const slatrunk_app = "SLATrunk"

static

Definition at line 134 of file app_sla.c.

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

stop

unsigned int stop

Definition at line 342 of file app_sla.c.

Referenced by ast_control_streamfile(), ast_control_streamfile_lang(), ast_control_streamfile_w_cb(), control_streamfile(), controlplayback_exec(), DownSample(), handle_controlstreamfile(), play_on_channel(), queue_exec(), and vparms_().

thread

pthread_t thread

The SLA thread ID

Definition at line 335 of file app_sla.c.

Referenced by __schedule_action(), ari_channels_handle_originate_with_id(), ast_ari_channels_create(), ast_dial_join(), ast_pthread_create_detached_stack(), ast_pthread_create_stack(), cleanup_thread_list(), feature_attended_transfer(), find_idle_thread(), handle_cli_iax2_show_threads(), handle_deferred_full_frames(), iax2_process_thread(), iax2_process_thread_cleanup(), idle_sched_init_pj_thread(), insert_idle_thread(), keepalive_transport_thread(), launch_monitor_thread(), load_module(), naptr_resolve(), pbx_outgoing_attempt(), sip_thread_start(), socket_process(), socket_process_helper(), socket_read(), softmix_bridge_destroy(), sorcery_memory_cache_thrash_create(), sorcery_memory_cache_thrash_destroy(), sorcery_memory_cache_thrash_retrieve(), sorcery_memory_cache_thrash_start(), sorcery_memory_cache_thrash_stop(), sorcery_memory_cache_thrash_update(), srv_resolve(), start_network_thread(), stasis_app_control_snoop(), and unbound_resolver_stop().