app_agent_pool.c File Reference

Call center agent pool. More...

#include "asterisk.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/channel.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_internal.h"
#include "asterisk/bridge_basic.h"
#include "asterisk/bridge_after.h"
#include "asterisk/config_options.h"
#include "asterisk/features_config.h"
#include "asterisk/astobj2.h"
#include "asterisk/stringfields.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/causes.h"

Include dependency graph for app_agent_pool.c:

Go to the source code of this file.

Data Structures
struct	agent_cfg
struct	agent_complete
struct	agent_pvt
	Structure representing an agent. More...
struct	agents_cfg

Macros
#define	agent_lock(agent)   _agent_lock(agent, __FILE__, __PRETTY_FUNCTION__, __LINE__, #agent)
	Lock the agent.
#define	agent_unlock(agent)   _agent_unlock(agent, __FILE__, __PRETTY_FUNCTION__, __LINE__, #agent)
	Unlock the agent.
#define	AST_MAX_BUF   256
#define	CALLER_SAFETY_TIMEOUT_TIME   (2 * 60 * 1000)
#define	FORMAT_HDR   "%-8s %-20s %-11s %-30s %s\n"
#define	FORMAT_ROW   "%-8s %-20s %-11s %-30s %s\n"
#define	LOGIN_WAIT_TIMEOUT_TIME   5

