Implementation of Agents (proxy channel) More...
#include "asterisk.h"
#include <sys/socket.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/signal.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/rtp.h"
#include "asterisk/acl.h"
#include "asterisk/callerid.h"
#include "asterisk/file.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/musiconhold.h"
#include "asterisk/manager.h"
#include "asterisk/features.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/astdb.h"
#include "asterisk/devicestate.h"
#include "asterisk/monitor.h"
#include "asterisk/stringfields.h"
#include "asterisk/event.h"
Go to the source code of this file.
Data Structures | |
struct | agent_pvt |
Structure representing an agent. More... | |
struct | agents |
Defines | |
#define | AST_MAX_AGENT 80 |
#define | AST_MAX_BUF 256 |
#define | AST_MAX_FILENAME_LEN 256 |
#define | CHECK_FORMATS(ast, p) |
#define | CLEANUP(ast, p) |
Cleanup moves all the relevant FD's from the 2nd to the first, but retains things properly for a timingfd XXX This might need more work if agents were logged in as agents or other totally impractical combinations XXX. | |
#define | DEFAULT_ACCEPTDTMF '#' |
#define | DEFAULT_ENDDTMF '*' |
#define | GETAGENTBYCALLERID "AGENTBYCALLERID" |
#define | PA_MAX_LEN 2048 |
Enumerations | |
enum | { AGENT_FLAG_ACKCALL = (1 << 0), AGENT_FLAG_AUTOLOGOFF = (1 << 1), AGENT_FLAG_WRAPUPTIME = (1 << 2), AGENT_FLAG_ACCEPTDTMF = (1 << 3), AGENT_FLAG_ENDDTMF = (1 << 4) } |
Functions | |
static int | __agent_start_monitoring (struct ast_channel *ast, struct agent_pvt *p, int needlock) |
static void | __reg_module (void) |
static void | __unreg_module (void) |
static int | action_agent_logoff (struct mansession *s, const struct message *m) |
static int | action_agents (struct mansession *s, const struct message *m) |
static struct agent_pvt * | add_agent (const char *agent, int pending) |
static int | agent_ack_sleep (void *data) |
static int | agent_answer (struct ast_channel *ast) |
static struct ast_channel * | agent_bridgedchannel (struct ast_channel *chan, struct ast_channel *bridge) |
static int | agent_call (struct ast_channel *ast, char *dest, int timeout) |
static int | agent_cleanup (struct agent_pvt *p) |
static int | agent_cont_sleep (void *data) |
static int | agent_devicestate (void *data) |
Part of PBX channel interface. | |
static int | agent_digit_begin (struct ast_channel *ast, char digit) |
static int | agent_digit_end (struct ast_channel *ast, char digit, unsigned int duration) |
static int | agent_fixup (struct ast_channel *oldchan, struct ast_channel *newchan) |
static struct ast_channel * | agent_get_base_channel (struct ast_channel *chan) |
return the channel or base channel if one exists. This function assumes the channel it is called on is already locked | |
static int | agent_hangup (struct ast_channel *ast) |
static int | agent_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen) |
static int | agent_logoff (const char *agent, int soft) |
static char * | agent_logoff_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) |
static void | agent_logoff_maintenance (struct agent_pvt *p, char *loginchan, long logintime, const char *uniqueid, char *logcommand) |
static struct ast_channel * | agent_new (struct agent_pvt *p, int state) |
Create new agent channel. | |
static struct ast_frame * | agent_read (struct ast_channel *ast) |
static struct ast_channel * | agent_request (const char *type, int format, void *data, int *cause) |
Part of the Asterisk PBX interface. | |
static int | agent_sendhtml (struct ast_channel *ast, int subclass, const char *data, int datalen) |
static int | agent_sendtext (struct ast_channel *ast, const char *text) |
static int | agent_set_base_channel (struct ast_channel *chan, struct ast_channel *base) |
static int | agent_start_monitoring (struct ast_channel *ast, int needlock) |
static int | agent_write (struct ast_channel *ast, struct ast_frame *f) |
static int | agentmonitoroutgoing_exec (struct ast_channel *chan, void *data) |
Called by the AgentMonitorOutgoing application (from the dial plan). | |
static char * | agents_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) |
static char * | agents_show_online (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) |
static int | check_availability (struct agent_pvt *newlyavailable, int needlock) |
static int | check_beep (struct agent_pvt *newlyavailable, int needlock) |
static char * | complete_agent_logoff_cmd (const char *line, const char *word, int pos, int state) |
static void | dump_agents (void) |
Dump AgentCallbackLogin agents to the ASTdb database for persistence. | |
static struct agent_pvt * | find_agent (char *agentid) |
static int | function_agent (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len) |
static int | load_module (void) |
Initialize the Agents module. This function is being called by Asterisk when loading the module. Among other things it registers applications, cli commands and reads the cofiguration file. | |
static int | login_exec (struct ast_channel *chan, void *data) |
Log in agent application. | |
static force_inline int | powerof (unsigned int d) |
static int | read_agent_config (int reload) |
static int | reload (void) |
static void | reload_agents (void) |
Reload the persistent agents from astdb. | |
static void | set_agentbycallerid (const char *callerid, const char *agent) |
store/clear the global variable that stores agentid based on the callerid | |
static int | unload_module (void) |
Variables | |
static struct ast_module_info __MODULE_INFO_SECTION | __mod_info = { __MODULE_INFO_GLOBALS .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Agent Proxy Channel" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .reload = reload, } |
static char | acceptdtmf = DEFAULT_ACCEPTDTMF |
static int | ackcall |
struct ast_custom_function | agent_function |
static const char | agent_logoff_usage [] = " If 'soft' is specified, do not hangup existing calls.\n" |
static struct ast_channel_tech | agent_tech |
Channel interface description for PBX integration. | |
static char | agentgoodbye [AST_MAX_FILENAME_LEN] = "vm-goodbye" |
static struct agents | agents |
static const char | app [] = "AgentLogin" |
static const char | app3 [] = "AgentMonitorOutgoing" |
static struct ast_module_info * | ast_module_info = &__mod_info |
static int | autologoff |
static int | autologoffunavail = 0 |
static char | beep [AST_MAX_BUF] = "beep" |
static struct ast_cli_entry | cli_agents [] |
static const char | config [] = "agents.conf" |
static int | endcall |
static char | enddtmf = DEFAULT_ENDDTMF |
static ast_group_t | group |
static const char | mandescr_agent_logoff [] = " Soft: Set to 'true' to not hangup existing calls\n" |
static const char | mandescr_agents [] = "Variables: NONE\n" |
static int | maxlogintries = 3 |
static char | moh [80] = "default" |
static int | multiplelogin = 1 |
static const char | pa_family [] = "Agents" |
static int | persistent_agents = 0 |
static int | recordagentcalls = 0 |
static char | recordformat [AST_MAX_BUF] = "" |
static char | recordformatext [AST_MAX_BUF] = "" |
static char | savecallsin [AST_MAX_BUF] = "" |
static const char | tdesc [] = "Call Agent Proxy Channel" |
static int | updatecdr = 0 |
static char | urlprefix [AST_MAX_BUF] = "" |
static int | wrapuptime |
Implementation of Agents (proxy channel)
This file is the implementation of Agents modules. It is a dynamic module that is loaded by Asterisk.
Definition in file chan_agent.c.
#define AST_MAX_AGENT 80 |
Agent ID or Password max length
Definition at line 191 of file chan_agent.c.
Referenced by agent_logoff_maintenance(), agentmonitoroutgoing_exec(), complete_agent_logoff_cmd(), and login_exec().
#define AST_MAX_BUF 256 |
Definition at line 192 of file chan_agent.c.
Referenced by __agent_start_monitoring(), agentmonitoroutgoing_exec(), agents_show(), agents_show_online(), and set_agentbycallerid().
#define AST_MAX_FILENAME_LEN 256 |
Definition at line 193 of file chan_agent.c.
Referenced by login_exec().
#define CHECK_FORMATS | ( | ast, | |
p | |||
) |
Definition at line 270 of file chan_agent.c.
Referenced by agent_read(), and agent_write().
#define CLEANUP | ( | ast, | |
p | |||
) |
Cleanup moves all the relevant FD's from the 2nd to the first, but retains things properly for a timingfd XXX This might need more work if agents were logged in as agents or other totally impractical combinations XXX.
Definition at line 291 of file chan_agent.c.
Referenced by agent_call(), agent_read(), and agent_write().
#define DEFAULT_ACCEPTDTMF '#' |
Definition at line 201 of file chan_agent.c.
#define DEFAULT_ENDDTMF '*' |
Definition at line 202 of file chan_agent.c.
#define GETAGENTBYCALLERID "AGENTBYCALLERID" |
Definition at line 225 of file chan_agent.c.
Referenced by agentmonitoroutgoing_exec(), and set_agentbycallerid().
#define PA_MAX_LEN 2048 |
The maximum length of each persistent member agent database entry
Definition at line 196 of file chan_agent.c.
anonymous enum |
AGENT_FLAG_ACKCALL | |
AGENT_FLAG_AUTOLOGOFF | |
AGENT_FLAG_WRAPUPTIME | |
AGENT_FLAG_ACCEPTDTMF | |
AGENT_FLAG_ENDDTMF |
Definition at line 227 of file chan_agent.c.
{ AGENT_FLAG_ACKCALL = (1 << 0), AGENT_FLAG_AUTOLOGOFF = (1 << 1), AGENT_FLAG_WRAPUPTIME = (1 << 2), AGENT_FLAG_ACCEPTDTMF = (1 << 3), AGENT_FLAG_ENDDTMF = (1 << 4), };
static int __agent_start_monitoring | ( | struct ast_channel * | ast, |
struct agent_pvt * | p, | ||
int | needlock | ||
) | [static] |
Definition at line 486 of file chan_agent.c.
References agent_pvt::agent, ast_cdr_alloc(), ast_cdr_setuserfield(), ast_log(), AST_MAX_BUF, ast_monitor_setjoinfiles(), ast_monitor_start(), ast_verbose(), ast_channel::cdr, LOG_ERROR, ast_channel::monitor, ast_channel::uniqueid, X_REC_IN, and X_REC_OUT.
Referenced by agent_start_monitoring(), and agentmonitoroutgoing_exec().
{ char tmp[AST_MAX_BUF],tmp2[AST_MAX_BUF], *pointer; char filename[AST_MAX_BUF]; int res = -1; if (!p) return -1; if (!ast->monitor) { snprintf(filename, sizeof(filename), "agent-%s-%s",p->agent, ast->uniqueid); /* substitute . for - */ if ((pointer = strchr(filename, '.'))) *pointer = '-'; snprintf(tmp, sizeof(tmp), "%s%s", savecallsin, filename); ast_monitor_start(ast, recordformat, tmp, needlock, X_REC_IN | X_REC_OUT); ast_monitor_setjoinfiles(ast, 1); snprintf(tmp2, sizeof(tmp2), "%s%s.%s", urlprefix, filename, recordformatext); #if 0 ast_verbose("name is %s, link is %s\n",tmp, tmp2); #endif if (!ast->cdr) ast->cdr = ast_cdr_alloc(); ast_cdr_setuserfield(ast, tmp2); res = 0; } else ast_log(LOG_ERROR, "Recording already started on that call.\n"); return res; }
static void __reg_module | ( | void | ) | [static] |
Definition at line 2643 of file chan_agent.c.
static void __unreg_module | ( | void | ) | [static] |
Definition at line 2643 of file chan_agent.c.
static int action_agent_logoff | ( | struct mansession * | s, |
const struct message * | m | ||
) | [static] |
Sets an agent as no longer logged in in the Manager API. It is registered on load_module() and it gets called by the manager backend.
s | |
m |
Definition at line 1773 of file chan_agent.c.
References agent_pvt::agent, agent_logoff(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), and astman_send_error().
Referenced by load_module().
{ const char *agent = astman_get_header(m, "Agent"); const char *soft_s = astman_get_header(m, "Soft"); /* "true" is don't hangup */ int soft; int ret; /* return value of agent_logoff */ if (ast_strlen_zero(agent)) { astman_send_error(s, m, "No agent specified"); return 0; } soft = ast_true(soft_s) ? 1 : 0; ret = agent_logoff(agent, soft); if (ret == 0) astman_send_ack(s, m, "Agent logged out"); else astman_send_error(s, m, "No such agent"); return 0; }
static int action_agents | ( | struct mansession * | s, |
const struct message * | m | ||
) | [static] |
Lists agents and their status to the Manager API. It is registered on load_module() and it gets called by the manager backend.
s | |
m |
Definition at line 1570 of file chan_agent.c.
References ast_channel::_bridge, agent_pvt::acknowledged, agent_pvt::agent, ast_bridged_channel(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_strdupa, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_ack(), agent_pvt::chan, ast_channel::cid, ast_callerid::cid_num, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::loginstart, ast_channel::name, agent_pvt::name, agent_pvt::owner, S_OR, and status.
Referenced by load_module().
{ const char *id = astman_get_header(m,"ActionID"); char idText[256] = ""; char chanbuf[256]; struct agent_pvt *p; char *username = NULL; char *loginChan = NULL; char *talkingto = NULL; char *talkingtoChan = NULL; char *status = NULL; if (!ast_strlen_zero(id)) snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id); astman_send_ack(s, m, "Agents will follow"); AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { ast_mutex_lock(&p->lock); /* 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. */ username = S_OR(p->name, "None"); /* Set a default status. It 'should' get changed. */ status = "AGENT_UNKNOWN"; if (!ast_strlen_zero(p->loginchan) && !p->chan) { loginChan = p->loginchan; talkingto = "n/a"; talkingtoChan = "n/a"; status = "AGENT_IDLE"; if (p->acknowledged) { snprintf(chanbuf, sizeof(chanbuf), " %s (Confirmed)", p->loginchan); loginChan = chanbuf; } } else if (p->chan) { loginChan = ast_strdupa(p->chan->name); if (p->owner && p->owner->_bridge) { talkingto = p->chan->cid.cid_num; if (ast_bridged_channel(p->owner)) talkingtoChan = ast_strdupa(ast_bridged_channel(p->owner)->name); else talkingtoChan = "n/a"; status = "AGENT_ONCALL"; } else { talkingto = "n/a"; talkingtoChan = "n/a"; status = "AGENT_IDLE"; } } else { loginChan = "n/a"; talkingto = "n/a"; talkingtoChan = "n/a"; status = "AGENT_LOGGEDOFF"; } astman_append(s, "Event: Agents\r\n" "Agent: %s\r\n" "Name: %s\r\n" "Status: %s\r\n" "LoggedInChan: %s\r\n" "LoggedInTime: %d\r\n" "TalkingTo: %s\r\n" "TalkingToChan: %s\r\n" "%s" "\r\n", p->agent, username, status, loginChan, (int)p->loginstart, talkingto, talkingtoChan, idText); ast_mutex_unlock(&p->lock); } AST_LIST_UNLOCK(&agents); astman_append(s, "Event: AgentsComplete\r\n" "%s" "\r\n",idText); return 0; }
static struct agent_pvt* add_agent | ( | const char * | agent, |
int | pending | ||
) | [static, read] |
Adds an agent to the global list of agents.
agent | A string with the username, password and real name of an agent. As defined in agents.conf. Example: "13,169,John Smith" |
pending | If it is pending or not. |
Definition at line 357 of file chan_agent.c.
References agent_pvt::acceptdtmf, agent_pvt::ackcall, agent_pvt::agent, AGENT_FLAG_ACCEPTDTMF, AGENT_FLAG_ACKCALL, AGENT_FLAG_AUTOLOGOFF, AGENT_FLAG_ENDDTMF, AGENT_FLAG_WRAPUPTIME, agent_pvt::app_complete_cond, agent_pvt::app_lock, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, AST_APP_ARG, ast_calloc, ast_cond_init(), ast_copy_string(), AST_DECLARE_APP_ARGS, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_mutex_init(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_tvnow(), agent_pvt::autologoff, agent_pvt::dead, agent_pvt::enddtmf, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, LOG_WARNING, agent_pvt::moh, agent_pvt::name, parse(), agent_pvt::password, agent_pvt::pending, and agent_pvt::wrapuptime.
Referenced by agent_request(), and read_agent_config().
{ char *parse; AST_DECLARE_APP_ARGS(args, AST_APP_ARG(agt); AST_APP_ARG(password); AST_APP_ARG(name); ); char *password = NULL; char *name = NULL; char *agt = NULL; struct agent_pvt *p; parse = ast_strdupa(agent); /* Extract username (agt), password and name from agent (args). */ AST_STANDARD_APP_ARGS(args, parse); if(args.argc == 0) { ast_log(LOG_WARNING, "A blank agent line!\n"); return NULL; } if(ast_strlen_zero(args.agt) ) { ast_log(LOG_WARNING, "An agent line with no agentid!\n"); return NULL; } else agt = args.agt; if(!ast_strlen_zero(args.password)) { password = args.password; while (*password && *password < 33) password++; } if(!ast_strlen_zero(args.name)) { name = args.name; while (*name && *name < 33) name++; } /* Are we searching for the agent here ? To see if it exists already ? */ AST_LIST_TRAVERSE(&agents, p, list) { if (!pending && !strcmp(p->agent, agt)) break; } if (!p) { // Build the agent. if (!(p = ast_calloc(1, sizeof(*p)))) return NULL; ast_copy_string(p->agent, agt, sizeof(p->agent)); ast_mutex_init(&p->lock); ast_mutex_init(&p->app_lock); ast_cond_init(&p->app_complete_cond, NULL); p->app_lock_flag = 0; p->app_sleep_cond = 1; p->group = group; p->pending = pending; AST_LIST_INSERT_TAIL(&agents, p, list); } ast_copy_string(p->password, password ? password : "", sizeof(p->password)); ast_copy_string(p->name, name ? name : "", sizeof(p->name)); ast_copy_string(p->moh, moh, sizeof(p->moh)); if (!ast_test_flag(p, AGENT_FLAG_ACKCALL)) { p->ackcall = ackcall; } if (!ast_test_flag(p, AGENT_FLAG_AUTOLOGOFF)) { p->autologoff = autologoff; } if (!ast_test_flag(p, AGENT_FLAG_ACCEPTDTMF)) { p->acceptdtmf = acceptdtmf; } if (!ast_test_flag(p, AGENT_FLAG_ENDDTMF)) { p->enddtmf = enddtmf; } /* If someone reduces the wrapuptime and reloads, we want it * to change the wrapuptime immediately on all calls */ if (!ast_test_flag(p, AGENT_FLAG_WRAPUPTIME) && p->wrapuptime > wrapuptime) { struct timeval now = ast_tvnow(); /* XXX check what is this exactly */ /* We won't be pedantic and check the tv_usec val */ if (p->lastdisc.tv_sec > (now.tv_sec + wrapuptime/1000)) { p->lastdisc.tv_sec = now.tv_sec + wrapuptime/1000; p->lastdisc.tv_usec = now.tv_usec; } } p->wrapuptime = wrapuptime; if (pending) p->dead = 1; else p->dead = 0; return p; }
static int agent_ack_sleep | ( | void * | data | ) | [static] |
Definition at line 1033 of file chan_agent.c.
References agent_pvt::acceptdtmf, agent_pvt::app_sleep_cond, AST_FRAME_DTMF, ast_frfree, ast_mutex_lock(), ast_mutex_unlock(), ast_read(), ast_waitfor(), agent_pvt::chan, f, ast_frame::frametype, agent_pvt::lock, and ast_frame::subclass.
Referenced by login_exec().
{ struct agent_pvt *p; int res=0; int to = 1000; struct ast_frame *f; /* Wait a second and look for something */ p = (struct agent_pvt *) data; if (!p->chan) return -1; for(;;) { to = ast_waitfor(p->chan, to); if (to < 0) return -1; if (!to) return 0; f = ast_read(p->chan); if (!f) return -1; if (f->frametype == AST_FRAME_DTMF) res = f->subclass; else res = 0; ast_frfree(f); ast_mutex_lock(&p->lock); if (!p->app_sleep_cond) { ast_mutex_unlock(&p->lock); return 0; } else if (res == p->acceptdtmf) { ast_mutex_unlock(&p->lock); return 1; } ast_mutex_unlock(&p->lock); res = 0; } return res; }
static int agent_answer | ( | struct ast_channel * | ast | ) | [static] |
Definition at line 480 of file chan_agent.c.
References ast_log(), and LOG_WARNING.
{ ast_log(LOG_WARNING, "Huh? Agent is being asked to answer?\n"); return -1; }
static struct ast_channel * agent_bridgedchannel | ( | struct ast_channel * | chan, |
struct ast_channel * | bridge | ||
) | [static, read] |
Definition at line 1074 of file chan_agent.c.
References ast_channel::_bridge, ast_debug, agent_pvt::chan, ast_channel::name, and ast_channel::tech_pvt.
{ struct agent_pvt *p = bridge->tech_pvt; struct ast_channel *ret = NULL; if (p) { if (chan == p->chan) ret = bridge->_bridge; else if (chan == bridge->_bridge) ret = p->chan; } ast_debug(1, "Asked for bridged channel on '%s'/'%s', returning '%s'\n", chan->name, bridge->name, ret ? ret->name : "<none>"); return ret; }
static int agent_call | ( | struct ast_channel * | ast, |
char * | dest, | ||
int | timeout | ||
) | [static] |
Definition at line 775 of file chan_agent.c.
References agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_start_monitoring(), ast_best_codec(), ast_call(), ast_channel_inherit_variables(), ast_debug, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), ast_getformatname(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_callerid(), ast_set_read_format(), ast_set_write_format(), ast_setstate(), AST_STATE_DIALING, AST_STATE_RINGING, AST_STATE_UP, ast_streamfile(), ast_strlen_zero(), ast_verb, ast_waitstream(), agent_pvt::chan, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, CLEANUP, ast_channel::language, agent_pvt::lock, LOG_NOTICE, LOG_WARNING, agent_pvt::loginchan, ast_channel::name, ast_channel::nativeformats, agent_pvt::pending, agent_pvt::start, and ast_channel::tech_pvt.
{ struct agent_pvt *p = ast->tech_pvt; int res = -1; int newstate=0; ast_mutex_lock(&p->lock); p->acknowledged = 0; if (!p->chan) { if (p->pending) { ast_debug(1, "Pretending to dial on pending agent\n"); newstate = AST_STATE_DIALING; res = 0; } else { ast_log(LOG_NOTICE, "Whoa, they hung up between alloc and call... what are the odds of that?\n"); res = -1; } ast_mutex_unlock(&p->lock); if (newstate) ast_setstate(ast, newstate); return res; } else if (!ast_strlen_zero(p->loginchan)) { time(&p->start); /* Call on this agent */ ast_verb(3, "outgoing agentcall, to agent '%s', on '%s'\n", p->agent, p->chan->name); ast_set_callerid(p->chan, ast->cid.cid_num, ast->cid.cid_name, NULL); ast_channel_inherit_variables(ast, p->chan); res = ast_call(p->chan, p->loginchan, 0); CLEANUP(ast,p); ast_mutex_unlock(&p->lock); return res; } ast_verb(3, "agent_call, call to agent '%s' call on '%s'\n", p->agent, p->chan->name); ast_debug(3, "Playing beep, lang '%s'\n", p->chan->language); res = ast_streamfile(p->chan, beep, p->chan->language); ast_debug(3, "Played beep, result '%d'\n", res); if (!res) { res = ast_waitstream(p->chan, ""); ast_debug(3, "Waited for stream, result '%d'\n", res); } if (!res) { res = ast_set_read_format(p->chan, ast_best_codec(p->chan->nativeformats)); ast_debug(3, "Set read format, result '%d'\n", res); if (res) ast_log(LOG_WARNING, "Unable to set read format to %s\n", ast_getformatname(ast_best_codec(p->chan->nativeformats))); } else { /* Agent hung-up */ p->chan = NULL; ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent); } if (!res) { res = ast_set_write_format(p->chan, ast_best_codec(p->chan->nativeformats)); ast_debug(3, "Set write format, result '%d'\n", res); if (res) ast_log(LOG_WARNING, "Unable to set write format to %s\n", ast_getformatname(ast_best_codec(p->chan->nativeformats))); } if(!res) { /* Call is immediately up, or might need ack */ if (p->ackcall > 1) newstate = AST_STATE_RINGING; else { newstate = AST_STATE_UP; if (recordagentcalls) agent_start_monitoring(ast, 0); p->acknowledged = 1; } res = 0; } CLEANUP(ast, p); ast_mutex_unlock(&p->lock); if (newstate) ast_setstate(ast, newstate); return res; }
static int agent_cleanup | ( | struct agent_pvt * | p | ) | [static] |
Deletes an agent after doing some clean up. Further documentation: How safe is this function ? What state should the agent be to be cleaned.
p | Agent to be deleted. |
Definition at line 458 of file chan_agent.c.
References agent_pvt::app_complete_cond, agent_pvt::app_lock, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, ast_channel_free(), ast_cond_destroy(), ast_cond_signal(), ast_free, ast_mutex_destroy(), agent_pvt::chan, agent_pvt::dead, agent_pvt::lock, agent_pvt::owner, and ast_channel::tech_pvt.
Referenced by check_availability().
{ struct ast_channel *chan = p->owner; p->owner = NULL; chan->tech_pvt = NULL; p->app_sleep_cond = 1; /* Release ownership of the agent to other threads (presumably running the login app). */ p->app_lock_flag = 0; ast_cond_signal(&p->app_complete_cond); if (chan) ast_channel_free(chan); if (p->dead) { ast_mutex_destroy(&p->lock); ast_mutex_destroy(&p->app_lock); ast_cond_destroy(&p->app_complete_cond); ast_free(p); } return 0; }
static int agent_cont_sleep | ( | void * | data | ) | [static] |
Definition at line 1012 of file chan_agent.c.
References agent_pvt::app_sleep_cond, ast_debug, ast_mutex_lock(), ast_mutex_unlock(), ast_tvdiff_ms(), ast_tvnow(), agent_pvt::lastdisc, and agent_pvt::lock.
Referenced by login_exec().
{ struct agent_pvt *p; int res; p = (struct agent_pvt *)data; ast_mutex_lock(&p->lock); res = p->app_sleep_cond; if (p->lastdisc.tv_sec) { if (ast_tvdiff_ms(ast_tvnow(), p->lastdisc) > 0) res = 1; } ast_mutex_unlock(&p->lock); if (!res) ast_debug(5, "agent_cont_sleep() returning %d\n", res ); return res; }
static int agent_devicestate | ( | void * | data | ) | [static] |
Part of PBX channel interface.
Definition at line 2443 of file chan_agent.c.
References agent_pvt::agent, AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), agent_pvt::chan, agent_pvt::group, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::owner, agent_pvt::pending, and s.
{ struct agent_pvt *p; char *s; ast_group_t groupmatch; int groupoff; int res = AST_DEVICE_INVALID; s = data; if ((s[0] == '@') && (sscanf(s + 1, "%30d", &groupoff) == 1)) groupmatch = (1 << groupoff); else if ((s[0] == ':') && (sscanf(s + 1, "%30d", &groupoff) == 1)) { groupmatch = (1 << groupoff); } else groupmatch = 0; /* Check actual logged in agents first */ AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { ast_mutex_lock(&p->lock); if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent))) { if (p->owner) { if (res != AST_DEVICE_INUSE) res = AST_DEVICE_BUSY; } else { if (res == AST_DEVICE_BUSY) res = AST_DEVICE_INUSE; if (p->chan || !ast_strlen_zero(p->loginchan)) { if (res == AST_DEVICE_INVALID) res = AST_DEVICE_UNKNOWN; } else if (res == AST_DEVICE_INVALID) res = AST_DEVICE_UNAVAILABLE; } if (!strcmp(data, p->agent)) { ast_mutex_unlock(&p->lock); break; } } ast_mutex_unlock(&p->lock); } AST_LIST_UNLOCK(&agents); return res; }
static int agent_digit_begin | ( | struct ast_channel * | ast, |
char | digit | ||
) | [static] |
Definition at line 753 of file chan_agent.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_senddigit_begin(), agent_pvt::chan, agent_pvt::lock, and ast_channel::tech_pvt.
{ struct agent_pvt *p = ast->tech_pvt; ast_mutex_lock(&p->lock); if (p->chan) { ast_senddigit_begin(p->chan, digit); } ast_mutex_unlock(&p->lock); return 0; }
static int agent_digit_end | ( | struct ast_channel * | ast, |
char | digit, | ||
unsigned int | duration | ||
) | [static] |
Definition at line 764 of file chan_agent.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_senddigit_end(), agent_pvt::chan, agent_pvt::lock, and ast_channel::tech_pvt.
{ struct agent_pvt *p = ast->tech_pvt; ast_mutex_lock(&p->lock); if (p->chan) { ast_senddigit_end(p->chan, digit, duration); } ast_mutex_unlock(&p->lock); return 0; }
static int agent_fixup | ( | struct ast_channel * | oldchan, |
struct ast_channel * | newchan | ||
) | [static] |
Definition at line 715 of file chan_agent.c.
References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), agent_pvt::lock, LOG_WARNING, agent_pvt::owner, and ast_channel::tech_pvt.
{ struct agent_pvt *p = newchan->tech_pvt; ast_mutex_lock(&p->lock); if (p->owner != oldchan) { ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner); ast_mutex_unlock(&p->lock); return -1; } p->owner = newchan; ast_mutex_unlock(&p->lock); return 0; }
struct ast_channel * agent_get_base_channel | ( | struct ast_channel * | chan | ) | [static, read] |
return the channel or base channel if one exists. This function assumes the channel it is called on is already locked
Definition at line 865 of file chan_agent.c.
References ast_log(), agent_pvt::chan, LOG_ERROR, and ast_channel::tech_pvt.
{ struct agent_pvt *p = NULL; struct ast_channel *base = chan; /* chan is locked by the calling function */ if (!chan || !chan->tech_pvt) { ast_log(LOG_ERROR, "whoa, you need a channel (0x%ld) with a tech_pvt (0x%ld) to get a base channel.\n", (long)chan, (chan)?(long)chan->tech_pvt:(long)NULL); return NULL; } p = chan->tech_pvt; if (p->chan) base = p->chan; return base; }
static int agent_hangup | ( | struct ast_channel * | ast | ) | [static] |
Definition at line 898 of file chan_agent.c.
References ast_channel::_bridge, ast_channel::_state, agent_pvt::abouttograb, agent_pvt::acknowledged, agent_pvt::agent, agent_logoff_maintenance(), agent_pvt::app_complete_cond, agent_pvt::app_lock, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, ast_channel_lock, ast_channel_unlock, ast_cond_destroy(), ast_cond_signal(), AST_CONTROL_HOLD, ast_debug, AST_DEVICE_NOT_INUSE, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), ast_free, ast_hangup(), ast_indicate_data(), AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, ast_log(), ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), ast_samp2tv(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_state2str(), AST_STATE_RESERVED, AST_STATE_UP, ast_strlen_zero(), ast_tv(), ast_tvadd(), ast_tvnow(), agent_pvt::autologoff, agent_pvt::chan, agent_pvt::dead, agent_pvt::deferlogoff, dump_agents(), agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, agent_pvt::logincallerid, agent_pvt::loginchan, agent_pvt::loginstart, agent_pvt::moh, agent_pvt::name, agent_pvt::owner, pbx_builtin_getvar_helper(), agent_pvt::pending, S_OR, agent_pvt::start, status, ast_channel::tech_pvt, ast_channel::uniqueid, and agent_pvt::wrapuptime.
{ struct agent_pvt *p = ast->tech_pvt; int howlong = 0; const char *status; ast_mutex_lock(&p->lock); p->owner = NULL; ast->tech_pvt = NULL; p->app_sleep_cond = 1; p->acknowledged = 0; /* if they really are hung up then set start to 0 so the test * later if we're called on an already downed channel * doesn't cause an agent to be logged out like when * agent_request() is followed immediately by agent_hangup() * as in apps/app_chanisavail.c:chanavail_exec() */ ast_debug(1, "Hangup called for state %s\n", ast_state2str(ast->_state)); if (p->start && (ast->_state != AST_STATE_UP)) { howlong = time(NULL) - p->start; p->start = 0; } else if (ast->_state == AST_STATE_RESERVED) howlong = 0; else p->start = 0; if (p->chan) { p->chan->_bridge = NULL; /* If they're dead, go ahead and hang up on the agent now */ if (!ast_strlen_zero(p->loginchan)) { /* Store last disconnect time */ if (p->wrapuptime) p->lastdisc = ast_tvadd(ast_tvnow(), ast_samp2tv(p->wrapuptime, 1000)); else p->lastdisc = ast_tv(0,0); if (p->chan) { status = pbx_builtin_getvar_helper(p->chan, "CHANLOCALSTATUS"); if (autologoffunavail && status && !strcasecmp(status, "CHANUNAVAIL")) { long logintime = time(NULL) - p->loginstart; p->loginstart = 0; ast_log(LOG_NOTICE, "Agent hangup: '%s' is not available now, auto logoff\n", p->name); agent_logoff_maintenance(p, p->loginchan, logintime, ast->uniqueid, "Chanunavail"); } /* Recognize the hangup and pass it along immediately */ ast_hangup(p->chan); p->chan = NULL; ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent); } ast_debug(1, "Hungup, howlong is %d, autologoff is %d\n", howlong, p->autologoff); if ((p->deferlogoff) || (howlong && p->autologoff && (howlong > p->autologoff))) { long logintime = time(NULL) - p->loginstart; p->loginstart = 0; if (!p->deferlogoff) ast_log(LOG_NOTICE, "Agent '%s' didn't answer/confirm within %d seconds (waited %d)\n", p->name, p->autologoff, howlong); p->deferlogoff = 0; agent_logoff_maintenance(p, p->loginchan, logintime, ast->uniqueid, "Autologoff"); if (persistent_agents) dump_agents(); } } else if (p->dead) { ast_channel_lock(p->chan); ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT); ast_channel_unlock(p->chan); } else if (p->loginstart) { ast_channel_lock(p->chan); ast_indicate_data(p->chan, AST_CONTROL_HOLD, S_OR(p->moh, NULL), !ast_strlen_zero(p->moh) ? strlen(p->moh) + 1 : 0); ast_channel_unlock(p->chan); } } ast_mutex_unlock(&p->lock); /* Only register a device state change if the agent is still logged in */ if (!p->loginstart) { p->loginchan[0] = '\0'; p->logincallerid[0] = '\0'; if (persistent_agents) dump_agents(); } else { ast_devstate_changed(AST_DEVICE_NOT_INUSE, "Agent/%s", p->agent); } if (p->pending) { AST_LIST_LOCK(&agents); AST_LIST_REMOVE(&agents, p, list); AST_LIST_UNLOCK(&agents); } if (p->abouttograb) { /* Let the "about to grab" thread know this isn't valid anymore, and let it kill it later */ p->abouttograb = 0; } else if (p->dead) { ast_mutex_destroy(&p->lock); ast_mutex_destroy(&p->app_lock); ast_cond_destroy(&p->app_complete_cond); ast_free(p); } else { if (p->chan) { /* Not dead -- check availability now */ ast_mutex_lock(&p->lock); /* Store last disconnect time */ p->lastdisc = ast_tvadd(ast_tvnow(), ast_samp2tv(p->wrapuptime, 1000)); ast_mutex_unlock(&p->lock); } /* Release ownership of the agent to other threads (presumably running the login app). */ if (ast_strlen_zero(p->loginchan)) { p->app_lock_flag = 0; ast_cond_signal(&p->app_complete_cond); } } return 0; }
static int agent_indicate | ( | struct ast_channel * | ast, |
int | condition, | ||
const void * | data, | ||
size_t | datalen | ||
) | [static] |
Definition at line 729 of file chan_agent.c.
References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_check_hangup(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), agent_pvt::chan, ast_channel_tech::indicate, agent_pvt::lock, LOG_ERROR, ast_channel::tech, and ast_channel::tech_pvt.
{ struct agent_pvt *p = ast->tech_pvt; int res = -1; ast_mutex_lock(&p->lock); if (p->chan && !ast_check_hangup(p->chan)) { while (ast_channel_trylock(p->chan)) { int res; if ((res = ast_channel_unlock(ast))) { ast_log(LOG_ERROR, "chan_agent bug! Channel was not locked upon entry to agent_indicate: %s\n", strerror(res)); ast_mutex_unlock(&p->lock); return -1; } usleep(1); ast_channel_lock(ast); } res = p->chan->tech->indicate ? p->chan->tech->indicate(p->chan, condition, data, datalen) : -1; ast_channel_unlock(p->chan); } else res = 0; ast_mutex_unlock(&p->lock); return res; }
static int agent_logoff | ( | const char * | agent, |
int | soft | ||
) | [static] |
Definition at line 1689 of file chan_agent.c.
References agent_pvt::agent, agent_logoff_maintenance(), ast_channel_trylock, ast_channel_unlock, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, agent_pvt::chan, DEADLOCK_AVOIDANCE, agent_pvt::deferlogoff, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::loginstart, and agent_pvt::owner.
Referenced by action_agent_logoff(), and agent_logoff_cmd().
{ struct agent_pvt *p; long logintime; int ret = -1; /* Return -1 if no agent if found */ AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { if (!strcasecmp(p->agent, agent)) { ret = 0; if (p->owner || p->chan) { if (!soft) { ast_mutex_lock(&p->lock); while (p->owner && ast_channel_trylock(p->owner)) { DEADLOCK_AVOIDANCE(&p->lock); } if (p->owner) { ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT); ast_channel_unlock(p->owner); } while (p->chan && ast_channel_trylock(p->chan)) { DEADLOCK_AVOIDANCE(&p->lock); } if (p->chan) { ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT); ast_channel_unlock(p->chan); } ast_mutex_unlock(&p->lock); } else p->deferlogoff = 1; } else { logintime = time(NULL) - p->loginstart; p->loginstart = 0; agent_logoff_maintenance(p, p->loginchan, logintime, NULL, "CommandLogoff"); } break; } } AST_LIST_UNLOCK(&agents); return ret; }
static char* agent_logoff_cmd | ( | struct ast_cli_entry * | e, |
int | cmd, | ||
struct ast_cli_args * | a | ||
) | [static] |
Definition at line 1735 of file chan_agent.c.
References agent_pvt::agent, agent_logoff(), ast_cli_args::argc, ast_cli_args::argv, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_agent_logoff_cmd(), ast_cli_args::fd, ast_cli_args::line, ast_cli_args::n, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.
{ int ret; char *agent; switch (cmd) { case CLI_INIT: e->command = "agent logoff"; e->usage = "Usage: agent logoff <channel> [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: return complete_agent_logoff_cmd(a->line, a->word, a->pos, a->n); } if (a->argc < 3 || a->argc > 4) return CLI_SHOWUSAGE; if (a->argc == 4 && strcasecmp(a->argv[3], "soft")) return CLI_SHOWUSAGE; agent = a->argv[2] + 6; ret = agent_logoff(agent, a->argc == 4); if (ret == 0) ast_cli(a->fd, "Logging out %s\n", agent); return CLI_SUCCESS; }
static void agent_logoff_maintenance | ( | struct agent_pvt * | p, |
char * | loginchan, | ||
long | logintime, | ||
const char * | uniqueid, | ||
char * | logcommand | ||
) | [static] |
Definition at line 1650 of file chan_agent.c.
References agent_pvt::agent, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), AST_MAX_AGENT, ast_queue_log(), ast_strdupa, ast_strlen_zero(), dump_agents(), EVENT_FLAG_AGENT, agent_pvt::logincallerid, agent_pvt::loginchan, manager_event, and set_agentbycallerid().
Referenced by agent_hangup(), agent_logoff(), and agent_read().
{ char *tmp = NULL; char agent[AST_MAX_AGENT]; if (!ast_strlen_zero(logcommand)) tmp = logcommand; else tmp = ast_strdupa(""); snprintf(agent, sizeof(agent), "Agent/%s", p->agent); if (!ast_strlen_zero(uniqueid)) { manager_event(EVENT_FLAG_AGENT, "Agentcallbacklogoff", "Agent: %s\r\n" "Reason: %s\r\n" "Loginchan: %s\r\n" "Logintime: %ld\r\n" "Uniqueid: %s\r\n", p->agent, tmp, loginchan, logintime, uniqueid); } else { manager_event(EVENT_FLAG_AGENT, "Agentcallbacklogoff", "Agent: %s\r\n" "Reason: %s\r\n" "Loginchan: %s\r\n" "Logintime: %ld\r\n", p->agent, tmp, loginchan, logintime); } ast_queue_log("NONE", ast_strlen_zero(uniqueid) ? "NONE" : uniqueid, agent, "AGENTCALLBACKLOGOFF", "%s|%ld|%s", loginchan, logintime, tmp); set_agentbycallerid(p->logincallerid, NULL); p->loginchan[0] ='\0'; p->logincallerid[0] = '\0'; ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent); if (persistent_agents) dump_agents(); }
static struct ast_channel* agent_new | ( | struct agent_pvt * | p, |
int | state | ||
) | [static, read] |
Create new agent channel.
Definition at line 1091 of file chan_agent.c.
References agent_pvt::agent, agent_tech, agent_pvt::app_complete_cond, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, ast_channel_alloc(), ast_channel_free(), ast_cond_signal(), AST_CONTROL_UNHOLD, ast_copy_string(), AST_FORMAT_SLINEAR, ast_indicate(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_null_frame, ast_queue_frame(), ast_random(), ast_string_field_set, ast_strlen_zero(), agent_pvt::chan, ast_channel::context, ast_channel::exten, ast_channel::language, language, agent_pvt::lock, LOG_WARNING, agent_pvt::loginchan, ast_channel::nativeformats, agent_pvt::owner, agent_pvt::pending, ast_channel::priority, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, ast_channel::tech, ast_channel::tech_pvt, and ast_channel::writeformat.
Referenced by agent_request(), and check_availability().
{ struct ast_channel *tmp; int alreadylocked; #if 0 if (!p->chan) { ast_log(LOG_WARNING, "No channel? :(\n"); return NULL; } #endif if (p->pending) tmp = ast_channel_alloc(0, state, 0, 0, "", p->chan ? p->chan->exten:"", p->chan ? p->chan->context:"", 0, "Agent/P%s-%d", p->agent, (int) ast_random() & 0xffff); else tmp = ast_channel_alloc(0, state, 0, 0, "", p->chan ? p->chan->exten:"", p->chan ? p->chan->context:"", 0, "Agent/%s", p->agent); if (!tmp) { ast_log(LOG_WARNING, "Unable to allocate agent channel structure\n"); return NULL; } tmp->tech = &agent_tech; if (p->chan) { tmp->nativeformats = p->chan->nativeformats; tmp->writeformat = p->chan->writeformat; tmp->rawwriteformat = p->chan->writeformat; tmp->readformat = p->chan->readformat; tmp->rawreadformat = p->chan->readformat; ast_string_field_set(tmp, language, p->chan->language); ast_copy_string(tmp->context, p->chan->context, sizeof(tmp->context)); ast_copy_string(tmp->exten, p->chan->exten, sizeof(tmp->exten)); /* XXX Is this really all we copy form the originating channel?? */ } else { tmp->nativeformats = AST_FORMAT_SLINEAR; tmp->writeformat = AST_FORMAT_SLINEAR; tmp->rawwriteformat = AST_FORMAT_SLINEAR; tmp->readformat = AST_FORMAT_SLINEAR; tmp->rawreadformat = AST_FORMAT_SLINEAR; } /* Safe, agentlock already held */ tmp->tech_pvt = p; p->owner = tmp; tmp->priority = 1; /* Wake up and wait for other applications (by definition the login app) * to release this channel). Takes ownership of the agent channel * to this thread only. * For signalling the other thread, ast_queue_frame is used until we * can safely use signals for this purpose. The pselect() needs to be * implemented in the kernel for this. */ p->app_sleep_cond = 0; alreadylocked = p->app_lock_flag; p->app_lock_flag = 1; if(ast_strlen_zero(p->loginchan) && alreadylocked) { if (p->chan) { ast_queue_frame(p->chan, &ast_null_frame); ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */ p->app_lock_flag = 1; ast_mutex_lock(&p->lock); } else { ast_log(LOG_WARNING, "Agent disconnected while we were connecting the call\n"); p->owner = NULL; tmp->tech_pvt = NULL; p->app_sleep_cond = 1; ast_channel_free( tmp ); ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */ p->app_lock_flag = 0; ast_cond_signal(&p->app_complete_cond); return NULL; } } else if (!ast_strlen_zero(p->loginchan)) { if (p->chan) ast_queue_frame(p->chan, &ast_null_frame); if (!p->chan) { ast_log(LOG_WARNING, "Agent disconnected while we were connecting the call\n"); p->owner = NULL; tmp->tech_pvt = NULL; p->app_sleep_cond = 1; ast_channel_free( tmp ); ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */ return NULL; } } if (p->chan) ast_indicate(p->chan, AST_CONTROL_UNHOLD); return tmp; }
static struct ast_frame * agent_read | ( | struct ast_channel * | ast | ) | [static, read] |
Definition at line 519 of file chan_agent.c.
References ast_channel::_bridge, ast_channel::_state, agent_pvt::acceptdtmf, agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_logoff_maintenance(), agent_start_monitoring(), AST_AGENT_FD, ast_channel_trylock, ast_channel_unlock, AST_CONTROL_ANSWER, ast_copy_flags, ast_debug, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), AST_FLAG_EXCEPTION, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, ast_hangup(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_null_frame, ast_read(), ast_samp2tv(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, AST_STATE_UP, ast_strlen_zero(), AST_TIMING_FD, ast_tvadd(), ast_tvnow(), ast_verb, agent_pvt::autologoff, agent_pvt::chan, CHECK_FORMATS, CLEANUP, DEADLOCK_AVOIDANCE, agent_pvt::enddtmf, f, ast_channel::fdno, ast_frame::frametype, agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, agent_pvt::loginchan, agent_pvt::loginstart, agent_pvt::name, ast_channel::name, agent_pvt::owner, pbx_builtin_getvar_helper(), agent_pvt::start, status, ast_frame::subclass, ast_channel::tech, ast_channel::tech_pvt, ast_channel_tech::type, ast_channel::uniqueid, and agent_pvt::wrapuptime.
{ struct agent_pvt *p = ast->tech_pvt; struct ast_frame *f = NULL; static struct ast_frame answer_frame = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER }; const char *status; int cur_time = time(NULL); ast_mutex_lock(&p->lock); CHECK_FORMATS(ast, p); if (!p->start) { p->start = cur_time; } if (p->chan) { ast_copy_flags(p->chan, ast, AST_FLAG_EXCEPTION); p->chan->fdno = (ast->fdno == AST_AGENT_FD) ? AST_TIMING_FD : ast->fdno; f = ast_read(p->chan); } else f = &ast_null_frame; if (!f) { /* If there's a channel, hang it up (if it's on a callback) make it NULL */ if (p->chan) { p->chan->_bridge = NULL; /* Note that we don't hangup if it's not a callback because Asterisk will do it for us when the PBX instance that called login finishes */ if (!ast_strlen_zero(p->loginchan)) { if (p->chan) ast_debug(1, "Bridge on '%s' being cleared (2)\n", p->chan->name); if (p->owner->_state != AST_STATE_UP) { int howlong = cur_time - p->start; if (p->autologoff && howlong >= p->autologoff) { p->loginstart = 0; ast_log(LOG_NOTICE, "Agent '%s' didn't answer/confirm within %d seconds (waited %d)\n", p->name, p->autologoff, howlong); agent_logoff_maintenance(p, p->loginchan, (cur_time = p->loginstart), ast->uniqueid, "Autologoff"); } } status = pbx_builtin_getvar_helper(p->chan, "CHANLOCALSTATUS"); if (autologoffunavail && status && !strcasecmp(status, "CHANUNAVAIL")) { long logintime = cur_time - p->loginstart; p->loginstart = 0; ast_log(LOG_NOTICE, "Agent read: '%s' is not available now, auto logoff\n", p->name); agent_logoff_maintenance(p, p->loginchan, logintime, ast->uniqueid, "Chanunavail"); } ast_hangup(p->chan); if (p->wrapuptime && p->acknowledged) p->lastdisc = ast_tvadd(ast_tvnow(), ast_samp2tv(p->wrapuptime, 1000)); } p->chan = NULL; ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent); p->acknowledged = 0; } } else { /* if acknowledgement is not required, and the channel is up, we may have missed an AST_CONTROL_ANSWER (if there was one), so mark the call acknowledged anyway */ if (!p->ackcall && !p->acknowledged && p->chan && (p->chan->_state == AST_STATE_UP)) { p->acknowledged = 1; } if (!p->acknowledged) { int howlong = cur_time - p->start; if (p->autologoff && (howlong >= p->autologoff)) { ast_log(LOG_NOTICE, "Agent '%s' didn't answer/confirm within %d seconds (waited %d)\n", p->name, p->autologoff, howlong); agent_logoff_maintenance(p, p->loginchan, (cur_time - p->loginstart), ast->uniqueid, "Autologoff"); if (p->owner || p->chan) { while (p->owner && ast_channel_trylock(p->owner)) { DEADLOCK_AVOIDANCE(&p->lock); } if (p->owner) { ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT); ast_channel_unlock(p->owner); } while (p->chan && ast_channel_trylock(p->chan)) { DEADLOCK_AVOIDANCE(&p->lock); } if (p->chan) { ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT); ast_channel_unlock(p->chan); } } else { long logintime; logintime = time(NULL) - p->loginstart; p->loginstart = 0; agent_logoff_maintenance(p, p->loginchan, logintime, NULL, "CommandLogoff"); } } } switch (f->frametype) { case AST_FRAME_CONTROL: if (f->subclass == AST_CONTROL_ANSWER) { if (p->ackcall) { ast_verb(3, "%s answered, waiting for '%c' to acknowledge\n", p->chan->name, p->acceptdtmf); /* Don't pass answer along */ ast_frfree(f); f = &ast_null_frame; } else { p->acknowledged = 1; /* Use the builtin answer frame for the recording start check below. */ ast_frfree(f); f = &answer_frame; } } break; case AST_FRAME_DTMF_BEGIN: /*ignore DTMF begin's as it can cause issues with queue announce files*/ if((!p->acknowledged && f->subclass == p->acceptdtmf) || (f->subclass == p->enddtmf && endcall)){ ast_frfree(f); f = &ast_null_frame; } break; case AST_FRAME_DTMF_END: if (!p->acknowledged && (f->subclass == p->acceptdtmf)) { ast_verb(3, "%s acknowledged\n", p->chan->name); p->acknowledged = 1; ast_frfree(f); f = &answer_frame; } else if (f->subclass == p->enddtmf && endcall) { /* terminates call */ ast_frfree(f); f = NULL; } break; case AST_FRAME_VOICE: case AST_FRAME_VIDEO: /* don't pass voice or video until the call is acknowledged */ if (!p->acknowledged) { ast_frfree(f); f = &ast_null_frame; } default: /* pass everything else on through */ break; } } CLEANUP(ast,p); if (p->chan && !p->chan->_bridge) { if (strcasecmp(p->chan->tech->type, "Local")) { p->chan->_bridge = ast; if (p->chan) ast_debug(1, "Bridge on '%s' being set to '%s' (3)\n", p->chan->name, p->chan->_bridge->name); } } ast_mutex_unlock(&p->lock); if (recordagentcalls && f == &answer_frame) agent_start_monitoring(ast,0); return f; }
static struct ast_channel * agent_request | ( | const char * | type, |
int | format, | ||
void * | data, | ||
int * | cause | ||
) | [static, read] |
Part of the Asterisk PBX interface.
Definition at line 1457 of file chan_agent.c.
References add_agent(), agent_pvt::agent, agent_new(), AST_CAUSE_BUSY, AST_CAUSE_UNREGISTERED, ast_debug, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_request(), AST_STATE_DOWN, ast_strlen_zero(), ast_tv(), ast_tvnow(), agent_pvt::chan, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, LOG_WARNING, agent_pvt::loginchan, agent_pvt::owner, agent_pvt::pending, and s.
{ struct agent_pvt *p; struct ast_channel *chan = NULL; char *s; ast_group_t groupmatch; int groupoff; int waitforagent=0; int hasagent = 0; struct timeval now; s = data; if ((s[0] == '@') && (sscanf(s + 1, "%30d", &groupoff) == 1)) { groupmatch = (1 << groupoff); } else if ((s[0] == ':') && (sscanf(s + 1, "%30d", &groupoff) == 1)) { groupmatch = (1 << groupoff); waitforagent = 1; } else groupmatch = 0; /* Check actual logged in agents first */ AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { ast_mutex_lock(&p->lock); if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent)) && ast_strlen_zero(p->loginchan)) { if (p->chan) hasagent++; now = ast_tvnow(); if (!p->lastdisc.tv_sec || (now.tv_sec >= p->lastdisc.tv_sec)) { p->lastdisc = ast_tv(0, 0); /* Agent must be registered, but not have any active call, and not be in a waiting state */ if (!p->owner && p->chan) { /* Fixed agent */ chan = agent_new(p, AST_STATE_DOWN); } if (chan) { ast_mutex_unlock(&p->lock); break; } } } ast_mutex_unlock(&p->lock); } if (!p) { AST_LIST_TRAVERSE(&agents, p, list) { ast_mutex_lock(&p->lock); if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent))) { if (p->chan || !ast_strlen_zero(p->loginchan)) hasagent++; now = ast_tvnow(); #if 0 ast_log(LOG_NOTICE, "Time now: %ld, Time of lastdisc: %ld\n", now.tv_sec, p->lastdisc.tv_sec); #endif if (!p->lastdisc.tv_sec || (now.tv_sec >= p->lastdisc.tv_sec)) { p->lastdisc = ast_tv(0, 0); /* Agent must be registered, but not have any active call, and not be in a waiting state */ if (!p->owner && p->chan) { /* Could still get a fixed agent */ chan = agent_new(p, AST_STATE_DOWN); } else if (!p->owner && !ast_strlen_zero(p->loginchan)) { /* Adjustable agent */ p->chan = ast_request("Local", format, p->loginchan, cause); if (p->chan) chan = agent_new(p, AST_STATE_DOWN); } if (chan) { ast_mutex_unlock(&p->lock); break; } } } ast_mutex_unlock(&p->lock); } } if (!chan && waitforagent) { /* No agent available -- but we're requesting to wait for one. Allocate a place holder */ if (hasagent) { ast_debug(1, "Creating place holder for '%s'\n", s); p = add_agent(data, 1); p->group = groupmatch; chan = agent_new(p, AST_STATE_DOWN); if (!chan) ast_log(LOG_WARNING, "Weird... Fix this to drop the unused pending agent\n"); } else { ast_debug(1, "Not creating place holder for '%s' since nobody logged in\n", s); } } *cause = hasagent ? AST_CAUSE_BUSY : AST_CAUSE_UNREGISTERED; AST_LIST_UNLOCK(&agents); return chan; }
static int agent_sendhtml | ( | struct ast_channel * | ast, |
int | subclass, | ||
const char * | data, | ||
int | datalen | ||
) | [static] |
Definition at line 668 of file chan_agent.c.
References ast_channel_sendhtml(), ast_mutex_lock(), ast_mutex_unlock(), agent_pvt::chan, agent_pvt::lock, and ast_channel::tech_pvt.
{ struct agent_pvt *p = ast->tech_pvt; int res = -1; ast_mutex_lock(&p->lock); if (p->chan) res = ast_channel_sendhtml(p->chan, subclass, data, datalen); ast_mutex_unlock(&p->lock); return res; }
static int agent_sendtext | ( | struct ast_channel * | ast, |
const char * | text | ||
) | [static] |
Definition at line 679 of file chan_agent.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_sendtext(), agent_pvt::chan, agent_pvt::lock, and ast_channel::tech_pvt.
{ struct agent_pvt *p = ast->tech_pvt; int res = -1; ast_mutex_lock(&p->lock); if (p->chan) res = ast_sendtext(p->chan, text); ast_mutex_unlock(&p->lock); return res; }
int agent_set_base_channel | ( | struct ast_channel * | chan, |
struct ast_channel * | base | ||
) | [static] |
Definition at line 881 of file chan_agent.c.
References ast_log(), agent_pvt::chan, LOG_ERROR, ast_channel::name, and ast_channel::tech_pvt.
{ struct agent_pvt *p = NULL; if (!chan || !base) { ast_log(LOG_ERROR, "whoa, you need a channel (0x%ld) and a base channel (0x%ld) for setting.\n", (long)chan, (long)base); return -1; } p = chan->tech_pvt; if (!p) { ast_log(LOG_ERROR, "whoa, channel %s is missing his tech_pvt structure!!.\n", chan->name); return -1; } p->chan = base; return 0; }
static int agent_start_monitoring | ( | struct ast_channel * | ast, |
int | needlock | ||
) | [static] |
Definition at line 514 of file chan_agent.c.
References __agent_start_monitoring(), and ast_channel::tech_pvt.
Referenced by agent_call(), and agent_read().
{ return __agent_start_monitoring(ast, ast->tech_pvt, needlock); }
static int agent_write | ( | struct ast_channel * | ast, |
struct ast_frame * | f | ||
) | [static] |
Definition at line 690 of file chan_agent.c.
References ast_debug, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_mutex_lock(), ast_mutex_unlock(), ast_write(), agent_pvt::chan, CHECK_FORMATS, CLEANUP, ast_frame::frametype, agent_pvt::lock, ast_channel::name, ast_frame::subclass, ast_channel::tech_pvt, and ast_channel::writeformat.
{ struct agent_pvt *p = ast->tech_pvt; int res = -1; CHECK_FORMATS(ast, p); ast_mutex_lock(&p->lock); if (!p->chan) res = 0; else { if ((f->frametype != AST_FRAME_VOICE) || (f->frametype != AST_FRAME_VIDEO) || (f->subclass == p->chan->writeformat)) { res = ast_write(p->chan, f); } else { ast_debug(1, "Dropping one incompatible %s frame on '%s' to '%s'\n", f->frametype == AST_FRAME_VOICE ? "audio" : "video", ast->name, p->chan->name); res = 0; } } CLEANUP(ast, p); ast_mutex_unlock(&p->lock); return res; }
static int agentmonitoroutgoing_exec | ( | struct ast_channel * | chan, |
void * | data | ||
) | [static] |
Called by the AgentMonitorOutgoing application (from the dial plan).
chan | |
data |
Definition at line 2314 of file chan_agent.c.
References __agent_start_monitoring(), agent_pvt::agent, ast_copy_string(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), AST_MAX_AGENT, AST_MAX_BUF, ast_channel::cdr, ast_cdr::channel, ast_channel::cid, ast_callerid::cid_num, GETAGENTBYCALLERID, LOG_WARNING, and pbx_builtin_getvar_helper().
Referenced by load_module().
{ int exitifnoagentid = 0; int nowarnings = 0; int changeoutgoing = 0; int res = 0; char agent[AST_MAX_AGENT]; if (data) { if (strchr(data, 'd')) exitifnoagentid = 1; if (strchr(data, 'n')) nowarnings = 1; if (strchr(data, 'c')) changeoutgoing = 1; } if (chan->cid.cid_num) { const char *tmp; char agentvar[AST_MAX_BUF]; snprintf(agentvar, sizeof(agentvar), "%s_%s", GETAGENTBYCALLERID, chan->cid.cid_num); if ((tmp = pbx_builtin_getvar_helper(NULL, agentvar))) { struct agent_pvt *p; ast_copy_string(agent, tmp, sizeof(agent)); AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { if (!strcasecmp(p->agent, tmp)) { if (changeoutgoing) snprintf(chan->cdr->channel, sizeof(chan->cdr->channel), "Agent/%s", p->agent); __agent_start_monitoring(chan, p, 1); break; } } AST_LIST_UNLOCK(&agents); } else { res = -1; if (!nowarnings) ast_log(LOG_WARNING, "Couldn't find the global variable %s, so I can't figure out which agent (if it's an agent) is placing outgoing call.\n", agentvar); } } else { res = -1; if (!nowarnings) ast_log(LOG_WARNING, "There is no callerid on that call, so I can't figure out which agent (if it's an agent) is placing outgoing call.\n"); } if (res) { if (exitifnoagentid) return res; } return 0; }
static char* agents_show | ( | struct ast_cli_entry * | e, |
int | cmd, | ||
struct ast_cli_args * | a | ||
) | [static] |
Show agents in cli.
< Number of agents configured
< Number of online agents
< Number of offline agents
Definition at line 1822 of file chan_agent.c.
References agent_pvt::acknowledged, agent_pvt::agent, ast_cli_args::argc, ast_bridged_channel(), ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, AST_MAX_BUF, ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), ast_tvdiff_ms(), ast_tvnow(), agent_pvt::chan, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::moh, ast_channel::name, agent_pvt::name, agent_pvt::owner, agent_pvt::pending, powerof(), and ast_cli_entry::usage.
{ struct agent_pvt *p; char username[AST_MAX_BUF]; char location[AST_MAX_BUF] = ""; char talkingto[AST_MAX_BUF] = ""; char music[AST_MAX_BUF]; int count_agents = 0; /*!< Number of agents configured */ int online_agents = 0; /*!< Number of online agents */ int offline_agents = 0; /*!< Number of offline agents */ switch (cmd) { case CLI_INIT: e->command = "agent show"; e->usage = "Usage: agent show\n" " Provides summary information on agents.\n"; return NULL; case CLI_GENERATE: return NULL; } if (a->argc != 2) return CLI_SHOWUSAGE; AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { ast_mutex_lock(&p->lock); if (p->pending) { if (p->group) ast_cli(a->fd, "-- Pending call to group %d\n", powerof(p->group)); else ast_cli(a->fd, "-- Pending call to agent %s\n", p->agent); } else { if (!ast_strlen_zero(p->name)) snprintf(username, sizeof(username), "(%s) ", p->name); else username[0] = '\0'; if (p->chan) { snprintf(location, sizeof(location), "logged in on %s", p->chan->name); if (p->owner && ast_bridged_channel(p->owner)) snprintf(talkingto, sizeof(talkingto), " talking to %s", ast_bridged_channel(p->owner)->name); else strcpy(talkingto, " is idle"); online_agents++; } else if (!ast_strlen_zero(p->loginchan)) { if (ast_tvdiff_ms(ast_tvnow(), p->lastdisc) > 0 || !(p->lastdisc.tv_sec)) snprintf(location, sizeof(location) - 20, "available at '%s'", p->loginchan); else snprintf(location, sizeof(location) - 20, "wrapping up at '%s'", p->loginchan); talkingto[0] = '\0'; online_agents++; if (p->acknowledged) strncat(location, " (Confirmed)", sizeof(location) - strlen(location) - 1); } else { strcpy(location, "not logged in"); talkingto[0] = '\0'; offline_agents++; } if (!ast_strlen_zero(p->moh)) snprintf(music, sizeof(music), " (musiconhold is '%s')", p->moh); ast_cli(a->fd, "%-12.12s %s%s%s%s\n", p->agent, username, location, talkingto, music); count_agents++; } ast_mutex_unlock(&p->lock); } AST_LIST_UNLOCK(&agents); if ( !count_agents ) ast_cli(a->fd, "No Agents are configured in %s\n",config); else ast_cli(a->fd, "%d agents configured [%d online , %d offline]\n",count_agents, online_agents, offline_agents); ast_cli(a->fd, "\n"); return CLI_SUCCESS; }
static char* agents_show_online | ( | struct ast_cli_entry * | e, |
int | cmd, | ||
struct ast_cli_args * | a | ||
) | [static] |
Definition at line 1900 of file chan_agent.c.
References agent_pvt::acknowledged, agent_pvt::agent, ast_cli_args::argc, ast_bridged_channel(), ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, AST_MAX_BUF, ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), agent_pvt::chan, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::moh, ast_channel::name, agent_pvt::name, agent_pvt::owner, and ast_cli_entry::usage.
{ struct agent_pvt *p; char username[AST_MAX_BUF]; char location[AST_MAX_BUF] = ""; char talkingto[AST_MAX_BUF] = ""; char music[AST_MAX_BUF]; int count_agents = 0; /* Number of agents configured */ int online_agents = 0; /* Number of online agents */ int agent_status = 0; /* 0 means offline, 1 means online */ switch (cmd) { case CLI_INIT: e->command = "agent show online"; e->usage = "Usage: agent show online\n" " Provides a list of all online agents.\n"; return NULL; case CLI_GENERATE: return NULL; } if (a->argc != 3) return CLI_SHOWUSAGE; AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { agent_status = 0; /* reset it to offline */ ast_mutex_lock(&p->lock); if (!ast_strlen_zero(p->name)) snprintf(username, sizeof(username), "(%s) ", p->name); else username[0] = '\0'; if (p->chan) { snprintf(location, sizeof(location), "logged in on %s", p->chan->name); if (p->owner && ast_bridged_channel(p->owner)) snprintf(talkingto, sizeof(talkingto), " talking to %s", ast_bridged_channel(p->owner)->name); else strcpy(talkingto, " is idle"); agent_status = 1; online_agents++; } else if (!ast_strlen_zero(p->loginchan)) { snprintf(location, sizeof(location) - 20, "available at '%s'", p->loginchan); talkingto[0] = '\0'; agent_status = 1; online_agents++; if (p->acknowledged) strncat(location, " (Confirmed)", sizeof(location) - strlen(location) - 1); } if (!ast_strlen_zero(p->moh)) snprintf(music, sizeof(music), " (musiconhold is '%s')", p->moh); if (agent_status) ast_cli(a->fd, "%-12.12s %s%s%s%s\n", p->agent, username, location, talkingto, music); count_agents++; ast_mutex_unlock(&p->lock); } AST_LIST_UNLOCK(&agents); if (!count_agents) ast_cli(a->fd, "No Agents are configured in %s\n", config); else ast_cli(a->fd, "%d agents online\n", online_agents); ast_cli(a->fd, "\n"); return CLI_SUCCESS; }
static int check_availability | ( | struct agent_pvt * | newlyavailable, |
int | needlock | ||
) | [static] |
Definition at line 1355 of file chan_agent.c.
References agent_pvt::abouttograb, agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_cleanup(), agent_new(), ast_channel_masquerade(), ast_copy_string(), ast_debug, AST_FLAG_ZOMBIE, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_setstate(), AST_STATE_DOWN, AST_STATE_UP, ast_streamfile(), ast_waitstream(), agent_pvt::chan, ast_channel::context, agent_pvt::group, ast_channel::language, agent_pvt::lock, ast_channel::name, agent_pvt::owner, and agent_pvt::pending.
Referenced by login_exec().
{ struct ast_channel *chan=NULL, *parent=NULL; struct agent_pvt *p; int res; ast_debug(1, "Checking availability of '%s'\n", newlyavailable->agent); if (needlock) AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { if (p == newlyavailable) { continue; } ast_mutex_lock(&p->lock); if (!p->abouttograb && p->pending && ((p->group && (newlyavailable->group & p->group)) || !strcmp(p->agent, newlyavailable->agent))) { ast_debug(1, "Call '%s' looks like a winner for agent '%s'\n", p->owner->name, newlyavailable->agent); /* We found a pending call, time to merge */ chan = agent_new(newlyavailable, AST_STATE_DOWN); parent = p->owner; p->abouttograb = 1; ast_mutex_unlock(&p->lock); break; } ast_mutex_unlock(&p->lock); } if (needlock) AST_LIST_UNLOCK(&agents); if (parent && chan) { if (newlyavailable->ackcall > 1) { /* Don't do beep here */ res = 0; } else { ast_debug(3, "Playing beep, lang '%s'\n", newlyavailable->chan->language); res = ast_streamfile(newlyavailable->chan, beep, newlyavailable->chan->language); ast_debug(3, "Played beep, result '%d'\n", res); if (!res) { res = ast_waitstream(newlyavailable->chan, ""); ast_debug(1, "Waited for stream, result '%d'\n", res); } } if (!res) { /* Note -- parent may have disappeared */ if (p->abouttograb) { newlyavailable->acknowledged = 1; /* Safe -- agent lock already held */ ast_setstate(parent, AST_STATE_UP); ast_setstate(chan, AST_STATE_UP); ast_copy_string(parent->context, chan->context, sizeof(parent->context)); /* Go ahead and mark the channel as a zombie so that masquerade will destroy it for us, and we need not call ast_hangup */ ast_set_flag(chan, AST_FLAG_ZOMBIE); ast_channel_masquerade(parent, chan); p->abouttograb = 0; } else { ast_debug(1, "Sneaky, parent disappeared in the mean time...\n"); agent_cleanup(newlyavailable); } } else { ast_debug(1, "Ugh... Agent hung up at exactly the wrong time\n"); agent_cleanup(newlyavailable); } } return 0; }
static int check_beep | ( | struct agent_pvt * | newlyavailable, |
int | needlock | ||
) | [static] |
Definition at line 1420 of file chan_agent.c.
References agent_pvt::abouttograb, agent_pvt::agent, ast_debug, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_streamfile(), ast_waitstream(), agent_pvt::chan, agent_pvt::group, ast_channel::language, agent_pvt::lock, ast_channel::name, agent_pvt::owner, and agent_pvt::pending.
Referenced by login_exec().
{ struct agent_pvt *p; int res=0; ast_debug(1, "Checking beep availability of '%s'\n", newlyavailable->agent); if (needlock) AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { if (p == newlyavailable) { continue; } ast_mutex_lock(&p->lock); if (!p->abouttograb && p->pending && ((p->group && (newlyavailable->group & p->group)) || !strcmp(p->agent, newlyavailable->agent))) { ast_debug(1, "Call '%s' looks like a would-be winner for agent '%s'\n", p->owner->name, newlyavailable->agent); ast_mutex_unlock(&p->lock); break; } ast_mutex_unlock(&p->lock); } if (needlock) AST_LIST_UNLOCK(&agents); if (p) { ast_mutex_unlock(&newlyavailable->lock); ast_debug(3, "Playing beep, lang '%s'\n", newlyavailable->chan->language); res = ast_streamfile(newlyavailable->chan, beep, newlyavailable->chan->language); ast_debug(1, "Played beep, result '%d'\n", res); if (!res) { res = ast_waitstream(newlyavailable->chan, ""); ast_debug(1, "Waited for stream, result '%d'\n", res); } ast_mutex_lock(&newlyavailable->lock); } return res; }
static char * complete_agent_logoff_cmd | ( | const char * | line, |
const char * | word, | ||
int | pos, | ||
int | state | ||
) | [static] |
Definition at line 1795 of file chan_agent.c.
References agent_pvt::agent, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, AST_MAX_AGENT, ast_strdup, len(), agent_pvt::loginstart, and agent_pvt::name.
Referenced by agent_logoff_cmd().
{ char *ret = NULL; if (pos == 2) { struct agent_pvt *p; char name[AST_MAX_AGENT]; int which = 0, len = strlen(word); AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { snprintf(name, sizeof(name), "Agent/%s", p->agent); if (!strncasecmp(word, name, len) && p->loginstart && ++which > state) { ret = ast_strdup(name); break; } } AST_LIST_UNLOCK(&agents); } else if (pos == 3 && state == 0) return ast_strdup("soft"); return ret; }
static void dump_agents | ( | void | ) | [static] |
Dump AgentCallbackLogin agents to the ASTdb database for persistence.
Definition at line 2367 of file chan_agent.c.
References agent_pvt::agent, ast_db_del(), ast_db_put(), ast_debug, AST_LIST_TRAVERSE, ast_log(), ast_strlen_zero(), buf, agent_pvt::chan, LOG_WARNING, agent_pvt::logincallerid, and agent_pvt::loginchan.
Referenced by agent_hangup(), and agent_logoff_maintenance().
{ struct agent_pvt *cur_agent = NULL; char buf[256]; AST_LIST_TRAVERSE(&agents, cur_agent, list) { if (cur_agent->chan) continue; if (!ast_strlen_zero(cur_agent->loginchan)) { snprintf(buf, sizeof(buf), "%s;%s", cur_agent->loginchan, cur_agent->logincallerid); if (ast_db_put(pa_family, cur_agent->agent, buf)) ast_log(LOG_WARNING, "failed to create persistent entry in ASTdb for %s!\n", buf); else ast_debug(1, "Saved Agent: %s on %s\n", cur_agent->agent, cur_agent->loginchan); } else { /* Delete - no agent or there is an error */ ast_db_del(pa_family, cur_agent->agent); } } }
static struct agent_pvt* find_agent | ( | char * | agentid | ) | [static, read] |
Definition at line 2490 of file chan_agent.c.
References agent_pvt::agent, and AST_LIST_TRAVERSE.
Referenced by function_agent().
{ struct agent_pvt *cur; AST_LIST_TRAVERSE(&agents, cur, list) { if (!strcmp(cur->agent, agentid)) break; } return cur; }
static int function_agent | ( | struct ast_channel * | chan, |
const char * | cmd, | ||
char * | data, | ||
char * | buf, | ||
size_t | len | ||
) | [static] |
Definition at line 2502 of file chan_agent.c.
References agent_pvt::agent, AST_APP_ARG, ast_channel_lock, ast_channel_unlock, ast_copy_string(), AST_DECLARE_APP_ARGS, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), AST_NONSTANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), agent_pvt::chan, find_agent(), LOG_WARNING, agent_pvt::loginchan, agent_pvt::moh, ast_channel::name, agent_pvt::name, parse(), agent_pvt::password, and status.
{ char *parse; AST_DECLARE_APP_ARGS(args, AST_APP_ARG(agentid); AST_APP_ARG(item); ); char *tmp; struct agent_pvt *agent; buf[0] = '\0'; if (ast_strlen_zero(data)) { ast_log(LOG_WARNING, "The AGENT function requires an argument - agentid!\n"); return -1; } parse = ast_strdupa(data); AST_NONSTANDARD_APP_ARGS(args, parse, ':'); if (!args.item) args.item = "status"; AST_LIST_LOCK(&agents); if (!(agent = find_agent(args.agentid))) { AST_LIST_UNLOCK(&agents); ast_log(LOG_WARNING, "Agent '%s' not found!\n", args.agentid); return -1; } if (!strcasecmp(args.item, "status")) { char *status = "LOGGEDOUT"; if (agent->chan || !ast_strlen_zero(agent->loginchan)) status = "LOGGEDIN"; ast_copy_string(buf, status, len); } else if (!strcasecmp(args.item, "password")) ast_copy_string(buf, agent->password, len); else if (!strcasecmp(args.item, "name")) ast_copy_string(buf, agent->name, len); else if (!strcasecmp(args.item, "mohclass")) ast_copy_string(buf, agent->moh, len); else if (!strcasecmp(args.item, "channel")) { if (agent->chan) { ast_channel_lock(agent->chan); ast_copy_string(buf, agent->chan->name, len); ast_channel_unlock(agent->chan); tmp = strrchr(buf, '-'); if (tmp) *tmp = '\0'; } } else if (!strcasecmp(args.item, "exten")) ast_copy_string(buf, agent->loginchan, len); AST_LIST_UNLOCK(&agents); return 0; }
static int load_module | ( | void | ) | [static] |
Initialize the Agents module. This function is being called by Asterisk when loading the module. Among other things it registers applications, cli commands and reads the cofiguration file.
Definition at line 2574 of file chan_agent.c.
References action_agent_logoff(), action_agents(), agent_function, agent_tech, agentmonitoroutgoing_exec(), ARRAY_LEN, ast_channel_register(), ast_cli_register_multiple(), ast_custom_function_register, ast_log(), ast_manager_register2(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_register_application_xml, cli_agents, EVENT_FLAG_AGENT, LOG_ERROR, login_exec(), read_agent_config(), and reload_agents().
{ /* Make sure we can register our agent channel type */ if (ast_channel_register(&agent_tech)) { ast_log(LOG_ERROR, "Unable to register channel class 'Agent'\n"); return AST_MODULE_LOAD_FAILURE; } /* Read in the config */ if (!read_agent_config(0)) return AST_MODULE_LOAD_DECLINE; if (persistent_agents) reload_agents(); /* Dialplan applications */ ast_register_application_xml(app, login_exec); ast_register_application_xml(app3, agentmonitoroutgoing_exec); /* Manager commands */ ast_manager_register2("Agents", EVENT_FLAG_AGENT, action_agents, "Lists agents and their status", mandescr_agents); ast_manager_register2("AgentLogoff", EVENT_FLAG_AGENT, action_agent_logoff, "Sets an agent as no longer logged in", mandescr_agent_logoff); /* CLI Commands */ ast_cli_register_multiple(cli_agents, ARRAY_LEN(cli_agents)); /* Dialplan Functions */ ast_custom_function_register(&agent_function); return AST_MODULE_LOAD_SUCCESS; }
static int login_exec | ( | struct ast_channel * | chan, |
void * | data | ||
) | [static] |
Log in agent application.
Called by the AgentLogin application (from the dial plan).
chan | |
data |
Definition at line 1986 of file chan_agent.c.
References ast_channel::_state, agent_pvt::acceptdtmf, agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_ack_sleep(), agent_cont_sleep(), AGENT_FLAG_ACCEPTDTMF, AGENT_FLAG_ACKCALL, AGENT_FLAG_AUTOLOGOFF, AGENT_FLAG_ENDDTMF, AGENT_FLAG_WRAPUPTIME, agent_pvt::app_complete_cond, agent_pvt::app_lock, agent_pvt::app_lock_flag, ast_answer(), AST_APP_ARG, ast_app_getdata(), ast_best_codec(), ast_channel_lock, ast_channel_unlock, ast_cond_destroy(), ast_cond_wait(), AST_CONTROL_HOLD, ast_copy_string(), ast_debug, AST_DECLARE_APP_ARGS, AST_DEVICE_NOT_INUSE, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), ast_free, ast_getformatname(), ast_indicate_data(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), AST_MAX_AGENT, AST_MAX_FILENAME_LEN, ast_module_user_add, ast_module_user_remove, ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), ast_queue_log(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_set_flag, ast_set_read_format(), ast_set_write_format(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_strdupa, ast_streamfile(), ast_strlen_zero(), ast_true(), ast_tv(), ast_tvdiff_ms(), ast_tvnow(), ast_verb, ast_waitstream(), agent_pvt::autologoff, ast_channel::cdr, agent_pvt::chan, ast_cdr::channel, check_availability(), check_beep(), agent_pvt::dead, agent_pvt::deferlogoff, agent_pvt::enddtmf, EVENT_FLAG_AGENT, ast_channel::language, agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, LOG_WARNING, agent_pvt::logincallerid, agent_pvt::loginchan, agent_pvt::loginstart, manager_event, maxlogintries, agent_pvt::moh, ast_channel::name, ast_channel::nativeformats, agent_pvt::owner, parse(), pass, agent_pvt::password, pbx_builtin_getvar_helper(), agent_pvt::pending, ast_channel::readformat, S_OR, ast_channel::uniqueid, update_cdr, updatecdr, agent_pvt::wrapuptime, and ast_channel::writeformat.
Referenced by load_module().
{ int res=0; int tries = 0; int max_login_tries = maxlogintries; struct agent_pvt *p; struct ast_module_user *u; int login_state = 0; char user[AST_MAX_AGENT] = ""; char pass[AST_MAX_AGENT]; char agent[AST_MAX_AGENT] = ""; char xpass[AST_MAX_AGENT] = ""; char *errmsg; char *parse; AST_DECLARE_APP_ARGS(args, AST_APP_ARG(agent_id); AST_APP_ARG(options); AST_APP_ARG(extension); ); const char *tmpoptions = NULL; int play_announcement = 1; char agent_goodbye[AST_MAX_FILENAME_LEN]; int update_cdr = updatecdr; char *filename = "agent-loginok"; u = ast_module_user_add(chan); parse = ast_strdupa(data); AST_STANDARD_APP_ARGS(args, parse); ast_copy_string(agent_goodbye, agentgoodbye, sizeof(agent_goodbye)); ast_channel_lock(chan); /* Set Channel Specific Login Overrides */ if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTLMAXLOGINTRIES"))) { max_login_tries = atoi(pbx_builtin_getvar_helper(chan, "AGENTMAXLOGINTRIES")); if (max_login_tries < 0) max_login_tries = 0; tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTMAXLOGINTRIES"); ast_verb(3, "Saw variable AGENTMAXLOGINTRIES=%s, setting max_login_tries to: %d on Channel '%s'.\n",tmpoptions,max_login_tries,chan->name); } if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTUPDATECDR"))) { if (ast_true(pbx_builtin_getvar_helper(chan, "AGENTUPDATECDR"))) update_cdr = 1; else update_cdr = 0; tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTUPDATECDR"); ast_verb(3, "Saw variable AGENTUPDATECDR=%s, setting update_cdr to: %d on Channel '%s'.\n",tmpoptions,update_cdr,chan->name); } if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTGOODBYE"))) { strcpy(agent_goodbye, pbx_builtin_getvar_helper(chan, "AGENTGOODBYE")); tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTGOODBYE"); ast_verb(3, "Saw variable AGENTGOODBYE=%s, setting agent_goodbye to: %s on Channel '%s'.\n",tmpoptions,agent_goodbye,chan->name); } ast_channel_unlock(chan); /* End Channel Specific Login Overrides */ if (!ast_strlen_zero(args.options)) { if (strchr(args.options, 's')) { play_announcement = 0; } } if (chan->_state != AST_STATE_UP) res = ast_answer(chan); if (!res) { if (!ast_strlen_zero(args.agent_id)) ast_copy_string(user, args.agent_id, AST_MAX_AGENT); else res = ast_app_getdata(chan, "agent-user", user, sizeof(user) - 1, 0); } while (!res && (max_login_tries==0 || tries < max_login_tries)) { tries++; /* Check for password */ AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { if (!strcmp(p->agent, user) && !p->pending) ast_copy_string(xpass, p->password, sizeof(xpass)); } AST_LIST_UNLOCK(&agents); if (!res) { if (!ast_strlen_zero(xpass)) res = ast_app_getdata(chan, "agent-pass", pass, sizeof(pass) - 1, 0); else pass[0] = '\0'; } errmsg = "agent-incorrect"; #if 0 ast_log(LOG_NOTICE, "user: %s, pass: %s\n", user, pass); #endif /* Check again for accuracy */ AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { int unlock_channel = 1; ast_channel_lock(chan); ast_mutex_lock(&p->lock); if (!strcmp(p->agent, user) && !strcmp(p->password, pass) && !p->pending) { login_state = 1; /* Successful Login */ /* Ensure we can't be gotten until we're done */ p->lastdisc = ast_tvnow(); p->lastdisc.tv_sec++; /* Set Channel Specific Agent Overrides */ if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTACKCALL"))) { if (!strcasecmp(pbx_builtin_getvar_helper(chan, "AGENTACKCALL"), "always")) p->ackcall = 2; else if (ast_true(pbx_builtin_getvar_helper(chan, "AGENTACKCALL"))) p->ackcall = 1; else p->ackcall = 0; tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTACKCALL"); ast_verb(3, "Saw variable AGENTACKCALL=%s, setting ackcall to: %d for Agent '%s'.\n", tmpoptions, p->ackcall, p->agent); ast_set_flag(p, AGENT_FLAG_ACKCALL); } else { p->ackcall = ackcall; } if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTAUTOLOGOFF"))) { p->autologoff = atoi(pbx_builtin_getvar_helper(chan, "AGENTAUTOLOGOFF")); if (p->autologoff < 0) p->autologoff = 0; tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTAUTOLOGOFF"); ast_verb(3, "Saw variable AGENTAUTOLOGOFF=%s, setting autologff to: %d for Agent '%s'.\n", tmpoptions, p->autologoff, p->agent); ast_set_flag(p, AGENT_FLAG_AUTOLOGOFF); } else { p->autologoff = autologoff; } if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTWRAPUPTIME"))) { p->wrapuptime = atoi(pbx_builtin_getvar_helper(chan, "AGENTWRAPUPTIME")); if (p->wrapuptime < 0) p->wrapuptime = 0; tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTWRAPUPTIME"); ast_verb(3, "Saw variable AGENTWRAPUPTIME=%s, setting wrapuptime to: %d for Agent '%s'.\n", tmpoptions, p->wrapuptime, p->agent); ast_set_flag(p, AGENT_FLAG_WRAPUPTIME); } else { p->wrapuptime = wrapuptime; } tmpoptions = pbx_builtin_getvar_helper(chan, "AGENTACCEPTDTMF"); if (!ast_strlen_zero(tmpoptions)) { p->acceptdtmf = *tmpoptions; ast_verb(3, "Saw variable AGENTACCEPTDTMF=%s, setting acceptdtmf to: %c for Agent '%s'.\n", tmpoptions, p->acceptdtmf, p->agent); ast_set_flag(p, AGENT_FLAG_ACCEPTDTMF); } tmpoptions = pbx_builtin_getvar_helper(chan, "AGENTENDDTMF"); if (!ast_strlen_zero(tmpoptions)) { p->enddtmf = *tmpoptions; ast_verb(3, "Saw variable AGENTENDDTMF=%s, setting enddtmf to: %c for Agent '%s'.\n", tmpoptions, p->enddtmf, p->agent); ast_set_flag(p, AGENT_FLAG_ENDDTMF); } ast_channel_unlock(chan); unlock_channel = 0; /* End Channel Specific Agent Overrides */ if (!p->chan) { long logintime; snprintf(agent, sizeof(agent), "Agent/%s", p->agent); p->loginchan[0] = '\0'; p->logincallerid[0] = '\0'; p->acknowledged = 0; ast_mutex_unlock(&p->lock); AST_LIST_UNLOCK(&agents); if( !res && play_announcement==1 ) res = ast_streamfile(chan, filename, chan->language); if (!res) ast_waitstream(chan, ""); AST_LIST_LOCK(&agents); ast_mutex_lock(&p->lock); if (!res) { res = ast_set_read_format(chan, ast_best_codec(chan->nativeformats)); if (res) ast_log(LOG_WARNING, "Unable to set read format to %d\n", ast_best_codec(chan->nativeformats)); } if (!res) { res = ast_set_write_format(chan, ast_best_codec(chan->nativeformats)); if (res) ast_log(LOG_WARNING, "Unable to set write format to %d\n", ast_best_codec(chan->nativeformats)); } /* Check once more just in case */ if (p->chan) res = -1; if (!res) { ast_indicate_data(chan, AST_CONTROL_HOLD, S_OR(p->moh, NULL), !ast_strlen_zero(p->moh) ? strlen(p->moh) + 1 : 0); if (p->loginstart == 0) time(&p->loginstart); manager_event(EVENT_FLAG_AGENT, "Agentlogin", "Agent: %s\r\n" "Channel: %s\r\n" "Uniqueid: %s\r\n", p->agent, chan->name, chan->uniqueid); if (update_cdr && chan->cdr) snprintf(chan->cdr->channel, sizeof(chan->cdr->channel), "Agent/%s", p->agent); ast_queue_log("NONE", chan->uniqueid, agent, "AGENTLOGIN", "%s", chan->name); ast_verb(2, "Agent '%s' logged in (format %s/%s)\n", p->agent, ast_getformatname(chan->readformat), ast_getformatname(chan->writeformat)); /* Login this channel and wait for it to go away */ p->chan = chan; if (p->ackcall > 1) check_beep(p, 0); else check_availability(p, 0); ast_mutex_unlock(&p->lock); AST_LIST_UNLOCK(&agents); ast_devstate_changed(AST_DEVICE_NOT_INUSE, "Agent/%s", p->agent); while (res >= 0) { ast_mutex_lock(&p->lock); if (p->deferlogoff && p->chan) { ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT); p->deferlogoff = 0; } if (p->chan != chan) res = -1; ast_mutex_unlock(&p->lock); /* Yield here so other interested threads can kick in. */ sched_yield(); if (res) break; AST_LIST_LOCK(&agents); ast_mutex_lock(&p->lock); if (p->lastdisc.tv_sec) { if (ast_tvdiff_ms(ast_tvnow(), p->lastdisc) > 0) { ast_debug(1, "Wrapup time for %s expired!\n", p->agent); p->lastdisc = ast_tv(0, 0); ast_devstate_changed(AST_DEVICE_NOT_INUSE, "Agent/%s", p->agent); if (p->ackcall > 1) check_beep(p, 0); else check_availability(p, 0); } } ast_mutex_unlock(&p->lock); AST_LIST_UNLOCK(&agents); /* Synchronize channel ownership between call to agent and itself. */ ast_mutex_lock(&p->app_lock); if (p->app_lock_flag == 1) { ast_cond_wait(&p->app_complete_cond, &p->app_lock); } ast_mutex_unlock(&p->app_lock); ast_mutex_lock(&p->lock); ast_mutex_unlock(&p->lock); if (p->ackcall > 1) res = agent_ack_sleep(p); else res = ast_safe_sleep_conditional( chan, 1000, agent_cont_sleep, p ); if ((p->ackcall > 1) && (res == 1)) { AST_LIST_LOCK(&agents); ast_mutex_lock(&p->lock); check_availability(p, 0); ast_mutex_unlock(&p->lock); AST_LIST_UNLOCK(&agents); res = 0; } sched_yield(); } ast_mutex_lock(&p->lock); if (res && p->owner) ast_log(LOG_WARNING, "Huh? We broke out when there was still an owner?\n"); /* Log us off if appropriate */ if (p->chan == chan) { p->chan = NULL; } p->acknowledged = 0; logintime = time(NULL) - p->loginstart; p->loginstart = 0; ast_mutex_unlock(&p->lock); manager_event(EVENT_FLAG_AGENT, "Agentlogoff", "Agent: %s\r\n" "Logintime: %ld\r\n" "Uniqueid: %s\r\n", p->agent, logintime, chan->uniqueid); ast_queue_log("NONE", chan->uniqueid, agent, "AGENTLOGOFF", "%s|%ld", chan->name, logintime); ast_verb(2, "Agent '%s' logged out\n", p->agent); /* If there is no owner, go ahead and kill it now */ ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent); if (p->dead && !p->owner) { ast_mutex_destroy(&p->lock); ast_mutex_destroy(&p->app_lock); ast_cond_destroy(&p->app_complete_cond); ast_free(p); } } else { ast_mutex_unlock(&p->lock); p = NULL; } res = -1; } else { ast_mutex_unlock(&p->lock); errmsg = "agent-alreadyon"; p = NULL; } break; } ast_mutex_unlock(&p->lock); if (unlock_channel) { ast_channel_unlock(chan); } } if (!p) AST_LIST_UNLOCK(&agents); if (!res && (max_login_tries==0 || tries < max_login_tries)) res = ast_app_getdata(chan, errmsg, user, sizeof(user) - 1, 0); } if (!res) res = ast_safe_sleep(chan, 500); ast_module_user_remove(u); return -1; }
static force_inline int powerof | ( | unsigned int | d | ) | [static] |
Definition at line 1552 of file chan_agent.c.
Referenced by agents_show().
{ int x = ffs(d); if (x) return x - 1; return 0; }
static int read_agent_config | ( | int | reload | ) | [static] |
Read configuration data. The file named agents.conf.
Definition at line 1185 of file chan_agent.c.
References add_agent(), agent_pvt::app_complete_cond, agent_pvt::app_lock, ast_category_browse(), ast_cond_destroy(), ast_config_destroy(), ast_config_load, ast_copy_string(), ast_free, ast_get_group(), AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log(), ast_mutex_destroy(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_strlen_zero(), ast_true(), ast_variable_browse(), ast_variable_retrieve(), agent_pvt::chan, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, agent_pvt::dead, agent_pvt::lock, LOG_ERROR, LOG_NOTICE, ast_variable::name, ast_variable::next, agent_pvt::owner, secret, and ast_variable::value.
Referenced by load_module(), and reload().
{ struct ast_config *cfg; struct ast_config *ucfg; struct ast_variable *v; struct agent_pvt *p; const char *general_val; const char *catname; const char *hasagent; int genhasagent; struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 }; group = 0; autologoff = 0; wrapuptime = 0; ackcall = 0; endcall = 1; cfg = ast_config_load(config, config_flags); if (!cfg) { ast_log(LOG_NOTICE, "No agent configuration found -- agent support disabled\n"); return 0; } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) { return -1; } else if (cfg == CONFIG_STATUS_FILEINVALID) { ast_log(LOG_ERROR, "%s contains a parsing error. Aborting\n", config); return 0; } if ((ucfg = ast_config_load("users.conf", config_flags))) { if (ucfg == CONFIG_STATUS_FILEUNCHANGED) { ucfg = NULL; } else if (ucfg == CONFIG_STATUS_FILEINVALID) { ast_log(LOG_ERROR, "users.conf contains a parsing error. Aborting\n"); return 0; } } AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { p->dead = 1; } strcpy(moh, "default"); /* set the default recording values */ recordagentcalls = 0; strcpy(recordformat, "wav"); strcpy(recordformatext, "wav"); urlprefix[0] = '\0'; savecallsin[0] = '\0'; /* Read in [general] section for persistence */ if ((general_val = ast_variable_retrieve(cfg, "general", "persistentagents"))) persistent_agents = ast_true(general_val); multiplelogin = ast_true(ast_variable_retrieve(cfg, "general", "multiplelogin")); /* Read in the [agents] section */ v = ast_variable_browse(cfg, "agents"); while(v) { /* Create the interface list */ if (!strcasecmp(v->name, "agent")) { add_agent(v->value, 0); } else if (!strcasecmp(v->name, "group")) { group = ast_get_group(v->value); } else if (!strcasecmp(v->name, "autologoff")) { autologoff = atoi(v->value); if (autologoff < 0) autologoff = 0; } else if (!strcasecmp(v->name, "ackcall")) { if (!strcasecmp(v->value, "always")) ackcall = 2; else if (ast_true(v->value)) ackcall = 1; else ackcall = 0; } else if (!strcasecmp(v->name, "endcall")) { endcall = ast_true(v->value); } else if (!strcasecmp(v->name, "acceptdtmf")) { acceptdtmf = *(v->value); ast_log(LOG_NOTICE, "Set acceptdtmf to %c\n", acceptdtmf); } else if (!strcasecmp(v->name, "enddtmf")) { enddtmf = *(v->value); } else if (!strcasecmp(v->name, "wrapuptime")) { wrapuptime = atoi(v->value); if (wrapuptime < 0) wrapuptime = 0; } else if (!strcasecmp(v->name, "maxlogintries") && !ast_strlen_zero(v->value)) { maxlogintries = atoi(v->value); if (maxlogintries < 0) maxlogintries = 0; } else if (!strcasecmp(v->name, "goodbye") && !ast_strlen_zero(v->value)) { strcpy(agentgoodbye,v->value); } else if (!strcasecmp(v->name, "musiconhold")) { ast_copy_string(moh, v->value, sizeof(moh)); } else if (!strcasecmp(v->name, "updatecdr")) { if (ast_true(v->value)) updatecdr = 1; else updatecdr = 0; } else if (!strcasecmp(v->name, "autologoffunavail")) { if (ast_true(v->value)) autologoffunavail = 1; else autologoffunavail = 0; } else if (!strcasecmp(v->name, "recordagentcalls")) { recordagentcalls = ast_true(v->value); } else if (!strcasecmp(v->name, "recordformat")) { ast_copy_string(recordformat, v->value, sizeof(recordformat)); if (!strcasecmp(v->value, "wav49")) strcpy(recordformatext, "WAV"); else ast_copy_string(recordformatext, v->value, sizeof(recordformatext)); } else if (!strcasecmp(v->name, "urlprefix")) { ast_copy_string(urlprefix, v->value, sizeof(urlprefix)); if (urlprefix[strlen(urlprefix) - 1] != '/') strncat(urlprefix, "/", sizeof(urlprefix) - strlen(urlprefix) - 1); } else if (!strcasecmp(v->name, "savecallsin")) { if (v->value[0] == '/') ast_copy_string(savecallsin, v->value, sizeof(savecallsin)); else snprintf(savecallsin, sizeof(savecallsin) - 2, "/%s", v->value); if (savecallsin[strlen(savecallsin) - 1] != '/') strncat(savecallsin, "/", sizeof(savecallsin) - strlen(savecallsin) - 1); } else if (!strcasecmp(v->name, "custom_beep")) { ast_copy_string(beep, v->value, sizeof(beep)); } v = v->next; } if (ucfg) { genhasagent = ast_true(ast_variable_retrieve(ucfg, "general", "hasagent")); catname = ast_category_browse(ucfg, NULL); while(catname) { if (strcasecmp(catname, "general")) { hasagent = ast_variable_retrieve(ucfg, catname, "hasagent"); if (ast_true(hasagent) || (!hasagent && genhasagent)) { char tmp[256]; const char *fullname = ast_variable_retrieve(ucfg, catname, "fullname"); const char *secret = ast_variable_retrieve(ucfg, catname, "secret"); if (!fullname) fullname = ""; if (!secret) secret = ""; snprintf(tmp, sizeof(tmp), "%s,%s,%s", catname, secret,fullname); add_agent(tmp, 0); } } catname = ast_category_browse(ucfg, catname); } ast_config_destroy(ucfg); } AST_LIST_TRAVERSE_SAFE_BEGIN(&agents, p, list) { if (p->dead) { AST_LIST_REMOVE_CURRENT(list); /* Destroy if appropriate */ if (!p->owner) { if (!p->chan) { ast_mutex_destroy(&p->lock); ast_mutex_destroy(&p->app_lock); ast_cond_destroy(&p->app_complete_cond); ast_free(p); } else { /* Cause them to hang up */ ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT); } } } } AST_LIST_TRAVERSE_SAFE_END; AST_LIST_UNLOCK(&agents); ast_config_destroy(cfg); return 1; }
static int reload | ( | void | ) | [static] |
Definition at line 2603 of file chan_agent.c.
References read_agent_config(), and reload_agents().
{ if (!read_agent_config(1)) { if (persistent_agents) reload_agents(); } return 0; }
static void reload_agents | ( | void | ) | [static] |
Reload the persistent agents from astdb.
Definition at line 2392 of file chan_agent.c.
References agent_pvt::agent, ast_copy_string(), ast_db_del(), ast_db_freetree(), ast_db_get(), ast_db_gettree(), ast_debug, AST_DEVICE_UNKNOWN, ast_devstate_changed(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_db_entry::key, agent_pvt::lock, LOG_NOTICE, agent_pvt::logincallerid, agent_pvt::loginchan, agent_pvt::loginstart, ast_db_entry::next, parse(), set_agentbycallerid(), and strsep().
Referenced by load_module(), and reload().
{ char *agent_num; struct ast_db_entry *db_tree; struct ast_db_entry *entry; struct agent_pvt *cur_agent; char agent_data[256]; char *parse; char *agent_chan; char *agent_callerid; db_tree = ast_db_gettree(pa_family, NULL); AST_LIST_LOCK(&agents); for (entry = db_tree; entry; entry = entry->next) { agent_num = entry->key + strlen(pa_family) + 2; AST_LIST_TRAVERSE(&agents, cur_agent, list) { ast_mutex_lock(&cur_agent->lock); if (strcmp(agent_num, cur_agent->agent) == 0) break; ast_mutex_unlock(&cur_agent->lock); } if (!cur_agent) { ast_db_del(pa_family, agent_num); continue; } else ast_mutex_unlock(&cur_agent->lock); if (!ast_db_get(pa_family, agent_num, agent_data, sizeof(agent_data)-1)) { ast_debug(1, "Reload Agent from AstDB: %s on %s\n", cur_agent->agent, agent_data); parse = agent_data; agent_chan = strsep(&parse, ";"); agent_callerid = strsep(&parse, ";"); ast_copy_string(cur_agent->loginchan, agent_chan, sizeof(cur_agent->loginchan)); if (agent_callerid) { ast_copy_string(cur_agent->logincallerid, agent_callerid, sizeof(cur_agent->logincallerid)); set_agentbycallerid(cur_agent->logincallerid, cur_agent->agent); } else cur_agent->logincallerid[0] = '\0'; if (cur_agent->loginstart == 0) time(&cur_agent->loginstart); ast_devstate_changed(AST_DEVICE_UNKNOWN, "Agent/%s", cur_agent->agent); } } AST_LIST_UNLOCK(&agents); if (db_tree) { ast_log(LOG_NOTICE, "Agents successfully reloaded from database.\n"); ast_db_freetree(db_tree); } }
static void set_agentbycallerid | ( | const char * | callerid, |
const char * | agent | ||
) | [static] |
store/clear the global variable that stores agentid based on the callerid
Definition at line 852 of file chan_agent.c.
References AST_MAX_BUF, ast_strlen_zero(), buf, GETAGENTBYCALLERID, and pbx_builtin_setvar_helper().
Referenced by agent_logoff_maintenance(), and reload_agents().
{ char buf[AST_MAX_BUF]; /* if there is no Caller ID, nothing to do */ if (ast_strlen_zero(callerid)) return; snprintf(buf, sizeof(buf), "%s_%s", GETAGENTBYCALLERID, callerid); pbx_builtin_setvar_helper(NULL, buf, agent); }
static int unload_module | ( | void | ) | [static] |
Definition at line 2612 of file chan_agent.c.
References agent_function, agent_tech, ARRAY_LEN, ast_channel_unregister(), ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_manager_unregister(), ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, ast_unregister_application(), cli_agents, and agent_pvt::owner.
{ struct agent_pvt *p; /* First, take us out of the channel loop */ ast_channel_unregister(&agent_tech); /* Unregister dialplan functions */ ast_custom_function_unregister(&agent_function); /* Unregister CLI commands */ ast_cli_unregister_multiple(cli_agents, ARRAY_LEN(cli_agents)); /* Unregister dialplan applications */ ast_unregister_application(app); ast_unregister_application(app3); /* Unregister manager command */ ast_manager_unregister("Agents"); ast_manager_unregister("AgentLogoff"); /* Unregister channel */ AST_LIST_LOCK(&agents); /* Hangup all interfaces if they have an owner */ while ((p = AST_LIST_REMOVE_HEAD(&agents, list))) { if (p->owner) ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD); ast_free(p); } AST_LIST_UNLOCK(&agents); return 0; }
struct ast_module_info __MODULE_INFO_SECTION __mod_info = { __MODULE_INFO_GLOBALS .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Agent Proxy Channel" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .reload = reload, } [static] |
Definition at line 2643 of file chan_agent.c.
char acceptdtmf = DEFAULT_ACCEPTDTMF [static] |
Definition at line 211 of file chan_agent.c.
Referenced by play_record_review().
int ackcall [static] |
Definition at line 207 of file chan_agent.c.
{ .name = "AGENT", .read = function_agent, }
Definition at line 2561 of file chan_agent.c.
Referenced by load_module(), and unload_module().
const char agent_logoff_usage[] = " If 'soft' is specified, do not hangup existing calls.\n" [static] |
Definition at line 1965 of file chan_agent.c.
struct ast_channel_tech agent_tech [static] |
Channel interface description for PBX integration.
Definition at line 325 of file chan_agent.c.
Referenced by agent_new(), load_module(), and unload_module().
char agentgoodbye[AST_MAX_FILENAME_LEN] = "vm-goodbye" [static] |
Definition at line 215 of file chan_agent.c.
const char app[] = "AgentLogin" [static] |
Definition at line 176 of file chan_agent.c.
const char app3[] = "AgentMonitorOutgoing" [static] |
Definition at line 177 of file chan_agent.c.
struct ast_module_info* ast_module_info = &__mod_info [static] |
Definition at line 2643 of file chan_agent.c.
int autologoff [static] |
Definition at line 205 of file chan_agent.c.
int autologoffunavail = 0 [static] |
Definition at line 210 of file chan_agent.c.
char beep[AST_MAX_BUF] = "beep" [static] |
Definition at line 223 of file chan_agent.c.
struct ast_cli_entry cli_agents[] [static] |
{ AST_CLI_DEFINE(agents_show, "Show status of agents"), AST_CLI_DEFINE(agents_show_online, "Show all online agents"), AST_CLI_DEFINE(agent_logoff_cmd, "Sets an agent offline"), }
Definition at line 1970 of file chan_agent.c.
Referenced by load_module(), and unload_module().
const char config[] = "agents.conf" [static] |
Definition at line 174 of file chan_agent.c.
int endcall [static] |
Definition at line 208 of file chan_agent.c.
char enddtmf = DEFAULT_ENDDTMF [static] |
Definition at line 212 of file chan_agent.c.
ast_group_t group [static] |
Definition at line 204 of file chan_agent.c.
Referenced by ast_get_group(), common_exec(), and handle_cli_check_permissions().
const char mandescr_agent_logoff[] = " Soft: Set to 'true' to not hangup existing calls\n" [static] |
Definition at line 183 of file chan_agent.c.
const char mandescr_agents[] = "Variables: NONE\n" [static] |
Definition at line 179 of file chan_agent.c.
int maxlogintries = 3 [static] |
Definition at line 214 of file chan_agent.c.
Referenced by login_exec().
char moh[80] = "default" [static] |
Definition at line 189 of file chan_agent.c.
Referenced by _get_mohbyname(), dial_exec_full(), moh_generate(), moh_release(), mohalloc(), and monmp3thread().
int multiplelogin = 1 [static] |
Definition at line 209 of file chan_agent.c.
const char pa_family[] = "Agents" [static] |
Persistent Agents astdb family
Definition at line 195 of file chan_agent.c.
int persistent_agents = 0 [static] |
queues.conf [general] option
Definition at line 198 of file chan_agent.c.
int recordagentcalls = 0 [static] |
Definition at line 217 of file chan_agent.c.
char recordformat[AST_MAX_BUF] = "" [static] |
Definition at line 218 of file chan_agent.c.
char recordformatext[AST_MAX_BUF] = "" [static] |
Definition at line 219 of file chan_agent.c.
char savecallsin[AST_MAX_BUF] = "" [static] |
Definition at line 221 of file chan_agent.c.
const char tdesc[] = "Call Agent Proxy Channel" [static] |
Definition at line 173 of file chan_agent.c.
int updatecdr = 0 [static] |
Definition at line 222 of file chan_agent.c.
Referenced by login_exec().
char urlprefix[AST_MAX_BUF] = "" [static] |
Definition at line 220 of file chan_agent.c.
Referenced by start_monitor_exec().
int wrapuptime [static] |
Definition at line 206 of file chan_agent.c.