Enumerations
enum	AGENT_LOGIN_OPT_FLAGS { OPT_SILENT = (1 << 0) }
enum	agent_override_flags { AGENT_FLAG_ACK_CALL = (1 << 0) , AGENT_FLAG_DTMF_ACCEPT = (1 << 1) , AGENT_FLAG_AUTO_LOGOFF = (1 << 2) , AGENT_FLAG_WRAPUP_TIME = (1 << 3) }
enum	agent_state {   AGENT_STATE_LOGGED_OUT , AGENT_STATE_PROBATION_WAIT , AGENT_STATE_READY_FOR_CALL , AGENT_STATE_CALL_PRESENT ,   AGENT_STATE_CALL_WAIT_ACK , AGENT_STATE_ON_CALL , AGENT_STATE_CALL_WRAPUP , AGENT_STATE_LOGGING_OUT }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static void	_agent_lock (struct agent_pvt *agent, const char *file, const char *function, int line, const char *var)
static void	_agent_unlock (struct agent_pvt *agent, const char *file, const char *function, int line, const char *var)
static int	action_agent_logoff (struct mansession *s, const struct message *m)
static int	action_agents (struct mansession *s, const struct message *m)
static void	agent_after_bridge_cb (struct ast_channel *chan, void *data)
static void	agent_after_bridge_cb_failed (enum ast_bridge_after_cb_reason reason, void *data)
static void	agent_alert (struct ast_bridge_channel *bridge_channel, const void *payload, size_t payload_size)
static struct ast_bridge_channel *	agent_bridge_channel_get_lock (struct agent_pvt *agent)
static void *	agent_cfg_alloc (const char *name)
static void	agent_cfg_destructor (void *vdoomed)
static void *	agent_cfg_find (struct ao2_container *agents, const char *username)
static int	agent_cfg_sort_cmp (const void *obj_left, const void *obj_right, int flags)
static void	agent_connect_caller (struct ast_bridge_channel *bridge_channel, struct agent_pvt *agent)
static void	agent_devstate_changed (const char *agent_id)
static int	agent_function_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static char *	agent_handle_logoff_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	agent_handle_show_all (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	agent_handle_show_online (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	agent_handle_show_specific (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct ast_channel *	agent_lock_logged (struct agent_pvt *agent)
static void	agent_login_channel_config (struct agent_pvt *agent, struct ast_channel *chan)
static int	agent_login_exec (struct ast_channel *chan, const char *data)
	Dialplan AgentLogin application to log in an agent.
static int	agent_logoff_request (const char *agent_id, int soft)
static void	agent_logout (struct agent_pvt *agent)
static int	agent_mark (void *obj, void *arg, int flags)
static int	agent_pvt_cmp (void *obj, void *arg, int flags)
static void	agent_pvt_destructor (void *vdoomed)
static enum ast_device_state	agent_pvt_devstate_get (const char *agent_id)
static struct agent_pvt *	agent_pvt_new (struct agent_cfg *cfg)
static int	agent_pvt_sort_cmp (const void *obj_left, const void *obj_right, int flags)
static int	agent_request_exec (struct ast_channel *chan, const char *data)
	Dialplan AgentRequest application to locate an agent to talk with.
static void	agent_run (struct agent_pvt *agent, struct ast_channel *logged)
static void	agent_show_requested (struct ast_cli_args *a, int online_only)
static int	agent_sweep (void *obj, void *arg, int flags)
static void *	agents_cfg_alloc (void)
static void	agents_cfg_destructor (void *vdoomed)
static void	agents_mark (void)
static void	agents_post_apply_config (void)
static void	agents_sweep (void)
static	AO2_GLOBAL_OBJ_STATIC (agent_holding)
static	AO2_GLOBAL_OBJ_STATIC (cfg_handle)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	bridge_agent_hold_ack (struct ast_bridge_channel *bridge_channel, void *hook_pvt)
static int	bridge_agent_hold_deferred_create (void)
static void	bridge_agent_hold_dissolving (struct ast_bridge *self)
	The bridge is being dissolved.
static int	bridge_agent_hold_heartbeat (struct ast_bridge_channel *bridge_channel, void *hook_pvt)
static struct ast_bridge *	bridge_agent_hold_new (void)
static void	bridge_agent_hold_pull (struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
static int	bridge_agent_hold_push (struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
static void	bridge_init_agent_hold (void)
static void	caller_abort_agent (struct agent_pvt *agent)
static int	caller_joined_bridge (struct ast_bridge_channel *bridge_channel, void *hook_pvt)
static int	caller_safety_timeout (struct ast_bridge_channel *bridge_channel, void *hook_pvt)
static void	clear_agent_status (struct ast_bridge_channel *bridge_channel, const void *payload, size_t payload_size)
static char *	complete_agent (const char *word, int state)
static char *	complete_agent_logoff (const char *word, int state)
static int	complete_agent_logoff_search (void *obj, void *arg, void *data, int flags)
static int	complete_agent_search (void *obj, void *arg, void *data, int flags)
	CONFIG_INFO_STANDARD (cfg_info, cfg_handle, agents_cfg_alloc,.files=ACO_FILES(&agents_conf),.post_apply_config=agents_post_apply_config,)
static void	destroy_config (void)
static int	load_config (void)
static int	load_module (void)
static int	reload (void)
static void	send_agent_login (struct ast_channel *chan, const char *agent)
static void	send_agent_logoff (struct ast_channel *chan, const char *agent, long logintime)
static int	send_alert_to_agent (struct ast_bridge_channel *bridge_channel, const char *agent_id)
static int	send_colp_to_agent (struct ast_bridge_channel *bridge_channel, struct ast_party_connected_line *connected)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Call center agent pool applications" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_DEVSTATE_PROVIDER, }
static struct ast_custom_function	agent_function
static ast_mutex_t	agent_holding_lock = AST_MUTEX_INIT_VALUE
static const struct ast_app_option	agent_login_opts [128] = { [ 's' ] = { .flag = OPT_SILENT }, }
static struct aco_type	agent_type
static struct aco_type *	agent_types [] = ACO_TYPES(&agent_type)
static struct ao2_container *	agents
static struct aco_file	agents_conf
static const char	app_agent_login [] = "AgentLogin"
static const char	app_agent_request [] = "AgentRequest"
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_bridge_methods	bridge_agent_hold_v_table
static struct ast_cli_entry	cli_agents []
static struct aco_type	general_type

Detailed Description

Call center agent pool.

Author

Richard Mudgett rmudg.nosp@m.ett@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

See Also:

• CREDITS
• Config_agent

Definition in file app_agent_pool.c.

Macro Definition Documentation

agent_lock

#define agent_lock

(

agent

)

_agent_lock(agent, __FILE__, __PRETTY_FUNCTION__, __LINE__, #agent)

Lock the agent.

Parameters

agent

Agent to lock

Definition at line 701 of file app_agent_pool.c.

agent_unlock

#define agent_unlock

(

agent

)

_agent_unlock(agent, __FILE__, __PRETTY_FUNCTION__, __LINE__, #agent)

Unlock the agent.

Parameters

agent

Agent to unlock

Definition at line 712 of file app_agent_pool.c.

AST_MAX_BUF

#define AST_MAX_BUF   256

Definition at line 387 of file app_agent_pool.c.

CALLER_SAFETY_TIMEOUT_TIME

#define CALLER_SAFETY_TIMEOUT_TIME   (2 * 60 * 1000)

Maximum wait time (in ms) for the custom_beep file to play announcing the caller.

Definition at line 390 of file app_agent_pool.c.

FORMAT_HDR

#define FORMAT_HDR   "%-8s %-20s %-11s %-30s %s\n"

FORMAT_ROW

#define FORMAT_ROW   "%-8s %-20s %-11s %-30s %s\n"

LOGIN_WAIT_TIMEOUT_TIME

#define LOGIN_WAIT_TIMEOUT_TIME   5

Number of seconds to wait for local channel optimizations to complete.

Definition at line 393 of file app_agent_pool.c.

Enumeration Type Documentation

AGENT_LOGIN_OPT_FLAGS

enum AGENT_LOGIN_OPT_FLAGS

Enumerator
OPT_SILENT

Definition at line 2119 of file app_agent_pool.c.

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

agent_override_flags

enum agent_override_flags

Agent config option override flags.

Enumerator
AGENT_FLAG_ACK_CALL
AGENT_FLAG_DTMF_ACCEPT
AGENT_FLAG_AUTO_LOGOFF
AGENT_FLAG_WRAPUP_TIME

Definition at line 631 of file app_agent_pool.c.

                          {
    AGENT_FLAG_ACK_CALL = (1 << 0),
    AGENT_FLAG_DTMF_ACCEPT = (1 << 1),
    AGENT_FLAG_AUTO_LOGOFF = (1 << 2),
    AGENT_FLAG_WRAPUP_TIME = (1 << 3),
};

agent_state

enum agent_state

Enumerator
AGENT_STATE_LOGGED_OUT	The agent is defined but an agent is not present.
AGENT_STATE_PROBATION_WAIT	Forced initial login wait to allow any local channel optimizations to happen.
AGENT_STATE_READY_FOR_CALL	The agent is ready for a call.
AGENT_STATE_CALL_PRESENT	The agent has a call waiting to connect.
AGENT_STATE_CALL_WAIT_ACK	The agent needs to ack the call.
AGENT_STATE_ON_CALL	The agent is connected with a call.
AGENT_STATE_CALL_WRAPUP	The agent is resting between calls.
AGENT_STATE_LOGGING_OUT	The agent is being kicked out.

Definition at line 611 of file app_agent_pool.c.

                 {
    /*! The agent is defined but an agent is not present. */
    AGENT_STATE_LOGGED_OUT,
    /*! Forced initial login wait to allow any local channel optimizations to happen. */
    AGENT_STATE_PROBATION_WAIT,
    /*! The agent is ready for a call. */
    AGENT_STATE_READY_FOR_CALL,
    /*! The agent has a call waiting to connect. */
    AGENT_STATE_CALL_PRESENT,
    /*! The agent needs to ack the call. */
    AGENT_STATE_CALL_WAIT_ACK,
    /*! The agent is connected with a call. */
    AGENT_STATE_ON_CALL,
    /*! The agent is resting between calls. */
    AGENT_STATE_CALL_WRAPUP,
    /*! The agent is being kicked out. */
    AGENT_STATE_LOGGING_OUT,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2739 of file app_agent_pool.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2739 of file app_agent_pool.c.

_agent_lock()

static void _agent_lock ( struct agent_pvt *  agent, const char *  file, const char *  function, int  line, const char *  var  )

inlinestatic

Definition at line 702 of file app_agent_pool.c.

{
    __ao2_lock(agent, AO2_LOCK_REQ_MUTEX, file, function, line, var);
}

References __ao2_lock(), AO2_LOCK_REQ_MUTEX, and var.

_agent_unlock()

static void _agent_unlock ( struct agent_pvt *  agent, const char *  file, const char *  function, int  line, const char *  var  )

inlinestatic

Definition at line 713 of file app_agent_pool.c.

{
    __ao2_unlock(agent, file, function, line, var);
}

References __ao2_unlock(), and var.

action_agent_logoff()

static int action_agent_logoff ( struct mansession *  s, const struct message *  m  )

static

Definition at line 2628 of file app_agent_pool.c.

{
    const char *agent = astman_get_header(m, "Agent");
    const char *soft_s = astman_get_header(m, "Soft"); /* "true" is don't hangup */
 
    if (ast_strlen_zero(agent)) {
        astman_send_error(s, m, "No agent specified");
        return 0;
    }
 
    if (!agent_logoff_request(agent, ast_true(soft_s))) {
        astman_send_ack(s, m, "Agent logged out");
    } else {
        astman_send_error(s, m, "No such agent");
    }
 
    return 0;
}

References agent_logoff_request(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), and astman_send_error().

Referenced by load_module().

action_agents()

static int action_agents ( struct mansession *  s, const struct message *  m  )

static

Definition at line 2550 of file app_agent_pool.c.

{
    const char *id = astman_get_header(m, "ActionID");
    char id_text[AST_MAX_BUF];
    struct ao2_iterator iter;
    struct agent_pvt *agent;
    struct ast_str *out = ast_str_alloca(4096);
    int num_agents = 0;
 
    if (!ast_strlen_zero(id)) {
        snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
    } else {
        id_text[0] = '\0';
    }
    astman_send_listack(s, m, "Agents will follow", "start");
 
    iter = ao2_iterator_init(agents, 0);
    for (; (agent = ao2_iterator_next(&iter)); ao2_ref(agent, -1)) {
        struct ast_channel *logged;
 
        agent_lock(agent);
        logged = agent_lock_logged(agent);
 
        /*
         * Status Values:
         * AGENT_LOGGEDOFF - Agent isn't logged in
         * AGENT_IDLE      - Agent is logged in, and waiting for call
         * AGENT_ONCALL    - Agent is logged in, and on a call
         * AGENT_UNKNOWN   - Don't know anything about agent. Shouldn't ever get this.
         */
        ast_str_set(&out, 0, "Agent: %s\r\n", agent->username);
        ast_str_append(&out, 0, "Name: %s\r\n", agent->cfg->full_name);
 
        if (logged) {
            const char *talking_to_chan;
            struct ast_str *logged_headers;
            RAII_VAR(struct ast_channel_snapshot *, logged_snapshot, ast_channel_snapshot_create(logged), ao2_cleanup);
 
            if (!logged_snapshot
                || !(logged_headers =
                     ast_manager_build_channel_state_string(logged_snapshot))) {
                ast_channel_unlock(logged);
                ast_channel_unref(logged);
                agent_unlock(agent);
                continue;
            }
 
            talking_to_chan = pbx_builtin_getvar_helper(logged, "BRIDGEPEER");
            if (!ast_strlen_zero(talking_to_chan)) {
                ast_str_append(&out, 0, "Status: %s\r\n", "AGENT_ONCALL");
                ast_str_append(&out, 0, "TalkingToChan: %s\r\n", talking_to_chan);
                ast_str_append(&out, 0, "CallStarted: %ld\n", (long) agent->call_start);
            } else {
                ast_str_append(&out, 0, "Status: %s\r\n", "AGENT_IDLE");
            }
            ast_str_append(&out, 0, "LoggedInTime: %ld\r\n", (long) agent->login_start);
            ast_str_append(&out, 0, "%s", ast_str_buffer(logged_headers));
            ast_channel_unlock(logged);
            ast_channel_unref(logged);
            ast_free(logged_headers);
        } else {
            ast_str_append(&out, 0, "Status: %s\r\n", "AGENT_LOGGEDOFF");
        }
 
        agent_unlock(agent);
 
        astman_append(s, "Event: Agents\r\n"
            "%s%s\r\n",
            ast_str_buffer(out), id_text);
        ++num_agents;
    }
    ao2_iterator_destroy(&iter);
 
    astman_send_list_complete_start(s, m, "AgentsComplete", num_agents);
    astman_send_list_complete_end(s);
    return 0;
}

References agent_lock, agent_lock_logged(), agent_unlock, agents, ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_snapshot_create(), ast_channel_unlock, ast_channel_unref, ast_free, ast_manager_build_channel_state_string(), AST_MAX_BUF, ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), agent_pvt::call_start, agent_pvt::cfg, agent_cfg::full_name, agent_pvt::login_start, out, pbx_builtin_getvar_helper(), RAII_VAR, and agent_pvt::username.

Referenced by load_module().

agent_after_bridge_cb()

static void agent_after_bridge_cb ( struct ast_channel *  chan, void *  data  )

static

Definition at line 1643 of file app_agent_pool.c.

{
    struct agent_pvt *agent;
 
    agent = ao2_find(agents, chan, 0);
    if (!agent) {
        return;
    }
 
    ast_debug(1, "Agent %s: New agent channel %s.\n",
        agent->username, ast_channel_name(chan));
    agent_run(agent, chan);
    ao2_ref(agent, -1);
}

References agent_run(), agents, ao2_find, ao2_ref, ast_channel_name(), ast_debug, and agent_pvt::username.

Referenced by bridge_agent_hold_push().

agent_after_bridge_cb_failed()

static void agent_after_bridge_cb_failed ( enum ast_bridge_after_cb_reason  reason, void *  data  )

static

Definition at line 1658 of file app_agent_pool.c.

{
    struct ast_channel *chan = data;
    struct agent_pvt *agent;
 
    agent = ao2_find(agents, chan, 0);
    if (!agent) {
        return;
    }
    ast_log(LOG_WARNING, "Agent %s: Forced logout.  Lost control of %s because: %s\n",
        agent->username, ast_channel_name(chan),
        ast_bridge_after_cb_reason_string(reason));
    agent_lock(agent);
    agent_logout(agent);
    ao2_ref(agent, -1);
}

References agent_lock, agent_logout(), agents, ao2_find, ao2_ref, ast_bridge_after_cb_reason_string(), ast_channel_name(), ast_log, ast_channel::data, LOG_WARNING, and agent_pvt::username.

Referenced by bridge_agent_hold_push().

agent_alert()

static void agent_alert ( struct ast_bridge_channel *  bridge_channel, const void *  payload, size_t  payload_size  )

static

Definition at line 1763 of file app_agent_pool.c.

{
    const char *agent_id = payload;
    const char *playfile;
    const char *dtmf_accept;
    struct agent_pvt *agent;
    int digit;
    char dtmf[2];
 
    agent = ao2_find(agents, agent_id, OBJ_KEY);
    if (!agent) {
        ast_debug(1, "Agent '%s' does not exist.  Where did it go?\n", agent_id);
        return;
    }
 
    /* Change holding bridge participant role's idle mode to silence */
    ast_bridge_channel_lock_bridge(bridge_channel);
    ast_bridge_channel_clear_roles(bridge_channel);
    ast_channel_set_bridge_role_option(bridge_channel->chan, "holding_participant", "idle_mode", "silence");
    ast_bridge_channel_establish_roles(bridge_channel);
    ast_bridge_unlock(bridge_channel->bridge);
 
    agent_lock(agent);
    playfile = ast_strdupa(agent->cfg->beep_sound);
 
    /* Determine which DTMF digits interrupt the alerting signal. */
    if (ast_test_flag(agent, AGENT_FLAG_ACK_CALL)
        ? agent->override_ack_call : agent->cfg->ack_call) {
        dtmf_accept = ast_test_flag(agent, AGENT_FLAG_DTMF_ACCEPT)
            ? agent->override_dtmf_accept : agent->cfg->dtmf_accept;
 
        /* Only the first digit of the ack will stop playback. */
        dtmf[0] = *dtmf_accept;
        dtmf[1] = '\0';
        dtmf_accept = dtmf;
    } else {
        dtmf_accept = NULL;
    }
    agent_unlock(agent);
 
    /* Alert the agent. */
    digit = ast_stream_and_wait(bridge_channel->chan, playfile,
        ast_strlen_zero(dtmf_accept) ? AST_DIGIT_ANY : dtmf_accept);
    ast_stopstream(bridge_channel->chan);
 
    agent_lock(agent);
    switch (agent->state) {
    case AGENT_STATE_CALL_PRESENT:
        if (!ast_strlen_zero(dtmf_accept)) {
            agent->state = AGENT_STATE_CALL_WAIT_ACK;
            agent->ack_time = ast_tvnow();
 
            if (0 < digit) {
                /* Playback was interrupted by a digit. */
                agent_unlock(agent);
                ao2_ref(agent, -1);
                ast_bridge_channel_feature_digit(bridge_channel, digit);
                return;
            }
            break;
        }
 
        /* Connect to caller now. */
        ast_debug(1, "Agent %s: Immediately connecting to call.\n", agent->username);
        agent_connect_caller(bridge_channel, agent);/* Will unlock agent. */
        ao2_ref(agent, -1);
        return;
    default:
        break;
    }
    agent_unlock(agent);
    ao2_ref(agent, -1);
}

References agent_cfg::ack_call, agent_pvt::ack_time, agent_connect_caller(), AGENT_FLAG_ACK_CALL, AGENT_FLAG_DTMF_ACCEPT, agent_lock, AGENT_STATE_CALL_PRESENT, AGENT_STATE_CALL_WAIT_ACK, agent_unlock, agents, ao2_find, ao2_ref, ast_bridge_channel_clear_roles(), ast_bridge_channel_establish_roles(), ast_bridge_channel_feature_digit(), ast_bridge_channel_lock_bridge(), ast_bridge_unlock, ast_channel_set_bridge_role_option(), ast_debug, AST_DIGIT_ANY, ast_stopstream(), ast_strdupa, ast_stream_and_wait(), ast_strlen_zero(), ast_test_flag, ast_tvnow(), agent_cfg::beep_sound, ast_bridge_channel::bridge, agent_pvt::cfg, ast_bridge_channel::chan, digit, agent_cfg::dtmf_accept, NULL, OBJ_KEY, agent_pvt::override_ack_call, agent_pvt::override_dtmf_accept, agent_pvt::state, and agent_pvt::username.

Referenced by send_alert_to_agent().

agent_bridge_channel_get_lock()

static struct ast_bridge_channel * agent_bridge_channel_get_lock ( struct agent_pvt *  agent )

static

Definition at line 1685 of file app_agent_pool.c.

{
    struct ast_channel *logged;
    struct ast_bridge_channel *bc;
 
    for (;;) {
        agent_lock(agent);
        logged = agent->logged;
        if (!logged) {
            agent_unlock(agent);
            return NULL;
        }
        ast_channel_ref(logged);
        agent_unlock(agent);
 
        ast_channel_lock(logged);
        bc = ast_channel_get_bridge_channel(logged);
        ast_channel_unlock(logged);
        ast_channel_unref(logged);
        if (!bc) {
            if (agent->logged != logged) {
                continue;
            }
            return NULL;
        }
 
        ast_bridge_channel_lock(bc);
        if (bc->chan != logged || agent->logged != logged) {
            ast_bridge_channel_unlock(bc);
            ao2_ref(bc, -1);
            continue;
        }
        return bc;
    }
}

References agent_lock, agent_unlock, ao2_ref, ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_ref, ast_channel_unlock, ast_channel_unref, bc, agent_pvt::logged, and NULL.

Referenced by agent_request_exec(), caller_abort_agent(), and caller_joined_bridge().

agent_cfg_alloc()

static void * agent_cfg_alloc ( const char *  name )

static

Definition at line 485 of file app_agent_pool.c.

{
    struct agent_cfg *cfg;
 
    cfg = ao2_alloc_options(sizeof(*cfg), agent_cfg_destructor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!cfg || ast_string_field_init(cfg, 64)) {
        ao2_cleanup(cfg);
        return NULL;
    }
    ast_string_field_set(cfg, username, name);
    return cfg;
}

References agent_cfg_destructor(), AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, ast_string_field_init, ast_string_field_set, name, NULL, and agent_cfg::username.

agent_cfg_destructor()

static void agent_cfg_destructor ( void *  vdoomed )

static

Definition at line 478 of file app_agent_pool.c.

{
    struct agent_cfg *doomed = vdoomed;
 
    ast_string_field_free_memory(doomed);
}

References ast_string_field_free_memory.

Referenced by agent_cfg_alloc().

agent_cfg_find()

static void * agent_cfg_find ( struct ao2_container *  agents, const char *  username  )

static

Definition at line 499 of file app_agent_pool.c.

{
    return ao2_find(agents, username, OBJ_KEY);
}

References agents, ao2_find, OBJ_KEY, and agent_cfg::username.

agent_cfg_sort_cmp()

static int agent_cfg_sort_cmp ( const void *  obj_left, const void *  obj_right, int  flags  )

static

Definition at line 456 of file app_agent_pool.c.

{
    const struct agent_cfg *cfg_left = obj_left;
    const struct agent_cfg *cfg_right = obj_right;
    const char *right_key = obj_right;
    int cmp;
 
    switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
    default:
    case OBJ_POINTER:
        right_key = cfg_right->username;
        /* Fall through */
    case OBJ_KEY:
        cmp = strcmp(cfg_left->username, right_key);
        break;
    case OBJ_PARTIAL_KEY:
        cmp = strncmp(cfg_left->username, right_key, strlen(right_key));
        break;
    }
    return cmp;
}

References OBJ_KEY, OBJ_PARTIAL_KEY, OBJ_POINTER, and agent_cfg::username.

Referenced by agents_cfg_alloc().

agent_connect_caller()

static void agent_connect_caller ( struct ast_bridge_channel *  bridge_channel, struct agent_pvt *  agent  )

static

Definition at line 1067 of file app_agent_pool.c.

{
    struct ast_bridge *caller_bridge;
    int record_agent_calls;
    int res;
 
    record_agent_calls = agent->cfg->record_agent_calls;
    caller_bridge = agent->caller_bridge;
    agent->caller_bridge = NULL;
    agent->state = AGENT_STATE_ON_CALL;
    time(&agent->call_start);
    agent_unlock(agent);
 
    if (!caller_bridge) {
        /* Reset agent. */
        ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END,
            AST_CAUSE_NORMAL_CLEARING);
        return;
    }
    res = ast_bridge_move(caller_bridge, bridge_channel->bridge, bridge_channel->chan,
        NULL, 0);
    if (res) {
        /* Reset agent. */
        ast_bridge_destroy(caller_bridge, 0);
        ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END,
            AST_CAUSE_NORMAL_CLEARING);
        return;
    }
    res = ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_ANSWER, NULL, 0)
        || ast_bridge_channel_write_callback(bridge_channel, 0, clear_agent_status, NULL, 0);
    if (res) {
        /* Reset agent. */
        ast_bridge_destroy(caller_bridge, 0);
        return;
    }
 
    if (record_agent_calls) {
        struct ast_bridge_features_automixmonitor options = {
            .start_stop = AUTO_MONITOR_START,
            };
 
        /*
         * The agent is in the new bridge so we can invoke the
         * mixmonitor hook to only start recording.
         */
        ast_bridge_features_do(AST_BRIDGE_BUILTIN_AUTOMIXMON, bridge_channel, &options);
    }
 
    ao2_t_ref(caller_bridge, -1, "Agent successfully in caller_bridge");
}

References AGENT_STATE_ON_CALL, agent_unlock, ao2_t_ref, AST_BRIDGE_BUILTIN_AUTOMIXMON, ast_bridge_channel_leave_bridge(), ast_bridge_channel_write_callback(), ast_bridge_channel_write_control_data(), ast_bridge_destroy(), ast_bridge_features_do(), ast_bridge_move(), AST_CAUSE_NORMAL_CLEARING, AST_CONTROL_ANSWER, AUTO_MONITOR_START, ast_bridge_channel::bridge, BRIDGE_CHANNEL_STATE_END, agent_pvt::call_start, agent_pvt::caller_bridge, agent_pvt::cfg, ast_bridge_channel::chan, clear_agent_status(), NULL, options, agent_cfg::record_agent_calls, and agent_pvt::state.

Referenced by agent_alert(), and bridge_agent_hold_ack().

agent_devstate_changed()

static void agent_devstate_changed ( const char *  agent_id )

static

Definition at line 793 of file app_agent_pool.c.

{
    ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "Agent:%s", agent_id);
}

References AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, and ast_devstate_changed().

Referenced by agent_logout(), agent_pvt_destructor(), agent_request_exec(), agents_post_apply_config(), bridge_agent_hold_heartbeat(), and bridge_agent_hold_push().

agent_function_read()

static int agent_function_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Definition at line 2207 of file app_agent_pool.c.

{
    char *parse;
    struct agent_pvt *agent;
    struct ast_channel *logged;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(agentid);
        AST_APP_ARG(item);
    );
 
    buf[0] = '\0';
 
    parse = ast_strdupa(data ?: "");
    AST_NONSTANDARD_APP_ARGS(args, parse, ':');
 
    if (ast_strlen_zero(args.agentid)) {
        ast_log(LOG_WARNING, "The AGENT function requires an argument - agentid!\n");
        return -1;
    }
    if (!args.item) {
        args.item = "status";
    }
 
    agent = ao2_find(agents, args.agentid, OBJ_KEY);
    if (!agent) {
        ast_log(LOG_WARNING, "Agent '%s' not found!\n", args.agentid);
        return -1;
    }
 
    agent_lock(agent);
    if (!strcasecmp(args.item, "status")) {
        const char *status;
 
        if (agent->logged) {
            status = "LOGGEDIN";
        } else {
            status = "LOGGEDOUT";
        }
        ast_copy_string(buf, status, len);
    } else if (!strcasecmp(args.item, "name")) {
        ast_copy_string(buf, agent->cfg->full_name, len);
    } else if (!strcasecmp(args.item, "mohclass")) {
        ast_copy_string(buf, agent->cfg->moh, len);
    } else if (!strcasecmp(args.item, "channel")) {
        logged = agent_lock_logged(agent);
        if (logged) {
            char *pos;
 
            ast_copy_string(buf, ast_channel_name(logged), len);
            ast_channel_unlock(logged);
            ast_channel_unref(logged);
 
            pos = strrchr(buf, '-');
            if (pos) {
                *pos = '\0';
            }
        }
    } else if (!strcasecmp(args.item, "fullchannel")) {
        logged = agent_lock_logged(agent);
        if (logged) {
            ast_copy_string(buf, ast_channel_name(logged), len);
            ast_channel_unlock(logged);
            ast_channel_unref(logged);
        }
    }
    agent_unlock(agent);
    ao2_ref(agent, -1);
 
    return 0;
}

References agent_lock, agent_lock_logged(), agent_unlock, agents, ao2_find, ao2_ref, args, AST_APP_ARG, ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_log, AST_NONSTANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), buf, agent_pvt::cfg, ast_channel::data, agent_cfg::full_name, item, len(), LOG_WARNING, agent_pvt::logged, agent_cfg::moh, OBJ_KEY, and status.

agent_handle_logoff_cmd()

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

static

Definition at line 2508 of file app_agent_pool.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "agent logoff";
        e->usage =
            "Usage: agent logoff <agent-id> [soft]\n"
            "       Sets an agent as no longer logged in.\n"
            "       If 'soft' is specified, do not hangup existing calls.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 2) {
            return complete_agent_logoff(a->word, a->n);
        } else if (a->pos == 3 && a->n == 0
            && (ast_strlen_zero(a->word)
                || !strncasecmp("soft", a->word, strlen(a->word)))) {
            return ast_strdup("soft");
        }
        return NULL;
    }
 
    if (a->argc < 3 || 4 < a->argc) {
        return CLI_SHOWUSAGE;
    }
    if (a->argc == 4 && strcasecmp(a->argv[3], "soft")) {
        return CLI_SHOWUSAGE;
    }
 
    if (!agent_logoff_request(a->argv[2], a->argc == 4)) {
        ast_cli(a->fd, "Logging out %s\n", a->argv[2]);
    }
 
    return CLI_SUCCESS;
}

References a, agent_logoff_request(), ast_cli(), ast_strdup, ast_strlen_zero(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_agent_logoff(), NULL, and ast_cli_entry::usage.

agent_handle_show_all()

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

static

Definition at line 2427 of file app_agent_pool.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "agent show all";
        e->usage =
            "Usage: agent show all\n"
            "       Provides summary information for all agents.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    agent_show_requested(a, 0);
 
    return CLI_SUCCESS;
}

References a, agent_show_requested(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

agent_handle_show_online()

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

static

Definition at line 2405 of file app_agent_pool.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "agent show online";
        e->usage =
            "Usage: agent show online\n"
            "       Provides summary information for logged in agents.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    agent_show_requested(a, 1);
 
    return CLI_SUCCESS;
}

References a, agent_show_requested(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

agent_handle_show_specific()

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

static

Definition at line 2449 of file app_agent_pool.c.

{
    struct agent_pvt *agent;
    struct ast_channel *logged;
    struct ast_str *out = ast_str_alloca(4096);
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "agent show";
        e->usage =
            "Usage: agent show <agent-id>\n"
            "       Show information about the <agent-id> agent\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 2) {
            return complete_agent(a->word, a->n);
        }
        return NULL;
    }
 
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    agent = ao2_find(agents, a->argv[2], OBJ_KEY);
    if (!agent) {
        ast_cli(a->fd, "Agent '%s' not found\n", a->argv[2]);
        return CLI_SUCCESS;
    }
 
    agent_lock(agent);
    logged = agent_lock_logged(agent);
    ast_str_set(&out, 0, "Id: %s\n", agent->username);
    ast_str_append(&out, 0, "Name: %s\n", agent->cfg->full_name);
    ast_str_append(&out, 0, "Beep: %s\n", agent->cfg->beep_sound);
    ast_str_append(&out, 0, "MOH: %s\n", agent->cfg->moh);
    ast_str_append(&out, 0, "RecordCalls: %s\n", AST_CLI_YESNO(agent->cfg->record_agent_calls));
    ast_str_append(&out, 0, "State: %s\n", ast_devstate_str(agent->devstate));
    if (logged) {
        const char *talking_with;
 
        ast_str_append(&out, 0, "LoggedInChannel: %s\n", ast_channel_name(logged));
        ast_str_append(&out, 0, "LoggedInTime: %ld\n", (long) agent->login_start);
        talking_with = pbx_builtin_getvar_helper(logged, "BRIDGEPEER");
        if (!ast_strlen_zero(talking_with)) {
            ast_str_append(&out, 0, "TalkingWith: %s\n", talking_with);
            ast_str_append(&out, 0, "CallStarted: %ld\n", (long) agent->call_start);
        }
        ast_channel_unlock(logged);
        ast_channel_unref(logged);
    }
    agent_unlock(agent);
    ao2_ref(agent, -1);
 
    ast_cli(a->fd, "%s", ast_str_buffer(out));
 
    return CLI_SUCCESS;
}

References a, agent_lock, agent_lock_logged(), agent_unlock, agents, ao2_find, ao2_ref, ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_cli(), AST_CLI_YESNO, ast_devstate_str(), ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_strlen_zero(), agent_cfg::beep_sound, agent_pvt::call_start, agent_pvt::cfg, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_agent(), agent_pvt::devstate, agent_cfg::full_name, agent_pvt::login_start, agent_cfg::moh, NULL, OBJ_KEY, out, pbx_builtin_getvar_helper(), agent_cfg::record_agent_calls, ast_cli_entry::usage, and agent_pvt::username.

agent_lock_logged()

static struct ast_channel * agent_lock_logged ( struct agent_pvt *  agent )

static

Definition at line 729 of file app_agent_pool.c.

{
    struct ast_channel *logged;
 
    for (;;) {
        if (!agent->logged) { /* No owner. Nothing to do. */
            return NULL;
        }
 
        /* If we don't ref the logged, it could be killed when we unlock the agent. */
        logged = ast_channel_ref(agent->logged);
 
        /* Locking logged requires us to lock channel, then agent. */
        agent_unlock(agent);
        ast_channel_lock(logged);
        agent_lock(agent);
 
        /* Check if logged changed during agent unlock period */
        if (logged != agent->logged) {
            /* Channel changed. Unref and do another pass. */
            ast_channel_unlock(logged);
            ast_channel_unref(logged);
        } else {
            /* Channel stayed the same. Return it. */
            return logged;
        }
    }
}

References agent_lock, agent_unlock, ast_channel_lock, ast_channel_ref, ast_channel_unlock, ast_channel_unref, agent_pvt::logged, and NULL.

Referenced by action_agents(), agent_function_read(), agent_handle_show_specific(), agent_logoff_request(), and agent_show_requested().

agent_login_channel_config()

static void agent_login_channel_config ( struct agent_pvt *  agent, struct ast_channel *  chan  )

static

Definition at line 2063 of file app_agent_pool.c.

{
    struct ast_flags opts = { 0 };
    struct ast_party_connected_line connected;
    unsigned int override_ack_call = 0;
    unsigned int override_auto_logoff = 0;
    unsigned int override_wrapup_time = 0;
    const char *override_dtmf_accept = NULL;
    const char *var;
 
    ast_party_connected_line_init(&connected);
 
    /* Get config values from channel. */
    ast_channel_lock(chan);
    ast_party_connected_line_copy(&connected, ast_channel_connected(chan));
 
    var = pbx_builtin_getvar_helper(chan, "AGENTACKCALL");
    if (!ast_strlen_zero(var)) {
        override_ack_call = ast_true(var) ? 1 : 0;
        ast_set_flag(&opts, AGENT_FLAG_ACK_CALL);
    }
 
    var = pbx_builtin_getvar_helper(chan, "AGENTACCEPTDTMF");
    if (!ast_strlen_zero(var)) {
        override_dtmf_accept = ast_strdupa(var);
        ast_set_flag(&opts, AGENT_FLAG_DTMF_ACCEPT);
    }
 
    var = pbx_builtin_getvar_helper(chan, "AGENTAUTOLOGOFF");
    if (!ast_strlen_zero(var)) {
        if (sscanf(var, "%u", &override_auto_logoff) == 1) {
            ast_set_flag(&opts, AGENT_FLAG_AUTO_LOGOFF);
        }
    }
 
    var = pbx_builtin_getvar_helper(chan, "AGENTWRAPUPTIME");
    if (!ast_strlen_zero(var)) {
        if (sscanf(var, "%u", &override_wrapup_time) == 1) {
            ast_set_flag(&opts, AGENT_FLAG_WRAPUP_TIME);
        }
    }
    ast_channel_unlock(chan);
 
    /* Set config values on agent. */
    agent_lock(agent);
    ast_party_connected_line_free(&agent->waiting_colp);
    agent->waiting_colp = connected;
 
    ast_string_field_set(agent, override_dtmf_accept, override_dtmf_accept);
    ast_copy_flags(agent, &opts, AST_FLAGS_ALL);
    agent->override_auto_logoff = override_auto_logoff;
    agent->override_wrapup_time = override_wrapup_time;
    agent->override_ack_call = override_ack_call;
    agent_unlock(agent);
}

References AGENT_FLAG_ACK_CALL, AGENT_FLAG_AUTO_LOGOFF, AGENT_FLAG_DTMF_ACCEPT, AGENT_FLAG_WRAPUP_TIME, agent_lock, agent_unlock, ast_channel_connected(), ast_channel_lock, ast_channel_unlock, ast_copy_flags, AST_FLAGS_ALL, ast_party_connected_line_copy(), ast_party_connected_line_free(), ast_party_connected_line_init(), ast_set_flag, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_true(), connected, NULL, agent_pvt::override_ack_call, agent_pvt::override_auto_logoff, agent_pvt::override_wrapup_time, pbx_builtin_getvar_helper(), var, and agent_pvt::waiting_colp.

Referenced by agent_login_exec().

agent_login_exec()

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

static

Dialplan AgentLogin application to log in an agent.

Parameters

chan	Channel attempting to login as an agent.
data	Application parameters

Return values

0	To continue in dialplan.
-1	To hangup.

Definition at line 2135 of file app_agent_pool.c.

{
    char *parse;
    struct ast_flags opts;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(agent_id);
        AST_APP_ARG(options);
        AST_APP_ARG(other);     /* Any remaining unused arguments */
    );
 
    RAII_VAR(struct agent_pvt *, agent, NULL, ao2_cleanup);
 
    if (bridge_agent_hold_deferred_create()) {
        return -1;
    }
 
    if (ast_channel_state(chan) != AST_STATE_UP && ast_answer(chan)) {
        return -1;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.agent_id)) {
        ast_log(LOG_WARNING, "AgentLogin requires an AgentId\n");
        return -1;
    }
 
    if (ast_app_parse_options(agent_login_opts, &opts, NULL, args.options)) {
        /* General invalid option syntax. */
        return -1;
    }
 
    /* Find the agent. */
    agent = ao2_find(agents, args.agent_id, OBJ_KEY);
    if (!agent) {
        ast_verb(3, "Agent '%s' does not exist.\n", args.agent_id);
        pbx_builtin_setvar_helper(chan, "AGENT_STATUS", "INVALID");
        return 0;
    }
 
    /* Has someone already logged in as this agent already? */
    agent_lock(agent);
    if (agent->logged) {
        agent_unlock(agent);
        ast_verb(3, "Agent '%s' already logged in.\n", agent->username);
        pbx_builtin_setvar_helper(chan, "AGENT_STATUS", "ALREADY_LOGGED_IN");
        return 0;
    }
    agent->logged = ast_channel_ref(chan);
    agent->last_disconnect = ast_tvnow();
    time(&agent->login_start);
    agent->deferred_logoff = 0;
    agent_unlock(agent);
 
    agent_login_channel_config(agent, chan);
 
    if (!ast_test_flag(&opts, OPT_SILENT)) {
        ast_stream_and_wait(chan, "agent-loginok", AST_DIGIT_NONE);
    }
 
    ast_verb(2, "Agent '%s' logged in (format %s/%s)\n", agent->username,
        ast_format_get_name(ast_channel_readformat(chan)),
        ast_format_get_name(ast_channel_writeformat(chan)));
    ast_channel_lock(chan);
    send_agent_login(chan, agent->username);
    ast_channel_unlock(chan);
 
    agent_run(agent, chan);
    return -1;
}

References agent_lock, agent_login_channel_config(), agent_login_opts, agent_run(), agent_unlock, agents, ao2_cleanup, ao2_find, args, ast_answer(), AST_APP_ARG, ast_app_parse_options(), ast_channel_lock, ast_channel_readformat(), ast_channel_ref, ast_channel_unlock, ast_channel_writeformat(), AST_DECLARE_APP_ARGS, AST_DIGIT_NONE, ast_format_get_name(), ast_log, AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_strdupa, ast_stream_and_wait(), ast_strlen_zero(), ast_test_flag, ast_tvnow(), ast_verb, bridge_agent_hold_deferred_create(), LOG_WARNING, NULL, OBJ_KEY, OPT_SILENT, options, pbx_builtin_setvar_helper(), RAII_VAR, and send_agent_login().

Referenced by load_module().

agent_logoff_request()

static int agent_logoff_request ( const char *  agent_id, int  soft  )

static

Definition at line 1012 of file app_agent_pool.c.

{
    struct ast_channel *logged;
    RAII_VAR(struct agent_pvt *, agent, ao2_find(agents, agent_id, OBJ_KEY), ao2_cleanup);
 
    if (!agent) {
        return -1;
    }
 
    agent_lock(agent);
    logged = agent_lock_logged(agent);
    if (logged) {
        if (soft) {
            agent->deferred_logoff = 1;
        } else {
            ast_softhangup(logged, AST_SOFTHANGUP_EXPLICIT);
        }
        ast_channel_unlock(logged);
        ast_channel_unref(logged);
    }
    agent_unlock(agent);
    return 0;
}

References agent_lock, agent_lock_logged(), agent_unlock, agents, ao2_cleanup, ao2_find, ast_channel_unlock, ast_channel_unref, ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, OBJ_KEY, and RAII_VAR.

Referenced by action_agent_logoff(), and agent_handle_logoff_cmd().

agent_logout()

static void agent_logout ( struct agent_pvt *  agent )

static

Definition at line 1508 of file app_agent_pool.c.

{
    struct ast_channel *logged;
    struct ast_bridge *caller_bridge;
    long time_logged_in;
 
    time_logged_in = time(NULL) - agent->login_start;
    logged = agent->logged;
    agent->logged = NULL;
    caller_bridge = agent->caller_bridge;
    agent->caller_bridge = NULL;
    agent->state = AGENT_STATE_LOGGED_OUT;
    agent->devstate = AST_DEVICE_UNAVAILABLE;
    ast_clear_flag(agent, AST_FLAGS_ALL);
    agent_unlock(agent);
    agent_devstate_changed(agent->username);
 
    if (caller_bridge) {
        ast_bridge_destroy(caller_bridge, 0);
    }
 
    ast_channel_lock(logged);
    send_agent_logoff(logged, agent->username, time_logged_in);
    ast_channel_unlock(logged);
    ast_verb(2, "Agent '%s' logged out.  Logged in for %ld seconds.\n",
        agent->username, time_logged_in);
    ast_channel_unref(logged);
}

References agent_devstate_changed(), AGENT_STATE_LOGGED_OUT, agent_unlock, ast_bridge_destroy(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_clear_flag, AST_DEVICE_UNAVAILABLE, AST_FLAGS_ALL, ast_verb, agent_pvt::caller_bridge, agent_pvt::devstate, agent_pvt::logged, agent_pvt::login_start, NULL, send_agent_logoff(), agent_pvt::state, and agent_pvt::username.

Referenced by agent_after_bridge_cb_failed(), and agent_run().

agent_mark()

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

static

Definition at line 911 of file app_agent_pool.c.

{
    struct agent_pvt *agent = obj;
 
    agent_lock(agent);
    agent->the_mark = 1;
    agent_unlock(agent);
    return 0;
}

References agent_lock, agent_unlock, and agent_pvt::the_mark.

Referenced by agents_mark().

agent_pvt_cmp()

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

static

Definition at line 889 of file app_agent_pool.c.

{
    const struct agent_pvt *agent = obj;
    int cmp;
 
    switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
    case OBJ_POINTER:
    case OBJ_KEY:
    case OBJ_PARTIAL_KEY:
        cmp = CMP_MATCH;
        break;
    default:
        if (agent->logged == arg) {
            cmp = CMP_MATCH;
        } else {
            cmp = 0;
        }
        break;
    }
    return cmp;
}

References CMP_MATCH, agent_pvt::flags, agent_pvt::logged, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by load_module().

agent_pvt_destructor()

static void agent_pvt_destructor ( void *  vdoomed )

static

Definition at line 798 of file app_agent_pool.c.

{
    struct agent_pvt *doomed = vdoomed;
 
    /* Make sure device state reflects agent destruction. */
    if (!ast_strlen_zero(doomed->username)) {
        ast_debug(1, "Agent %s: Destroyed.\n", doomed->username);
        agent_devstate_changed(doomed->username);
    }
 
    ast_party_connected_line_free(&doomed->waiting_colp);
    if (doomed->caller_bridge) {
        ast_bridge_destroy(doomed->caller_bridge, 0);
        doomed->caller_bridge = NULL;
    }
    if (doomed->logged) {
        doomed->logged = ast_channel_unref(doomed->logged);
    }
    ao2_cleanup(doomed->cfg);
    doomed->cfg = NULL;
    ast_string_field_free_memory(doomed);
}

References agent_devstate_changed(), ao2_cleanup, ast_bridge_destroy(), ast_channel_unref, ast_debug, ast_party_connected_line_free(), ast_string_field_free_memory, ast_strlen_zero(), agent_pvt::caller_bridge, agent_pvt::cfg, agent_pvt::logged, NULL, agent_pvt::username, and agent_pvt::waiting_colp.

Referenced by agent_pvt_new().

agent_pvt_devstate_get()

static enum ast_device_state agent_pvt_devstate_get ( const char *  agent_id )

static

Definition at line 771 of file app_agent_pool.c.

{
    enum ast_device_state dev_state = AST_DEVICE_INVALID;
    struct agent_pvt *agent;
 
    agent = ao2_find(agents, agent_id, OBJ_KEY);
    if (agent) {
        agent_lock(agent);
        dev_state = agent->devstate;
        agent_unlock(agent);
        ao2_ref(agent, -1);
    }
    return dev_state;
}

References agent_lock, agent_unlock, agents, ao2_find, ao2_ref, AST_DEVICE_INVALID, agent_pvt::devstate, and OBJ_KEY.

Referenced by load_module().

agent_pvt_new()

static struct agent_pvt * agent_pvt_new ( struct agent_cfg *  cfg )

static

Definition at line 821 of file app_agent_pool.c.

{
    struct agent_pvt *agent;
 
    agent = ao2_alloc(sizeof(*agent), agent_pvt_destructor);
    if (!agent) {
        return NULL;
    }
    if (ast_string_field_init(agent, 32)) {
        ao2_ref(agent, -1);
        return NULL;
    }
    ast_string_field_set(agent, username, cfg->username);
    ast_party_connected_line_init(&agent->waiting_colp);
    ao2_ref(cfg, +1);
    agent->cfg = cfg;
    agent->devstate = AST_DEVICE_UNAVAILABLE;
    return agent;
}

References agent_pvt_destructor(), ao2_alloc, ao2_ref, AST_DEVICE_UNAVAILABLE, ast_party_connected_line_init(), ast_string_field_init, ast_string_field_set, agent_pvt::cfg, agent_pvt::devstate, NULL, agent_cfg::username, agent_pvt::username, and agent_pvt::waiting_colp.

Referenced by agents_post_apply_config().

agent_pvt_sort_cmp()

static int agent_pvt_sort_cmp ( const void *  obj_left, const void *  obj_right, int  flags  )

static

Definition at line 857 of file app_agent_pool.c.

{
    const struct agent_pvt *agent_left = obj_left;
    const struct agent_pvt *agent_right = obj_right;
    const char *right_key = obj_right;
    int cmp;
 
    switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
    default:
    case OBJ_POINTER:
        right_key = agent_right->username;
        /* Fall through */
    case OBJ_KEY:
        cmp = strcmp(agent_left->username, right_key);
        break;
    case OBJ_PARTIAL_KEY:
        cmp = strncmp(agent_left->username, right_key, strlen(right_key));
        break;
    }
    return cmp;
}

References agent_pvt::flags, OBJ_KEY, OBJ_PARTIAL_KEY, OBJ_POINTER, and agent_pvt::username.

Referenced by load_module().

agent_request_exec()

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

static

Dialplan AgentRequest application to locate an agent to talk with.

Parameters

chan	Channel wanting to talk with an agent.
data	Application parameters

Return values

0	To continue in dialplan.
-1	To hangup.

Definition at line 1914 of file app_agent_pool.c.

{
    struct ast_bridge *caller_bridge;
    struct ast_bridge_channel *logged;
    char *parse;
    int res;
    struct ast_bridge_features caller_features;
    struct ast_party_connected_line connected;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(agent_id);
        AST_APP_ARG(other);     /* Any remaining unused arguments */
    );
 
    RAII_VAR(struct agent_pvt *, agent, NULL, ao2_cleanup);
 
    if (bridge_agent_hold_deferred_create()) {
        return -1;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.agent_id)) {
        ast_log(LOG_WARNING, "AgentRequest requires an AgentId\n");
        return -1;
    }
 
    /* Find the agent. */
    agent = ao2_find(agents, args.agent_id, OBJ_KEY);
    if (!agent) {
        ast_verb(3, "Agent '%s' does not exist.\n", args.agent_id);
        pbx_builtin_setvar_helper(chan, "AGENT_STATUS", "INVALID");
        return 0;
    }
 
    if (ast_bridge_features_init(&caller_features)) {
        return -1;
    }
 
    /* Add safety timeout hook. */
    ao2_ref(agent, +1);
    if (ast_bridge_interval_hook(&caller_features, 0, CALLER_SAFETY_TIMEOUT_TIME,
        caller_safety_timeout, agent, __ao2_cleanup, AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
        ao2_ref(agent, -1);
        ast_bridge_features_cleanup(&caller_features);
        return -1;
    }
 
    /* Setup the alert agent on caller joining the bridge hook. */
    ao2_ref(agent, +1);
    if (ast_bridge_join_hook(&caller_features, caller_joined_bridge, agent,
        __ao2_cleanup, 0)) {
        ao2_ref(agent, -1);
        ast_bridge_features_cleanup(&caller_features);
        return -1;
    }
 
    caller_bridge = ast_bridge_basic_new();
    if (!caller_bridge) {
        ast_bridge_features_cleanup(&caller_features);
        return -1;
    }
 
    agent_lock(agent);
    switch (agent->state) {
    case AGENT_STATE_LOGGED_OUT:
    case AGENT_STATE_LOGGING_OUT:
        agent_unlock(agent);
        ast_bridge_destroy(caller_bridge, 0);
        ast_bridge_features_cleanup(&caller_features);
        ast_verb(3, "Agent '%s' not logged in.\n", agent->username);
        pbx_builtin_setvar_helper(chan, "AGENT_STATUS", "NOT_LOGGED_IN");
        return 0;
    case AGENT_STATE_READY_FOR_CALL:
        ao2_ref(caller_bridge, +1);
        agent->caller_bridge = caller_bridge;
        agent->state = AGENT_STATE_CALL_PRESENT;
        agent->devstate = AST_DEVICE_INUSE;
        break;
    default:
        agent_unlock(agent);
        ast_bridge_destroy(caller_bridge, 0);
        ast_bridge_features_cleanup(&caller_features);
        ast_verb(3, "Agent '%s' is busy.\n", agent->username);
        pbx_builtin_setvar_helper(chan, "AGENT_STATUS", "BUSY");
        return 0;
    }
    agent_unlock(agent);
    agent_devstate_changed(agent->username);
 
    /* Get COLP for agent. */
    ast_party_connected_line_init(&connected);
    ast_channel_lock(chan);
    ast_connected_line_copy_from_caller(&connected, ast_channel_caller(chan));
    ast_channel_unlock(chan);
 
    logged = agent_bridge_channel_get_lock(agent);
    if (!logged) {
        ast_party_connected_line_free(&connected);
        caller_abort_agent(agent);
        ast_bridge_destroy(caller_bridge, 0);
        ast_bridge_features_cleanup(&caller_features);
        ast_verb(3, "Agent '%s' not logged in.\n", agent->username);
        pbx_builtin_setvar_helper(chan, "AGENT_STATUS", "NOT_LOGGED_IN");
        return 0;
    }
 
    send_colp_to_agent(logged, &connected);
    ast_bridge_channel_unlock(logged);
    ao2_ref(logged, -1);
    ast_party_connected_line_free(&connected);
 
    if (ast_bridge_join(caller_bridge, chan, NULL, &caller_features, NULL,
        AST_BRIDGE_JOIN_PASS_REFERENCE)) {
        caller_abort_agent(agent);
        ast_verb(3, "Agent '%s': Caller %s failed to join the bridge.\n",
            agent->username, ast_channel_name(chan));
        pbx_builtin_setvar_helper(chan, "AGENT_STATUS", "ERROR");
    }
    ast_bridge_features_cleanup(&caller_features);
 
    /* Determine if we need to continue in the dialplan after the bridge. */
    ast_channel_lock(chan);
    if (ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO) {
        /*
         * The bridge was broken for a hangup that isn't real.
         * Don't run the h extension, because the channel isn't
         * really hung up.  This should really only happen with
         * AST_SOFTHANGUP_ASYNCGOTO.
         */
        res = 0;
    } else {
        res = ast_check_hangup(chan)
            || ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)
            || ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENT_STATUS"));
    }
    ast_channel_unlock(chan);
 
    return res ? -1 : 0;
}

References __ao2_cleanup(), agent_bridge_channel_get_lock(), agent_devstate_changed(), agent_lock, AGENT_STATE_CALL_PRESENT, AGENT_STATE_LOGGED_OUT, AGENT_STATE_LOGGING_OUT, AGENT_STATE_READY_FOR_CALL, agent_unlock, agents, ao2_cleanup, ao2_find, ao2_ref, args, AST_APP_ARG, ast_bridge_basic_new(), ast_bridge_channel_unlock, ast_bridge_destroy(), ast_bridge_features_cleanup(), ast_bridge_features_init(), AST_BRIDGE_HOOK_REMOVE_ON_PULL, ast_bridge_interval_hook(), ast_bridge_join(), ast_bridge_join_hook(), AST_BRIDGE_JOIN_PASS_REFERENCE, ast_channel_caller(), ast_channel_flags(), ast_channel_lock, ast_channel_name(), ast_channel_softhangup_internal_flag(), ast_channel_unlock, ast_check_hangup(), ast_connected_line_copy_from_caller(), AST_DECLARE_APP_ARGS, AST_DEVICE_INUSE, AST_FLAG_ZOMBIE, ast_log, ast_party_connected_line_free(), ast_party_connected_line_init(), AST_SOFTHANGUP_ASYNCGOTO, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_verb, bridge_agent_hold_deferred_create(), caller_abort_agent(), caller_joined_bridge(), caller_safety_timeout(), CALLER_SAFETY_TIMEOUT_TIME, connected, LOG_WARNING, NULL, OBJ_KEY, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), RAII_VAR, and send_colp_to_agent().

Referenced by load_module().

agent_run()

static void agent_run ( struct agent_pvt *  agent, struct ast_channel *  logged  )

static

Definition at line 1545 of file app_agent_pool.c.

{
    struct ast_bridge_features features;
 
    if (ast_bridge_features_init(&features)) {
        ast_channel_hangupcause_set(logged, AST_CAUSE_NORMAL_CLEARING);
        goto agent_run_cleanup;
    }
    for (;;) {
        struct agents_cfg *cfgs;
        struct agent_cfg *cfg_new;
        struct agent_cfg *cfg_old;
        struct ast_bridge *holding;
        struct ast_bridge *caller_bridge;
 
        ast_channel_hangupcause_set(logged, AST_CAUSE_NORMAL_CLEARING);
 
        holding = ao2_global_obj_ref(agent_holding);
        if (!holding) {
            ast_debug(1, "Agent %s: Someone destroyed the agent holding bridge.\n",
                agent->username);
            break;
        }
 
        /*
         * When the agent channel leaves the bridging system we usually
         * want to put the agent back into the holding bridge for the
         * next caller.
         */
        ast_bridge_join(holding, logged, NULL, &features, NULL,
            AST_BRIDGE_JOIN_PASS_REFERENCE);
        if (logged != agent->logged) {
            /* This channel is no longer the logged in agent. */
            break;
        }
 
        if (agent->dead) {
            /* The agent is no longer configured. */
            break;
        }
 
        /* Update the agent's config before rejoining the holding bridge. */
        cfgs = ao2_global_obj_ref(cfg_handle);
        if (!cfgs) {
            /* There is no agent configuration.  All agents were destroyed. */
            break;
        }
        cfg_new = ao2_find(cfgs->agents, agent->username, OBJ_KEY);
        ao2_ref(cfgs, -1);
        if (!cfg_new) {
            /* The agent is no longer configured. */
            break;
        }
        agent_lock(agent);
        cfg_old = agent->cfg;
        agent->cfg = cfg_new;
 
        agent->last_disconnect = ast_tvnow();
 
        /* Clear out any caller bridge before rejoining the holding bridge. */
        caller_bridge = agent->caller_bridge;
        agent->caller_bridge = NULL;
        agent_unlock(agent);
        ao2_ref(cfg_old, -1);
        if (caller_bridge) {
            ast_bridge_destroy(caller_bridge, 0);
        }
 
        if (agent->state == AGENT_STATE_LOGGING_OUT
            || agent->deferred_logoff
            || ast_check_hangup_locked(logged)) {
            /* The agent was requested to logout or hungup. */
            break;
        }
 
        /*
         * It is safe to access agent->waiting_colp without a lock.  It
         * is only setup on agent login and not changed.
         */
        ast_channel_update_connected_line(logged, &agent->waiting_colp, NULL);
    }
    ast_bridge_features_cleanup(&features);
 
agent_run_cleanup:
    agent_lock(agent);
    if (logged != agent->logged) {
        /*
         * We are no longer the agent channel because of local channel
         * optimization.
         */
        agent_unlock(agent);
        ast_debug(1, "Agent %s: Channel %s is no longer the agent.\n",
            agent->username, ast_channel_name(logged));
        return;
    }
    agent_logout(agent);
}

References agent_lock, agent_logout(), AGENT_STATE_LOGGING_OUT, agent_unlock, agents_cfg::agents, ao2_find, ao2_global_obj_ref, ao2_ref, ast_bridge_destroy(), ast_bridge_features_cleanup(), ast_bridge_features_init(), ast_bridge_join(), AST_BRIDGE_JOIN_PASS_REFERENCE, AST_CAUSE_NORMAL_CLEARING, ast_channel_hangupcause_set(), ast_channel_name(), ast_channel_update_connected_line(), ast_check_hangup_locked(), ast_debug, ast_tvnow(), agent_pvt::caller_bridge, agent_pvt::cfg, cfg_handle, agent_pvt::dead, agent_pvt::deferred_logoff, agent_pvt::last_disconnect, agent_pvt::logged, NULL, OBJ_KEY, agent_pvt::state, agent_pvt::username, and agent_pvt::waiting_colp.

Referenced by agent_after_bridge_cb(), and agent_login_exec().

agent_show_requested()

static void agent_show_requested ( struct ast_cli_args *  a, int  online_only  )

static

Definition at line 2350 of file app_agent_pool.c.

{
#define FORMAT_HDR "%-8s %-20s %-11s %-30s %s\n"
#define FORMAT_ROW "%-8s %-20s %-11s %-30s %s\n"
 
    struct ao2_iterator iter;
    struct agent_pvt *agent;
    struct ast_str *out = ast_str_alloca(512);
    unsigned int agents_total = 0;
    unsigned int agents_logged_in = 0;
    unsigned int agents_talking = 0;
 
    ast_cli(a->fd, FORMAT_HDR, "Agent-ID", "Name", "State", "Channel", "Talking with");
    iter = ao2_iterator_init(agents, 0);
    for (; (agent = ao2_iterator_next(&iter)); ao2_ref(agent, -1)) {
        struct ast_channel *logged;
 
        ++agents_total;
 
        agent_lock(agent);
        logged = agent_lock_logged(agent);
        if (logged) {
            const char *talking_with;
 
            ++agents_logged_in;
 
            talking_with = pbx_builtin_getvar_helper(logged, "BRIDGEPEER");
            if (!ast_strlen_zero(talking_with)) {
                ++agents_talking;
            } else {
                talking_with = "";
            }
            ast_str_set(&out, 0, FORMAT_ROW, agent->username, agent->cfg->full_name,
                ast_devstate_str(agent->devstate), ast_channel_name(logged), talking_with);
            ast_channel_unlock(logged);
            ast_channel_unref(logged);
        } else {
            ast_str_set(&out, 0, FORMAT_ROW, agent->username, agent->cfg->full_name,
                ast_devstate_str(agent->devstate), "", "");
        }
        agent_unlock(agent);
 
        if (!online_only || logged) {
            ast_cli(a->fd, "%s", ast_str_buffer(out));
        }
    }
    ao2_iterator_destroy(&iter);
 
    ast_cli(a->fd, "\nDefined agents: %u, Logged in: %u, Talking: %u\n",
        agents_total, agents_logged_in, agents_talking);
 
#undef FORMAT_HDR
#undef FORMAT_ROW
}

References a, agent_lock, agent_lock_logged(), agent_unlock, agents, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_cli(), ast_devstate_str(), ast_str_alloca, ast_str_buffer(), ast_str_set(), ast_strlen_zero(), agent_pvt::cfg, agent_pvt::devstate, FORMAT_HDR, FORMAT_ROW, agent_cfg::full_name, out, pbx_builtin_getvar_helper(), and agent_pvt::username.

Referenced by agent_handle_show_all(), and agent_handle_show_online().

agent_sweep()

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

static

Definition at line 926 of file app_agent_pool.c.

{
    struct agent_pvt *agent = obj;
    int cmp = 0;
 
    agent_lock(agent);
    if (agent->the_mark) {
        agent->the_mark = 0;
        agent->dead = 1;
        /* Unlink dead agents immediately. */
        cmp = CMP_MATCH;
    }
    agent_unlock(agent);
    return cmp;
}

References agent_lock, agent_unlock, CMP_MATCH, agent_pvt::dead, and agent_pvt::the_mark.

Referenced by agents_sweep().

agents_cfg_alloc()

static void * agents_cfg_alloc ( void  )

static

Definition at line 557 of file app_agent_pool.c.

{
    struct agents_cfg *cfg;
 
    cfg = ao2_alloc_options(sizeof(*cfg), agents_cfg_destructor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!cfg) {
        return NULL;
    }
    cfg->agents = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_NOLOCK,
        AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, agent_cfg_sort_cmp, NULL);
    if (!cfg->agents) {
        ao2_ref(cfg, -1);
        cfg = NULL;
    }
    return cfg;
}

References agent_cfg_sort_cmp(), agents_cfg::agents, agents_cfg_destructor(), AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, ao2_container_alloc_rbtree, ao2_ref, and NULL.

agents_cfg_destructor()

static void agents_cfg_destructor ( void *  vdoomed )

static

Definition at line 537 of file app_agent_pool.c.

{
    struct agents_cfg *doomed = vdoomed;
 
    ao2_cleanup(doomed->agents);
    doomed->agents = NULL;
}

References agents_cfg::agents, ao2_cleanup, and NULL.

Referenced by agents_cfg_alloc().

agents_mark()

static void agents_mark ( void  )

static

Definition at line 921 of file app_agent_pool.c.

{
    ao2_callback(agents, 0, agent_mark, NULL);
}

References agent_mark(), agents, ao2_callback, and NULL.

Referenced by agents_post_apply_config().

agents_post_apply_config()

static void agents_post_apply_config ( void  )

static

Definition at line 972 of file app_agent_pool.c.

{
    struct ao2_iterator iter;
    struct agent_cfg *cfg;
    RAII_VAR(struct agents_cfg *, cfgs, ao2_global_obj_ref(cfg_handle), ao2_cleanup);
 
    ast_assert(cfgs != NULL);
 
    agents_mark();
    iter = ao2_iterator_init(cfgs->agents, 0);
    for (; (cfg = ao2_iterator_next(&iter)); ao2_ref(cfg, -1)) {
        RAII_VAR(struct agent_pvt *, agent, ao2_find(agents, cfg->username, OBJ_KEY), ao2_cleanup);
 
        if (agent) {
            agent_lock(agent);
            agent->the_mark = 0;
            if (!agent->logged) {
                struct agent_cfg *cfg_old;
 
                /* Replace the config of agents not logged in. */
                cfg_old = agent->cfg;
                ao2_ref(cfg, +1);
                agent->cfg = cfg;
                ao2_cleanup(cfg_old);
            }
            agent_unlock(agent);
            continue;
        }
        agent = agent_pvt_new(cfg);
        if (!agent) {
            continue;
        }
        ao2_link(agents, agent);
        ast_debug(1, "Agent %s: Created.\n", agent->username);
        agent_devstate_changed(agent->username);
    }
    ao2_iterator_destroy(&iter);
    agents_sweep();
}

References agent_devstate_changed(), agent_lock, agent_pvt_new(), agent_unlock, agents, agents_mark(), agents_sweep(), ao2_cleanup, ao2_find, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_link, ao2_ref, ast_assert, ast_debug, cfg_handle, NULL, OBJ_KEY, RAII_VAR, and agent_cfg::username.

agents_sweep()

static void agents_sweep ( void  )

static

Definition at line 942 of file app_agent_pool.c.

{
    struct ao2_iterator *iter;
    struct agent_pvt *agent;
    struct ast_channel *logged;
 
    iter = ao2_callback(agents, OBJ_MULTIPLE | OBJ_UNLINK, agent_sweep, NULL);
    if (!iter) {
        return;
    }
    for (; (agent = ao2_iterator_next(iter)); ao2_ref(agent, -1)) {
        agent_lock(agent);
        if (agent->logged) {
            logged = ast_channel_ref(agent->logged);
        } else {
            logged = NULL;
        }
        agent_unlock(agent);
        if (!logged) {
            continue;
        }
        ast_log(LOG_NOTICE,
            "Forced logoff of agent %s(%s).  Agent no longer configured.\n",
            agent->username, ast_channel_name(logged));
        ast_softhangup(logged, AST_SOFTHANGUP_EXPLICIT);
        ast_channel_unref(logged);
    }
    ao2_iterator_destroy(iter);
}

References agent_lock, agent_sweep(), agent_unlock, agents, ao2_callback, ao2_iterator_destroy(), ao2_iterator_next, ao2_ref, ast_channel_name(), ast_channel_ref, ast_channel_unref, ast_log, ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, LOG_NOTICE, agent_pvt::logged, NULL, OBJ_MULTIPLE, OBJ_UNLINK, and agent_pvt::username.

Referenced by agents_post_apply_config().

AO2_GLOBAL_OBJ_STATIC() [1/2]

static AO2_GLOBAL_OBJ_STATIC ( agent_holding  )

static

Agent holding bridge instance holder.

AO2_GLOBAL_OBJ_STATIC() [2/2]

static AO2_GLOBAL_OBJ_STATIC ( cfg_handle  )

static

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 2739 of file app_agent_pool.c.

bridge_agent_hold_ack()

static int bridge_agent_hold_ack ( struct ast_bridge_channel *  bridge_channel, void *  hook_pvt  )

static

Definition at line 1118 of file app_agent_pool.c.

{
    struct agent_pvt *agent = hook_pvt;
 
    agent_lock(agent);
    switch (agent->state) {
    case AGENT_STATE_CALL_WAIT_ACK:
        /* Connect to caller now. */
        ast_debug(1, "Agent %s: Acked call.\n", agent->username);
        agent_connect_caller(bridge_channel, agent);/* Will unlock agent. */
        return 0;
    default:
        break;
    }
    agent_unlock(agent);
    return 0;
}

References agent_connect_caller(), agent_lock, AGENT_STATE_CALL_WAIT_ACK, agent_unlock, ast_debug, agent_pvt::state, and agent_pvt::username.

Referenced by bridge_agent_hold_push().

bridge_agent_hold_deferred_create()

static int bridge_agent_hold_deferred_create ( void  )

static

Definition at line 1448 of file app_agent_pool.c.

{
    RAII_VAR(struct ast_bridge *, holding, ao2_global_obj_ref(agent_holding), ao2_cleanup);
 
    if (!holding) {
        ast_mutex_lock(&agent_holding_lock);
        holding = ao2_global_obj_ref(agent_holding);
        if (!holding) {
            holding = bridge_agent_hold_new();
            ao2_global_obj_replace_unref(agent_holding, holding);
        }
        ast_mutex_unlock(&agent_holding_lock);
        if (!holding) {
            ast_log(LOG_ERROR, "Could not create agent holding bridge.\n");
            return -1;
        }
    }
    return 0;
}

References agent_holding_lock, ao2_cleanup, ao2_global_obj_ref, ao2_global_obj_replace_unref, ast_log, ast_mutex_lock, ast_mutex_unlock, bridge_agent_hold_new(), LOG_ERROR, and RAII_VAR.

Referenced by agent_login_exec(), and agent_request_exec().

bridge_agent_hold_dissolving()

static void bridge_agent_hold_dissolving ( struct ast_bridge *  self )

static

The bridge is being dissolved.

Parameters

self	Bridge to operate upon.

The bridge is being dissolved. Remove any external references to the bridge so it can be destroyed.

Note

On entry, self must NOT be locked.

Definition at line 1417 of file app_agent_pool.c.

{
    ao2_global_obj_release(agent_holding);
    ast_bridge_base_v_table.dissolving(self);
}

References ao2_global_obj_release, ast_bridge_base_v_table, and ast_bridge_methods::dissolving.

Referenced by bridge_init_agent_hold().

bridge_agent_hold_heartbeat()

static int bridge_agent_hold_heartbeat ( struct ast_bridge_channel *  bridge_channel, void *  hook_pvt  )

static

Definition at line 1136 of file app_agent_pool.c.

{
    struct agent_pvt *agent = hook_pvt;
    int probation_timedout = 0;
    int ack_timedout = 0;
    int wrapup_timedout = 0;
    int deferred_logoff;
    unsigned int wrapup_time;
    unsigned int auto_logoff;
 
    agent_lock(agent);
    deferred_logoff = agent->deferred_logoff;
    if (deferred_logoff) {
        agent->state = AGENT_STATE_LOGGING_OUT;
    }
 
    switch (agent->state) {
    case AGENT_STATE_PROBATION_WAIT:
        probation_timedout =
            LOGIN_WAIT_TIMEOUT_TIME <= (time(NULL) - agent->probation_start);
        if (probation_timedout) {
            /* Now ready for a caller. */
            agent->state = AGENT_STATE_READY_FOR_CALL;
            agent->devstate = AST_DEVICE_NOT_INUSE;
        }
        break;
    case AGENT_STATE_CALL_WAIT_ACK:
        /* Check ack call time. */
        auto_logoff = agent->cfg->auto_logoff;
        if (ast_test_flag(agent, AGENT_FLAG_AUTO_LOGOFF)) {
            auto_logoff = agent->override_auto_logoff;
        }
        if (auto_logoff) {
            auto_logoff *= 1000;
            ack_timedout = ast_tvdiff_ms(ast_tvnow(), agent->ack_time) > auto_logoff;
            if (ack_timedout) {
                agent->state = AGENT_STATE_LOGGING_OUT;
            }
        }
        break;
    case AGENT_STATE_CALL_WRAPUP:
        /* Check wrapup time. */
        wrapup_time = agent->cfg->wrapup_time;
        if (ast_test_flag(agent, AGENT_FLAG_WRAPUP_TIME)) {
            wrapup_time = agent->override_wrapup_time;
        }
        wrapup_timedout = ast_tvdiff_ms(ast_tvnow(), agent->last_disconnect) > wrapup_time;
        if (wrapup_timedout) {
            agent->state = AGENT_STATE_READY_FOR_CALL;
            agent->devstate = AST_DEVICE_NOT_INUSE;
        }
        break;
    default:
        break;
    }
    agent_unlock(agent);
 
    if (deferred_logoff) {
        ast_debug(1, "Agent %s: Deferred logoff.\n", agent->username);
        ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END,
            AST_CAUSE_NORMAL_CLEARING);
    } else if (probation_timedout) {
        ast_debug(1, "Agent %s: Login complete.\n", agent->username);
        agent_devstate_changed(agent->username);
    } else if (ack_timedout) {
        ast_debug(1, "Agent %s: Ack call timeout.\n", agent->username);
        ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END,
            AST_CAUSE_NORMAL_CLEARING);
    } else if (wrapup_timedout) {
        ast_debug(1, "Agent %s: Wrapup timeout. Ready for new call.\n", agent->username);
        agent_devstate_changed(agent->username);
    }
 
    return 0;
}

References agent_pvt::ack_time, agent_devstate_changed(), AGENT_FLAG_AUTO_LOGOFF, AGENT_FLAG_WRAPUP_TIME, agent_lock, AGENT_STATE_CALL_WAIT_ACK, AGENT_STATE_CALL_WRAPUP, AGENT_STATE_LOGGING_OUT, AGENT_STATE_PROBATION_WAIT, AGENT_STATE_READY_FOR_CALL, agent_unlock, ast_bridge_channel_leave_bridge(), AST_CAUSE_NORMAL_CLEARING, ast_debug, AST_DEVICE_NOT_INUSE, ast_test_flag, ast_tvdiff_ms(), ast_tvnow(), agent_cfg::auto_logoff, BRIDGE_CHANNEL_STATE_END, agent_pvt::cfg, agent_pvt::deferred_logoff, agent_pvt::devstate, agent_pvt::last_disconnect, LOGIN_WAIT_TIMEOUT_TIME, NULL, agent_pvt::override_auto_logoff, agent_pvt::override_wrapup_time, agent_pvt::probation_start, agent_pvt::state, agent_pvt::username, and agent_cfg::wrapup_time.

Referenced by bridge_agent_hold_push().

bridge_agent_hold_new()

static struct ast_bridge * bridge_agent_hold_new ( void  )

static

Definition at line 1425 of file app_agent_pool.c.

{
    struct ast_bridge *bridge;
 
    bridge = bridge_alloc(sizeof(struct ast_bridge), &bridge_agent_hold_v_table);
    bridge = bridge_base_init(bridge, AST_BRIDGE_CAPABILITY_HOLDING,
        AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM
            | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_PROHIBITED,
        "AgentPool", NULL, NULL);
    bridge = bridge_register(bridge);
    return bridge;
}

References AST_BRIDGE_CAPABILITY_HOLDING, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM, AST_BRIDGE_FLAG_TRANSFER_PROHIBITED, bridge_agent_hold_v_table, bridge_alloc(), bridge_base_init(), bridge_register(), and NULL.

Referenced by bridge_agent_hold_deferred_create().

bridge_agent_hold_pull()

static void bridge_agent_hold_pull ( struct ast_bridge *  self, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 1400 of file app_agent_pool.c.

{
    ast_channel_remove_bridge_role(bridge_channel->chan, "holding_participant");
    ast_bridge_base_v_table.pull(self, bridge_channel);
}

References ast_bridge_base_v_table, ast_channel_remove_bridge_role(), ast_channel::bridge_channel, ast_bridge_channel::chan, and ast_bridge_methods::pull.

Referenced by bridge_init_agent_hold().

bridge_agent_hold_push()

static int bridge_agent_hold_push ( struct ast_bridge *  self, struct ast_bridge_channel *  bridge_channel, struct ast_bridge_channel *  swap  )

static

Todo:

XXX the login probation time should be only if it is needed.

Need to determine if there are any local channels that can optimize and wait until they actually do before leaving the AGENT_STATE_PROBATION_WAIT state. For now, the blind timer of LOGIN_WAIT_TIMEOUT_TIME will do.

Definition at line 1229 of file app_agent_pool.c.

{
    int res = 0;
    unsigned int wrapup_time;
    char dtmf[AST_FEATURE_MAX_LEN];
    struct ast_channel *chan;
    const char *moh_class;
    RAII_VAR(struct agent_pvt *, agent, NULL, ao2_cleanup);
 
    chan = bridge_channel->chan;
 
    agent = ao2_find(agents, swap ? swap->chan : chan, 0);
    if (!agent) {
        /* Could not find the agent. */
        return -1;
    }
 
    /* Setup agent entertainment */
    agent_lock(agent);
    moh_class = ast_strdupa(agent->cfg->moh);
    agent_unlock(agent);
    res |= ast_channel_add_bridge_role(chan, "holding_participant");
    res |= ast_channel_set_bridge_role_option(chan, "holding_participant", "idle_mode", "musiconhold");
    res |= ast_channel_set_bridge_role_option(chan, "holding_participant", "moh_class", moh_class);
 
    /* Add DTMF acknowledge hook. */
    dtmf[0] = '\0';
    agent_lock(agent);
    if (ast_test_flag(agent, AGENT_FLAG_ACK_CALL)
        ? agent->override_ack_call : agent->cfg->ack_call) {
        const char *dtmf_accept;
 
        dtmf_accept = ast_test_flag(agent, AGENT_FLAG_DTMF_ACCEPT)
            ? agent->override_dtmf_accept : agent->cfg->dtmf_accept;
        ast_copy_string(dtmf, dtmf_accept, sizeof(dtmf));
    }
    agent_unlock(agent);
    if (!ast_strlen_zero(dtmf)) {
        ao2_ref(agent, +1);
        if (ast_bridge_dtmf_hook(bridge_channel->features, dtmf, bridge_agent_hold_ack,
            agent, __ao2_cleanup, AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
            ao2_ref(agent, -1);
            res = -1;
        }
    }
 
    /* Add heartbeat interval hook. */
    ao2_ref(agent, +1);
    if (ast_bridge_interval_hook(bridge_channel->features, 0, 1000,
        bridge_agent_hold_heartbeat, agent, __ao2_cleanup, AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
        ao2_ref(agent, -1);
        res = -1;
    }
 
    res |= ast_bridge_base_v_table.push(self, bridge_channel, swap);
    if (res) {
        ast_channel_remove_bridge_role(chan, "holding_participant");
        return -1;
    }
 
    if (swap) {
        res = ast_bridge_set_after_callback(chan, agent_after_bridge_cb,
            agent_after_bridge_cb_failed, chan);
        if (res) {
            ast_channel_remove_bridge_role(chan, "holding_participant");
            return -1;
        }
 
        agent_lock(agent);
        ast_channel_unref(agent->logged);
        agent->logged = ast_channel_ref(chan);
        agent_unlock(agent);
 
        /*
         * Kick the channel out so it can come back in fully controlled.
         * Otherwise, the after bridge callback will linger and the
         * agent will have some slightly different behavior in corner
         * cases.
         */
        ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END,
            AST_CAUSE_NORMAL_CLEARING);
        return 0;
    }
 
    agent_lock(agent);
    switch (agent->state) {
    case AGENT_STATE_LOGGED_OUT:
        /*!
         * \todo XXX the login probation time should be only if it is needed.
         *
         * Need to determine if there are any local channels that can
         * optimize and wait until they actually do before leaving the
         * AGENT_STATE_PROBATION_WAIT state.  For now, the blind
         * timer of LOGIN_WAIT_TIMEOUT_TIME will do.
         */
        /*
         * Start the login probation timer.
         *
         * We cannot handle an agent local channel optimization when the
         * agent is on a call.  The optimization may kick the agent
         * channel we know about out of the call without our being able
         * to switch to the replacement channel.  Get any agent local
         * channel optimization out of the way while the agent is in the
         * holding bridge.
         */
        time(&agent->probation_start);
        agent->state = AGENT_STATE_PROBATION_WAIT;
        agent_unlock(agent);
        break;
    case AGENT_STATE_PROBATION_WAIT:
        /* Restart the probation timer. */
        time(&agent->probation_start);
        agent_unlock(agent);
        break;
    case AGENT_STATE_READY_FOR_CALL:
        /*
         * Likely someone manually kicked us out of the holding bridge
         * and we came right back in.
         */
        agent_unlock(agent);
        break;
    default:
        /* Unexpected agent state. */
        ast_assert(0);
        /* Fall through */
    case AGENT_STATE_CALL_PRESENT:
    case AGENT_STATE_CALL_WAIT_ACK:
        agent->state = AGENT_STATE_READY_FOR_CALL;
        agent->devstate = AST_DEVICE_NOT_INUSE;
        agent_unlock(agent);
        ast_debug(1, "Agent %s: Call abort recovery complete.\n", agent->username);
        agent_devstate_changed(agent->username);
        break;
    case AGENT_STATE_ON_CALL:
    case AGENT_STATE_CALL_WRAPUP:
        wrapup_time = agent->cfg->wrapup_time;
        if (ast_test_flag(agent, AGENT_FLAG_WRAPUP_TIME)) {
            wrapup_time = agent->override_wrapup_time;
        }
        if (wrapup_time) {
            agent->state = AGENT_STATE_CALL_WRAPUP;
        } else {
            agent->state = AGENT_STATE_READY_FOR_CALL;
            agent->devstate = AST_DEVICE_NOT_INUSE;
        }
        agent_unlock(agent);
        if (!wrapup_time) {
            /* No wrapup time. */
            ast_debug(1, "Agent %s: Ready for new call.\n", agent->username);
            agent_devstate_changed(agent->username);
        }
        break;
    }
 
    return 0;
}

References __ao2_cleanup(), agent_after_bridge_cb(), agent_after_bridge_cb_failed(), agent_devstate_changed(), AGENT_FLAG_ACK_CALL, AGENT_FLAG_DTMF_ACCEPT, AGENT_FLAG_WRAPUP_TIME, agent_lock, AGENT_STATE_CALL_PRESENT, AGENT_STATE_CALL_WAIT_ACK, AGENT_STATE_CALL_WRAPUP, AGENT_STATE_LOGGED_OUT, AGENT_STATE_ON_CALL, AGENT_STATE_PROBATION_WAIT, AGENT_STATE_READY_FOR_CALL, agent_unlock, agents, ao2_cleanup, ao2_find, ao2_ref, ast_assert, ast_bridge_base_v_table, ast_bridge_channel_leave_bridge(), ast_bridge_dtmf_hook(), AST_BRIDGE_HOOK_REMOVE_ON_PULL, ast_bridge_interval_hook(), ast_bridge_set_after_callback(), AST_CAUSE_NORMAL_CLEARING, ast_channel_add_bridge_role(), ast_channel_ref, ast_channel_remove_bridge_role(), ast_channel_set_bridge_role_option(), ast_channel_unref, ast_copy_string(), ast_debug, AST_DEVICE_NOT_INUSE, AST_FEATURE_MAX_LEN, ast_strdupa, ast_strlen_zero(), ast_test_flag, bridge_agent_hold_ack(), bridge_agent_hold_heartbeat(), ast_channel::bridge_channel, BRIDGE_CHANNEL_STATE_END, ast_bridge_channel::chan, ast_bridge_channel::features, NULL, ast_bridge_methods::push, and RAII_VAR.

Referenced by bridge_init_agent_hold().

bridge_init_agent_hold()

static void bridge_init_agent_hold ( void  )

static

Definition at line 1438 of file app_agent_pool.c.

{
    /* Setup bridge agent_hold subclass v_table. */
    bridge_agent_hold_v_table = ast_bridge_base_v_table;
    bridge_agent_hold_v_table.name = "agent_hold";
    bridge_agent_hold_v_table.dissolving = bridge_agent_hold_dissolving;
    bridge_agent_hold_v_table.push = bridge_agent_hold_push;
    bridge_agent_hold_v_table.pull = bridge_agent_hold_pull;
}

References ast_bridge_base_v_table, bridge_agent_hold_dissolving(), bridge_agent_hold_pull(), bridge_agent_hold_push(), bridge_agent_hold_v_table, ast_bridge_methods::dissolving, ast_bridge_methods::name, ast_bridge_methods::pull, and ast_bridge_methods::push.

Referenced by load_module().

caller_abort_agent()

static void caller_abort_agent ( struct agent_pvt *  agent )

static

Definition at line 1721 of file app_agent_pool.c.

{
    struct ast_bridge_channel *logged;
 
    logged = agent_bridge_channel_get_lock(agent);
    if (!logged) {
        struct ast_bridge *caller_bridge;
 
        ast_debug(1, "Agent '%s' no longer logged in.\n", agent->username);
 
        agent_lock(agent);
        caller_bridge = agent->caller_bridge;
        agent->caller_bridge = NULL;
        agent_unlock(agent);
        if (caller_bridge) {
            ast_bridge_destroy(caller_bridge, 0);
        }
        return;
    }
 
    /* Kick the agent out of the holding bridge to reset it. */
    ast_bridge_channel_leave_bridge_nolock(logged, BRIDGE_CHANNEL_STATE_END,
        AST_CAUSE_NORMAL_CLEARING);
    ast_bridge_channel_unlock(logged);
}

References agent_bridge_channel_get_lock(), agent_lock, agent_unlock, ast_bridge_channel_leave_bridge_nolock(), ast_bridge_channel_unlock, ast_bridge_destroy(), AST_CAUSE_NORMAL_CLEARING, ast_debug, BRIDGE_CHANNEL_STATE_END, agent_pvt::caller_bridge, NULL, and agent_pvt::username.

Referenced by agent_request_exec(), caller_joined_bridge(), and caller_safety_timeout().

caller_joined_bridge()

static int caller_joined_bridge ( struct ast_bridge_channel *  bridge_channel, void *  hook_pvt  )

static

Definition at line 1872 of file app_agent_pool.c.

{
    struct agent_pvt *agent = hook_pvt;
    struct ast_bridge_channel *logged;
    int res;
 
    logged = agent_bridge_channel_get_lock(agent);
    if (!logged) {
        ast_verb(3, "Agent '%s' not logged in.\n", agent->username);
        pbx_builtin_setvar_helper(bridge_channel->chan, "AGENT_STATUS", "NOT_LOGGED_IN");
 
        ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, 0);
        caller_abort_agent(agent);
        return -1;
    }
 
    res = send_alert_to_agent(logged, agent->username);
    ast_bridge_channel_unlock(logged);
    ao2_ref(logged, -1);
    if (res) {
        ast_verb(3, "Agent '%s': Failed to alert the agent.\n", agent->username);
        pbx_builtin_setvar_helper(bridge_channel->chan, "AGENT_STATUS", "ERROR");
 
        ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, 0);
        caller_abort_agent(agent);
        return -1;
    }
 
    pbx_builtin_setvar_helper(bridge_channel->chan, "AGENT_STATUS", "NOT_CONNECTED");
    ast_indicate(bridge_channel->chan, AST_CONTROL_RINGING);
    return -1;
}

References agent_bridge_channel_get_lock(), ao2_ref, ast_bridge_channel_leave_bridge(), ast_bridge_channel_unlock, AST_CONTROL_RINGING, ast_indicate(), ast_verb, BRIDGE_CHANNEL_STATE_END, caller_abort_agent(), ast_bridge_channel::chan, pbx_builtin_setvar_helper(), send_alert_to_agent(), and agent_pvt::username.

Referenced by agent_request_exec().

caller_safety_timeout()

static int caller_safety_timeout ( struct ast_bridge_channel *  bridge_channel, void *  hook_pvt  )

static

Definition at line 1747 of file app_agent_pool.c.

{
    struct agent_pvt *agent = hook_pvt;
 
    if (agent->state == AGENT_STATE_CALL_PRESENT) {
        ast_log(LOG_WARNING, "Agent '%s' process did not respond.  Safety timeout.\n",
            agent->username);
        pbx_builtin_setvar_helper(bridge_channel->chan, "AGENT_STATUS", "ERROR");
 
        ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, 0);
        caller_abort_agent(agent);
    }
 
    return -1;
}

References AGENT_STATE_CALL_PRESENT, ast_bridge_channel_leave_bridge(), ast_log, BRIDGE_CHANNEL_STATE_END, caller_abort_agent(), ast_bridge_channel::chan, LOG_WARNING, pbx_builtin_setvar_helper(), agent_pvt::state, and agent_pvt::username.

Referenced by agent_request_exec().

clear_agent_status()

static void clear_agent_status ( struct ast_bridge_channel *  bridge_channel, const void *  payload, size_t  payload_size  )

static

Definition at line 1052 of file app_agent_pool.c.

{
    pbx_builtin_setvar_helper(bridge_channel->chan, "AGENT_STATUS", NULL);
}

References ast_channel::bridge_channel, ast_bridge_channel::chan, NULL, and pbx_builtin_setvar_helper().

Referenced by agent_connect_caller().

complete_agent()

static char * complete_agent ( const char *  word, int  state  )

static

Definition at line 2300 of file app_agent_pool.c.

{
    char *ret;
    struct agent_pvt *agent;
    struct agent_complete search = {
        .state = state,
    };
 
    agent = ao2_callback_data(agents, ast_strlen_zero(word) ? 0 : OBJ_PARTIAL_KEY,
        complete_agent_search, (char *) word, &search);
    if (!agent) {
        return NULL;
    }
    ret = ast_strdup(agent->username);
    ao2_ref(agent, -1);
    return ret;
}

References agents, ao2_callback_data, ao2_ref, ast_strdup, ast_strlen_zero(), complete_agent_search(), NULL, OBJ_PARTIAL_KEY, agent_complete::state, and agent_pvt::username.

Referenced by agent_handle_show_specific().

complete_agent_logoff()

static char * complete_agent_logoff ( const char *  word, int  state  )

static

Definition at line 2332 of file app_agent_pool.c.

{
    char *ret;
    struct agent_pvt *agent;
    struct agent_complete search = {
        .state = state,
    };
 
    agent = ao2_callback_data(agents, ast_strlen_zero(word) ? 0 : OBJ_PARTIAL_KEY,
        complete_agent_logoff_search, (char *) word, &search);
    if (!agent) {
        return NULL;
    }
    ret = ast_strdup(agent->username);
    ao2_ref(agent, -1);
    return ret;
}

References agents, ao2_callback_data, ao2_ref, ast_strdup, ast_strlen_zero(), complete_agent_logoff_search(), NULL, OBJ_PARTIAL_KEY, agent_complete::state, and agent_pvt::username.

Referenced by agent_handle_logoff_cmd().

complete_agent_logoff_search()

static int complete_agent_logoff_search ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 2318 of file app_agent_pool.c.

{
    struct agent_pvt *agent = obj;
    struct agent_complete *search = data;
 
    if (!agent->logged) {
        return 0;
    }
    if (++search->which > search->state) {
        return CMP_MATCH;
    }
    return 0;
}

References CMP_MATCH, agent_pvt::logged, agent_complete::state, and agent_complete::which.

Referenced by complete_agent_logoff().

complete_agent_search()

static int complete_agent_search ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 2290 of file app_agent_pool.c.

{
    struct agent_complete *search = data;
 
    if (++search->which > search->state) {
        return CMP_MATCH;
    }
    return 0;
}

References CMP_MATCH, agent_complete::state, and agent_complete::which.

Referenced by complete_agent().

CONFIG_INFO_STANDARD()

CONFIG_INFO_STANDARD	(	cfg_info	,
		cfg_handle	,
		agents_cfg_alloc	,
		.	files = ACO_FILES(&agents_conf),
		.	post_apply_config = agents_post_apply_config
	)

destroy_config()

static void destroy_config ( void  )

static

Definition at line 582 of file app_agent_pool.c.

{
    ao2_global_obj_release(cfg_handle);
    aco_info_destroy(&cfg_info);
}

References aco_info_destroy(), ao2_global_obj_release, and cfg_handle.

Referenced by unload_module().

load_config()

static int load_config ( void  )

static

Definition at line 588 of file app_agent_pool.c.

{
    if (aco_info_init(&cfg_info)) {
        return -1;
    }
 
    /* Agent options */
    aco_option_register(&cfg_info, "ackcall", ACO_EXACT, agent_types, "no", OPT_BOOL_T, 1, FLDSET(struct agent_cfg, ack_call));
    aco_option_register(&cfg_info, "acceptdtmf", ACO_EXACT, agent_types, "#", OPT_STRINGFIELD_T, 1, STRFLDSET(struct agent_cfg, dtmf_accept));
    aco_option_register(&cfg_info, "autologoff", ACO_EXACT, agent_types, "0", OPT_UINT_T, 0, FLDSET(struct agent_cfg, auto_logoff));
    aco_option_register(&cfg_info, "wrapuptime", ACO_EXACT, agent_types, "0", OPT_UINT_T, 0, FLDSET(struct agent_cfg, wrapup_time));
    aco_option_register(&cfg_info, "musiconhold", ACO_EXACT, agent_types, "default", OPT_STRINGFIELD_T, 0, STRFLDSET(struct agent_cfg, moh));
    aco_option_register(&cfg_info, "recordagentcalls", ACO_EXACT, agent_types, "no", OPT_BOOL_T, 1, FLDSET(struct agent_cfg, record_agent_calls));
    aco_option_register(&cfg_info, "custom_beep", ACO_EXACT, agent_types, "beep", OPT_STRINGFIELD_T, 0, STRFLDSET(struct agent_cfg, beep_sound));
    aco_option_register(&cfg_info, "fullname", ACO_EXACT, agent_types, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct agent_cfg, full_name));
 
    if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
        return -1;
    }
 
    return 0;
}

References ACO_EXACT, aco_info_init(), aco_option_register, aco_process_config(), ACO_PROCESS_ERROR, agent_types, FLDSET, NULL, OPT_BOOL_T, OPT_STRINGFIELD_T, OPT_UINT_T, and STRFLDSET.

Referenced by __reload(), handle_voicemail_reload(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload(), reload_module(), and reload_module().

load_module()

static int load_module ( void  )

static

Definition at line 2679 of file app_agent_pool.c.

{
    int res = 0;
 
    agents = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_MUTEX,
        AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, agent_pvt_sort_cmp, agent_pvt_cmp);
    if (!agents) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    /* Init agent holding bridge v_table. */
    bridge_init_agent_hold();
 
    /* Setup to provide Agent:agent-id device state. */
    res |= ast_devstate_prov_add("Agent", agent_pvt_devstate_get);
 
    /* CLI Commands */
    res |= ast_cli_register_multiple(cli_agents, ARRAY_LEN(cli_agents));
 
    /* Manager commands */
    res |= ast_manager_register_xml("Agents", EVENT_FLAG_AGENT, action_agents);
    res |= ast_manager_register_xml("AgentLogoff", EVENT_FLAG_AGENT, action_agent_logoff);
 
    /* Dialplan Functions */
    res |= ast_custom_function_register(&agent_function);
 
    /* Dialplan applications */
    res |= ast_register_application_xml(app_agent_login, agent_login_exec);
    res |= ast_register_application_xml(app_agent_request, agent_request_exec);
 
    if (res) {
        ast_log(LOG_ERROR, "Unable to register application. Not loading module.\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (load_config()) {
        ast_log(LOG_ERROR, "Unable to load config. Not loading module.\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
}

References action_agent_logoff(), action_agents(), agent_function, agent_login_exec(), agent_pvt_cmp(), agent_pvt_devstate_get(), agent_pvt_sort_cmp(), agent_request_exec(), agents, AO2_ALLOC_OPT_LOCK_MUTEX, AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, ao2_container_alloc_rbtree, app_agent_login, app_agent_request, ARRAY_LEN, ast_cli_register_multiple, ast_custom_function_register, ast_devstate_prov_add(), ast_log, ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_register_application_xml, bridge_init_agent_hold(), cli_agents, EVENT_FLAG_AGENT, load_config(), LOG_ERROR, and unload_module().

reload()

static int reload ( void  )

static

Definition at line 2724 of file app_agent_pool.c.

{
    if (aco_process_config(&cfg_info, 1) == ACO_PROCESS_ERROR) {
        /* Just keep the config we already have in place. */
        return -1;
    }
    return 0;
}

References aco_process_config(), and ACO_PROCESS_ERROR.

send_agent_login()

static void send_agent_login ( struct ast_channel *  chan, const char *  agent  )

static

Definition at line 1468 of file app_agent_pool.c.

{
    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
    ast_assert(agent != NULL);
 
    blob = ast_json_pack("{s: s}",
        "agent", agent);
    if (!blob) {
        return;
    }
 
    ast_channel_publish_blob(chan, ast_channel_agent_login_type(), blob);
}

References ast_assert, ast_channel_agent_login_type(), ast_channel_publish_blob(), ast_json_pack(), ast_json_unref(), NULL, and RAII_VAR.

Referenced by agent_login_exec().

send_agent_logoff()

static void send_agent_logoff ( struct ast_channel *  chan, const char *  agent, long  logintime  )

static

Definition at line 1483 of file app_agent_pool.c.

{
    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
    ast_assert(agent != NULL);
 
    blob = ast_json_pack("{s: s, s: I}",
        "agent", agent,
        "logintime", (ast_json_int_t)logintime);
    if (!blob) {
        return;
    }
 
    ast_channel_publish_blob(chan, ast_channel_agent_logoff_type(), blob);
}

References ast_assert, ast_channel_agent_logoff_type(), ast_channel_publish_blob(), ast_json_pack(), ast_json_unref(), NULL, and RAII_VAR.

Referenced by agent_logout().

send_alert_to_agent()

static int send_alert_to_agent ( struct ast_bridge_channel *  bridge_channel, const char *  agent_id  )

static

Definition at line 1837 of file app_agent_pool.c.

{
    return ast_bridge_channel_queue_callback(bridge_channel,
        AST_BRIDGE_CHANNEL_CB_OPTION_MEDIA, agent_alert, agent_id, strlen(agent_id) + 1);
}

References agent_alert(), AST_BRIDGE_CHANNEL_CB_OPTION_MEDIA, and ast_bridge_channel_queue_callback().

Referenced by caller_joined_bridge().

send_colp_to_agent()

static int send_colp_to_agent ( struct ast_bridge_channel *  bridge_channel, struct ast_party_connected_line *  connected  )

static

Definition at line 1843 of file app_agent_pool.c.

{
    struct ast_set_party_connected_line update = {
        .id.name = 1,
        .id.number = 1,
        .id.subaddress = 1,
    };
    unsigned char data[1024];   /* This should be large enough */
    size_t datalen;
 
    datalen = ast_connected_line_build_data(data, sizeof(data), connected, &update);
    if (datalen == (size_t) -1) {
        return 0;
    }
 
    return ast_bridge_channel_queue_control_data(bridge_channel,
        AST_CONTROL_CONNECTED_LINE, data, datalen);
}

References ast_bridge_channel_queue_control_data(), ast_connected_line_build_data(), AST_CONTROL_CONNECTED_LINE, connected, ast_set_party_connected_line::id, ast_set_party_id::name, and update().

Referenced by agent_request_exec().

unload_module()

static int unload_module ( void  )

static

Definition at line 2647 of file app_agent_pool.c.

{
    struct ast_bridge *holding;
 
    /* Unregister dialplan applications */
    ast_unregister_application(app_agent_login);
    ast_unregister_application(app_agent_request);
 
    /* Unregister dialplan functions */
    ast_custom_function_unregister(&agent_function);
 
    /* Unregister manager command */
    ast_manager_unregister("Agents");
    ast_manager_unregister("AgentLogoff");
 
    /* Unregister CLI commands */
    ast_cli_unregister_multiple(cli_agents, ARRAY_LEN(cli_agents));
 
    ast_devstate_prov_del("Agent");
 
    /* Destroy agent holding bridge. */
    holding = ao2_global_obj_replace(agent_holding, NULL);
    if (holding) {
        ast_bridge_destroy(holding, 0);
    }
 
    destroy_config();
    ao2_cleanup(agents);
    agents = NULL;
    return 0;
}

References agent_function, agents, ao2_cleanup, ao2_global_obj_replace, app_agent_login, app_agent_request, ARRAY_LEN, ast_bridge_destroy(), ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_devstate_prov_del(), ast_manager_unregister(), ast_unregister_application(), cli_agents, destroy_config(), and NULL.

Referenced by load_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Call center agent pool applications" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_DEVSTATE_PROVIDER, }

static

Definition at line 2739 of file app_agent_pool.c.

agent_function

struct ast_custom_function agent_function

static

Initial value:

= {
    .name = "AGENT",
    .read = agent_function_read,
}

Definition at line 2278 of file app_agent_pool.c.

                                                   {
    .name = "AGENT",
    .read = agent_function_read,
};

Referenced by load_module(), and unload_module().

agent_holding_lock

ast_mutex_t agent_holding_lock = AST_MUTEX_INIT_VALUE

static

Agent holding bridge deferred creation lock.

Definition at line 1040 of file app_agent_pool.c.

Referenced by bridge_agent_hold_deferred_create().

agent_login_opts

const struct ast_app_option agent_login_opts[128] = { [ 's' ] = { .flag = OPT_SILENT }, }

static

Definition at line 2124 of file app_agent_pool.c.

Referenced by agent_login_exec().

agent_type

struct aco_type agent_type

static

Definition at line 510 of file app_agent_pool.c.

                                    {
    .type = ACO_ITEM,
    .name = "agent-id",
    .category_match = ACO_BLACKLIST_EXACT,
    .category = "general",
    .item_alloc = agent_cfg_alloc,
    .item_find = agent_cfg_find,
    .item_offset = offsetof(struct agents_cfg, agents),
};

Referenced by ast_channel_get_cc_agent_type(), and ast_sip_auth_digest_algorithms_vector_init().

agent_types

struct aco_type* agent_types[] = ACO_TYPES(&agent_type)

static

Definition at line 520 of file app_agent_pool.c.

Referenced by load_config().

agents

struct ao2_container* agents

static

Container of defined agents.

Definition at line 694 of file app_agent_pool.c.

Referenced by action_agents(), agent_after_bridge_cb(), agent_after_bridge_cb_failed(), agent_alert(), agent_cfg_find(), agent_function_read(), agent_handle_show_specific(), agent_login_exec(), agent_logoff_request(), agent_pvt_devstate_get(), agent_request_exec(), agent_show_requested(), agents_mark(), agents_post_apply_config(), agents_sweep(), bridge_agent_hold_push(), complete_agent(), complete_agent_logoff(), load_module(), and unload_module().

agents_conf

struct aco_file agents_conf

static

Initial value:

= {
    .filename = "agents.conf",
    .types = ACO_TYPES(&general_type, &agent_type),
}

Definition at line 530 of file app_agent_pool.c.

                                     {
    .filename = "agents.conf",
    .types = ACO_TYPES(&general_type, &agent_type),
};

app_agent_login

const char app_agent_login[] = "AgentLogin"

static

Definition at line 395 of file app_agent_pool.c.

Referenced by load_module(), and unload_module().

app_agent_request

const char app_agent_request[] = "AgentRequest"

static

Definition at line 396 of file app_agent_pool.c.

Referenced by load_module(), and unload_module().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2739 of file app_agent_pool.c.

bridge_agent_hold_v_table

struct ast_bridge_methods bridge_agent_hold_v_table

static

Definition at line 1423 of file app_agent_pool.c.

Referenced by bridge_agent_hold_new(), and bridge_init_agent_hold().

cli_agents

struct ast_cli_entry cli_agents[]

static

Definition at line 2543 of file app_agent_pool.c.

                                           {
    AST_CLI_DEFINE(agent_handle_show_online, "Show status of online agents"),
    AST_CLI_DEFINE(agent_handle_show_all, "Show status of all agents"),
    AST_CLI_DEFINE(agent_handle_show_specific, "Show information about an agent"),
    AST_CLI_DEFINE(agent_handle_logoff_cmd, "Sets an agent offline"),
};

Referenced by load_module(), and unload_module().

general_type

struct aco_type general_type

static

Definition at line 523 of file app_agent_pool.c.

                                      {
    .type = ACO_GLOBAL,
    .name = "global",
    .category_match = ACO_WHITELIST_EXACT,
    .category = "general",
};