kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-10-31 18:55:19 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
cb55bf96efa8db45a1df0598e758051887afeca0
asterisk/channels/chan_agent.c
Mark Spencer df4a69f7ce Fix agent deadlock (bug #3311) 
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@4805 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-01-15 23:31:19 +00:00

2092 lines
62 KiB
C
Executable File
Raw Blame History

/*
* Asterisk -- A telephony toolkit for Linux.
*
* Implementation of Agents
*
* Copyright (C) 1999-2004, Digium Inc.
*
* Mark Spencer <markster@digium.com>
*
* This program is free software, distributed under the terms of
* the GNU General Public License
*/
#include <stdio.h>
#include <string.h>
#include <asterisk/lock.h>
#include <asterisk/channel.h>
#include <asterisk/channel_pvt.h>
#include <asterisk/config.h>
#include <asterisk/logger.h>
#include <asterisk/module.h>
#include <asterisk/pbx.h>
#include <asterisk/options.h>
#include <asterisk/lock.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 <sys/socket.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/signal.h>
static char *desc = "Agent Proxy Channel";
static char *channeltype = "Agent";
static char *tdesc = "Call Agent Proxy Channel";
static char *config = "agents.conf";
static char *app = "AgentLogin";
static char *app2 = "AgentCallbackLogin";
static char *app3 = "AgentMonitorOutgoing";
static char *synopsis = "Call agent login";
static char *synopsis2 = "Call agent callback login";
static char *synopsis3 = "Record agent's outgoing call";
static char *descrip =
" AgentLogin([AgentNo][|options]):\n"
"Asks the agent to login to the system. Always returns -1. While\n"
"logged in, the agent can receive calls and will hear a 'beep'\n"
"when a new call comes in. The agent can dump the call by pressing\n"
"the star key.\n"
"The option string may contain zero or more of the following characters:\n"
" 's' -- silent login - do not announce the login ok segment after agent logged in/off\n";
static char *descrip2 =
" AgentCallbackLogin([AgentNo][|[options][exten]@context]):\n"
"Asks the agent to login to the system with callback.\n"
"The agent's callback extension is called (optionally with the specified\n"
"context).\n"
"The option string may contain zero or more of the following characters:\n"
" 's' -- silent login - do not announce the login ok segment agent logged in/off\n";
static char *descrip3 =
" AgentMonitorOutgoing([options]):\n"
"Tries to figure out the id of the agent who is placing outgoing call based on\n"
"comparision of the callerid of the current interface and the global variable \n"
"placed by the AgentCallbackLogin application. That's why it should be used only\n"
"with the AgentCallbackLogin app. Uses the monitoring functions in chan_agent \n"
"instead of Monitor application. That have to be configured in the agents.conf file.\n"
"\nReturn value:\n"
"Normally the app returns 0 unless the options are passed. Also if the callerid or\n"
"the agentid are not specified it'll look for n+101 priority.\n"
"\nOptions:\n"
" 'd' - make the app return -1 if there is an error condition and there is\n"
" no extension n+101\n"
" 'c' - change the CDR so that the source of the call is 'Agent/agent_id'\n"
" 'n' - don't generate the warnings when there is no callerid or the\n"
" agentid is not known.\n"
" It's handy if you want to have one context for agent and non-agent calls.\n";
static char mandescr_agents[] =
"Description: Will list info about all possible agents.\n"
"Variables: NONE\n";
static char moh[80] = "default";
#define AST_MAX_AGENT 80 /* Agent ID or Password max length */
#define AST_MAX_BUF 256
#define AST_MAX_FILENAME_LEN 256
/* Persistent Agents astdb family */
static const char *pa_family = "/Agents";
/* The maximum lengh of each persistent member agent database entry */
#define PA_MAX_LEN 2048
/* queues.conf [general] option */
static int persistent_agents = 0;
static void dump_agents(void);
static int capability = -1;
static ast_group_t group;
static int autologoff;
static int wrapuptime;
static int ackcall;
static int maxlogintries = 3;
static char agentgoodbye[AST_MAX_FILENAME_LEN] = "vm-goodbye";
static int usecnt =0;
AST_MUTEX_DEFINE_STATIC(usecnt_lock);
/* Protect the interface list (of pvt's) */
AST_MUTEX_DEFINE_STATIC(agentlock);
static int recordagentcalls = 0;
static char recordformat[AST_MAX_BUF] = "";
static char recordformatext[AST_MAX_BUF] = "";
static int createlink = 0;
static char urlprefix[AST_MAX_BUF] = "";
static char savecallsin[AST_MAX_BUF] = "";
static int updatecdr = 0;
static char beep[AST_MAX_BUF] = "beep";
#define GETAGENTBYCALLERID "AGENTBYCALLERID"
static struct agent_pvt {
ast_mutex_t lock; /* Channel private lock */
int dead; /* Poised for destruction? */
int pending; /* Not a real agent -- just pending a match */
int abouttograb; /* About to grab */
int autologoff; /* Auto timeout time */
int ackcall; /* ackcall */
time_t loginstart; /* When agent first logged in (0 when logged off) */
time_t start; /* When call started */
struct timeval lastdisc; /* When last disconnected */
int wrapuptime; /* Wrapup time in ms */
ast_group_t group; /* Group memberships */
int acknowledged; /* Acknowledged */
char moh[80]; /* Which music on hold */
char agent[AST_MAX_AGENT]; /* Agent ID */
char password[AST_MAX_AGENT]; /* Password for Agent login */
char name[AST_MAX_AGENT];
ast_mutex_t app_lock; /* Synchronization between owning applications */
volatile pthread_t owning_app; /* Owning application thread id */
volatile int app_sleep_cond; /* Sleep condition for the login app */
struct ast_channel *owner; /* Agent */
char loginchan[80];
struct ast_channel *chan; /* Channel we use */
struct agent_pvt *next; /* Agent */
} *agents = NULL;
#define CHECK_FORMATS(ast, p) do { \
if (p->chan) {\
if (ast->nativeformats != p->chan->nativeformats) { \
ast_log(LOG_DEBUG, "Native formats changing from %d to %d\n", ast->nativeformats, p->chan->nativeformats); \
/* Native formats changed, reset things */ \
ast->nativeformats = p->chan->nativeformats; \
ast_log(LOG_DEBUG, "Resetting read to %d and write to %d\n", ast->readformat, ast->writeformat);\
ast_set_read_format(ast, ast->readformat); \
ast_set_write_format(ast, ast->writeformat); \
} \
if (p->chan->readformat != ast->pvt->rawreadformat) \
ast_set_read_format(p->chan, ast->pvt->rawreadformat); \
if (p->chan->writeformat != ast->pvt->rawwriteformat) \
ast_set_write_format(p->chan, ast->pvt->rawwriteformat); \
} \
} while(0)
/* 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 CLEANUP(ast, p) do { \
int x; \
if (p->chan) { \
for (x=0;x<AST_MAX_FDS;x++) {\
if (x != AST_MAX_FDS - 2) \
ast->fds[x] = p->chan->fds[x]; \
} \
ast->fds[AST_MAX_FDS - 3] = p->chan->fds[AST_MAX_FDS - 2]; \
} \
} while(0)
static void agent_unlink(struct agent_pvt *agent)
{
struct agent_pvt *p, *prev;
prev = NULL;
p = agents;
while(p) {
if (p == agent) {
if (prev)
prev->next = agent->next;
else
agents = agent->next;
break;
}
prev = p;
p = p->next;
}
}
static struct agent_pvt *add_agent(char *agent, int pending)
{
char tmp[AST_MAX_BUF] = "";
char *password=NULL, *name=NULL;
struct agent_pvt *p, *prev;
strncpy(tmp, agent, sizeof(tmp) - 1);
if ((password = strchr(tmp, ','))) {
*password = '\0';
password++;
while (*password < 33) password++;
}
if (password && (name = strchr(password, ','))) {
*name = '\0';
name++;
while (*name < 33) name++;
}
prev=NULL;
p = agents;
while(p) {
if (!pending && !strcmp(p->agent, tmp))
break;
prev = p;
p = p->next;
}
if (!p) {
p = malloc(sizeof(struct agent_pvt));
if (p) {
memset(p, 0, sizeof(struct agent_pvt));
strncpy(p->agent, tmp, sizeof(p->agent) -1);
ast_mutex_init(&p->lock);
ast_mutex_init(&p->app_lock);
p->owning_app = (pthread_t) -1;
p->app_sleep_cond = 1;
p->group = group;
p->pending = pending;
p->next = NULL;
if (prev)
prev->next = p;
else
agents = p;
}
}
if (!p)
return NULL;
strncpy(p->password, password ? password : "", sizeof(p->password) - 1);
strncpy(p->name, name ? name : "", sizeof(p->name) - 1);
strncpy(p->moh, moh, sizeof(p->moh) - 1);
p->ackcall = ackcall;
p->autologoff = autologoff;
p->wrapuptime = wrapuptime;
if (pending)
p->dead = 1;
else
p->dead = 0;
return p;
}
static int agent_cleanup(struct agent_pvt *p)
{
struct ast_channel *chan = p->owner;
p->owner = NULL;
chan->pvt->pvt = NULL;
p->app_sleep_cond = 1;
/* Release ownership of the agent to other threads (presumably running the login app). */
ast_mutex_unlock(&p->app_lock);
if (chan)
ast_channel_free(chan);
if (p->dead) {
ast_mutex_destroy(&p->lock);
ast_mutex_destroy(&p->app_lock);
free(p);
}
return 0;
}
static int check_availability(struct agent_pvt *newlyavailable, int needlock);
static int agent_answer(struct ast_channel *ast)
{
ast_log(LOG_WARNING, "Huh? Agent is being asked to answer?\n");
return -1;
}
static int __agent_start_monitoring(struct ast_channel *ast, struct agent_pvt *p, int needlock)
{
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 ? savecallsin : "", filename);
ast_monitor_start(ast, recordformat, tmp, needlock);
ast_monitor_setjoinfiles(ast, 1);
snprintf(tmp2, sizeof(tmp2), "%s%s.%s", urlprefix ? 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 int agent_start_monitoring(struct ast_channel *ast, int needlock)
{
return __agent_start_monitoring(ast, ast->pvt->pvt, needlock);
}
static struct ast_frame *agent_read(struct ast_channel *ast)
{
struct agent_pvt *p = ast->pvt->pvt;
struct ast_frame *f = NULL;
static struct ast_frame null_frame = { AST_FRAME_NULL, };
static struct ast_frame answer_frame = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
ast_mutex_lock(&p->lock);
CHECK_FORMATS(ast, p);
if (p->chan) {
ast_copy_flags(p->chan, ast, AST_FLAG_EXCEPTION);
if (ast->fdno == AST_MAX_FDS - 3)
p->chan->fdno = AST_MAX_FDS - 2;
else
p->chan->fdno = ast->fdno;
f = ast_read(p->chan);
} else
f = &null_frame;
if (!f) {
/* If there's a channel, hang it up (if it's on a callback) make it NULL */
if (p->chan) {
/* 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)) {
p->chan->_bridge = NULL;
ast_hangup(p->chan);
if (p->wrapuptime) {
gettimeofday(&p->lastdisc, NULL);
p->lastdisc.tv_usec += (p->wrapuptime % 1000) * 1000;
if (p->lastdisc.tv_usec > 1000000) {
p->lastdisc.tv_usec -= 1000000;
p->lastdisc.tv_sec++;
}
p->lastdisc.tv_sec += (p->wrapuptime / 1000);
}
}
p->chan = NULL;
p->acknowledged = 0;
}
}
if ((p->chan && (p->chan->_state != AST_STATE_UP)) && f && (f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_ANSWER)) {
/* TC */
if (p->ackcall) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "%s answered, waiting for '#' to acknowledge\n", p->chan->name);
/* Don't pass answer along */
ast_frfree(f);
f = &null_frame;
}
else {
p->acknowledged = 1;
f = &answer_frame;
if (p->chan)
p->chan->_bridge = ast;
}
}
if (f && (f->frametype == AST_FRAME_DTMF) && (f->subclass == '#')) {
if (!p->acknowledged) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "%s acknowledged\n", p->chan->name);
p->acknowledged = 1;
ast_frfree(f);
f = &answer_frame;
if (p->chan)
p->chan->_bridge = ast;
}
}
if (f && (f->frametype == AST_FRAME_DTMF) && (f->subclass == '*')) {
/* * terminates call */
ast_frfree(f);
f = NULL;
}
CLEANUP(ast,p);
ast_mutex_unlock(&p->lock);
if (recordagentcalls && f == &answer_frame)
agent_start_monitoring(ast,0);
return f;
}
static int agent_write(struct ast_channel *ast, struct ast_frame *f)
{
struct agent_pvt *p = ast->pvt->pvt;
int res = -1;
CHECK_FORMATS(ast, p);
ast_mutex_lock(&p->lock);
if (p->chan) {
if ((f->frametype != AST_FRAME_VOICE) ||
(f->subclass == p->chan->writeformat)) {
res = ast_write(p->chan, f);
} else {
ast_log(LOG_DEBUG, "Dropping one incompatible voice frame on '%s' to '%s'\n", ast->name, p->chan->name);
res = 0;
}
} else
res = 0;
CLEANUP(ast, p);
ast_mutex_unlock(&p->lock);
return res;
}
static int agent_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
{
struct agent_pvt *p = newchan->pvt->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;
}
static int agent_indicate(struct ast_channel *ast, int condition)
{
struct agent_pvt *p = ast->pvt->pvt;
int res = -1;
ast_mutex_lock(&p->lock);
if (p->chan)
res = ast_indicate(p->chan, condition);
else
res = 0;
ast_mutex_unlock(&p->lock);
return res;
}
static int agent_digit(struct ast_channel *ast, char digit)
{
struct agent_pvt *p = ast->pvt->pvt;
int res = -1;
ast_mutex_lock(&p->lock);
if (p->chan)
res = p->chan->pvt->send_digit(p->chan, digit);
else
res = 0;
ast_mutex_unlock(&p->lock);
return res;
}
static int agent_call(struct ast_channel *ast, char *dest, int timeout)
{
struct agent_pvt *p = ast->pvt->pvt;
int res = -1;
int newstate=0;
ast_mutex_lock(&p->lock);
p->acknowledged = 0;
if (!p->chan) {
if (p->pending) {
ast_log(LOG_DEBUG, "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 */
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "outgoing agentcall, to agent '%s', on '%s'\n", p->agent, p->chan->name);
if (p->chan->cid.cid_num)
free(p->chan->cid.cid_num);
if (ast->cid.cid_num)
p->chan->cid.cid_num = strdup(ast->cid.cid_num);
else
p->chan->cid.cid_num = NULL;
if (p->chan->cid.cid_name)
free(p->chan->cid.cid_name);
if (ast->cid.cid_name)
p->chan->cid.cid_name = strdup(ast->cid.cid_name);
else
p->chan->cid.cid_name = NULL;
res = ast_call(p->chan, p->loginchan, 0);
CLEANUP(ast,p);
ast_mutex_unlock(&p->lock);
return res;
}
ast_verbose( VERBOSE_PREFIX_3 "agent_call, call to agent '%s' call on '%s'\n", p->agent, p->chan->name);
ast_log( LOG_DEBUG, "Playing beep, lang '%s'\n", p->chan->language);
res = ast_streamfile(p->chan, beep, p->chan->language);
ast_log( LOG_DEBUG, "Played beep, result '%d'\n", res);
if (!res) {
res = ast_waitstream(p->chan, "");
ast_log( LOG_DEBUG, "Waited for stream, result '%d'\n", res);
}
if (!res) {
res = ast_set_read_format(p->chan, ast_best_codec(p->chan->nativeformats));
ast_log( LOG_DEBUG, "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;
}
if (!res) {
ast_set_write_format(p->chan, ast_best_codec(p->chan->nativeformats));
ast_log( LOG_DEBUG, "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_hangup(struct ast_channel *ast)
{
struct agent_pvt *p = ast->pvt->pvt;
int howlong = 0;
ast_mutex_lock(&p->lock);
p->owner = NULL;
ast->pvt->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_mutex_lock(&usecnt_lock);
usecnt--;
ast_mutex_unlock(&usecnt_lock);
ast_log(LOG_DEBUG, "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) {
/* 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) {
gettimeofday(&p->lastdisc, NULL);
p->lastdisc.tv_usec += (p->wrapuptime % 1000) * 1000;
if (p->lastdisc.tv_usec >= 1000000) {
p->lastdisc.tv_usec -= 1000000;
p->lastdisc.tv_sec++;
}
p->lastdisc.tv_sec += (p->wrapuptime / 1000);
} else
memset(&p->lastdisc, 0, sizeof(p->lastdisc));
if (p->chan) {
/* Recognize the hangup and pass it along immediately */
ast_hangup(p->chan);
p->chan = NULL;
}
ast_log(LOG_DEBUG, "Hungup, howlong is %d, autologoff is %d\n", howlong, p->autologoff);
if (howlong && p->autologoff && (howlong > p->autologoff)) {
char agent[AST_MAX_AGENT] = "";
long logintime = time(NULL) - p->loginstart;
p->loginstart = 0;
ast_log(LOG_NOTICE, "Agent '%s' didn't answer/confirm within %d seconds (waited %d)\n", p->name, p->autologoff, howlong);
manager_event(EVENT_FLAG_AGENT, "Agentcallbacklogoff",
"Agent: %s\r\n"
"Loginchan: %s\r\n"
"Logintime: %ld\r\n"
"Reason: Autologoff\r\n"
"Uniqueid: %s\r\n",
p->agent, p->loginchan, logintime, ast->uniqueid);
snprintf(agent, sizeof(agent), "Agent/%s", p->agent);
ast_queue_log("NONE", ast->uniqueid, agent, "AGENTCALLBACKLOGOFF", "%s|%ld|%s", p->loginchan, logintime, "Autologoff");
p->loginchan[0] = '\0';
ast_device_state_changed("Agent/%s", p->agent);
}
} else if (p->dead) {
ast_mutex_lock(&p->chan->lock);
ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
ast_mutex_unlock(&p->chan->lock);
} else {
ast_mutex_lock(&p->chan->lock);
ast_moh_start(p->chan, p->moh);
ast_mutex_unlock(&p->chan->lock);
}
}
#if 0
ast_mutex_unlock(&p->lock);
/* Release ownership of the agent to other threads (presumably running the login app). */
ast_mutex_unlock(&p->app_lock);
} else if (p->dead) {
/* Go ahead and lose it */
ast_mutex_unlock(&p->lock);
/* Release ownership of the agent to other threads (presumably running the login app). */
ast_mutex_unlock(&p->app_lock);
} else {
ast_mutex_unlock(&p->lock);
/* Release ownership of the agent to other threads (presumably running the login app). */
ast_mutex_unlock(&p->app_lock);
}
#endif
ast_mutex_unlock(&p->lock);
if (p->pending) {
ast_mutex_lock(&agentlock);
agent_unlink(p);
ast_mutex_unlock(&agentlock);
}
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);
free(p);
} else {
if (p->chan) {
/* Not dead -- check availability now */
ast_mutex_lock(&p->lock);
/* Store last disconnect time */
gettimeofday(&p->lastdisc, NULL);
ast_mutex_unlock(&p->lock);
}
/* Release ownership of the agent to other threads (presumably running the login app). */
ast_mutex_unlock(&p->app_lock);
}
return 0;
}
static int agent_cont_sleep( void *data )
{
struct agent_pvt *p;
struct timeval tv;
int res;
p = (struct agent_pvt *)data;
ast_mutex_lock(&p->lock);
res = p->app_sleep_cond;
if (p->lastdisc.tv_sec) {
gettimeofday(&tv, NULL);
if ((tv.tv_sec - p->lastdisc.tv_sec) * 1000 +
(tv.tv_usec - p->lastdisc.tv_usec) / 1000 > p->wrapuptime)
res = 1;
}
ast_mutex_unlock(&p->lock);
#if 0
if( !res )
ast_log( LOG_DEBUG, "agent_cont_sleep() returning %d\n", res );
#endif
return res;
}
static int agent_ack_sleep( void *data )
{
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) {
for(;;) {
to = ast_waitfor(p->chan, to);
if (to < 0) {
res = -1;
break;
}
if (!to) {
res = 0;
break;
}
f = ast_read(p->chan);
if (!f) {
res = -1;
break;
}
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);
res = 0;
break;
} else if (res == '#') {
ast_mutex_unlock(&p->lock);
res = 1;
break;
}
ast_mutex_unlock(&p->lock);
res = 0;
}
} else
res = -1;
return res;
}
static struct ast_channel *agent_bridgedchannel(struct ast_channel *chan, struct ast_channel *bridge)
{
struct agent_pvt *p;
struct ast_channel *ret=NULL;
p = bridge->pvt->pvt;
if (chan == p->chan)
ret = bridge->_bridge;
else if (chan == bridge->_bridge)
ret = p->chan;
return NULL;
}
/*--- agent_new: Create new agent channel ---*/
static struct ast_channel *agent_new(struct agent_pvt *p, int state)
{
struct ast_channel *tmp;
struct ast_frame null_frame = { AST_FRAME_NULL };
#if 0
if (!p->chan) {
ast_log(LOG_WARNING, "No channel? :(\n");
return NULL;
}
#endif
tmp = ast_channel_alloc(0);
if (tmp) {
if (p->chan) {
tmp->nativeformats = p->chan->nativeformats;
tmp->writeformat = p->chan->writeformat;
tmp->pvt->rawwriteformat = p->chan->writeformat;
tmp->readformat = p->chan->readformat;
tmp->pvt->rawreadformat = p->chan->readformat;
strncpy(tmp->language, p->chan->language, sizeof(tmp->language)-1);
strncpy(tmp->context, p->chan->context, sizeof(tmp->context)-1);
strncpy(tmp->exten, p->chan->exten, sizeof(tmp->exten)-1);
} else {
tmp->nativeformats = AST_FORMAT_SLINEAR;
tmp->writeformat = AST_FORMAT_SLINEAR;
tmp->pvt->rawwriteformat = AST_FORMAT_SLINEAR;
tmp->readformat = AST_FORMAT_SLINEAR;
tmp->pvt->rawreadformat = AST_FORMAT_SLINEAR;
}
if (p->pending)
snprintf(tmp->name, sizeof(tmp->name), "Agent/P%s-%d", p->agent, rand() & 0xffff);
else
snprintf(tmp->name, sizeof(tmp->name), "Agent/%s", p->agent);
tmp->type = channeltype;
/* Safe, agentlock already held */
ast_setstate(tmp, state);
tmp->pvt->pvt = p;
tmp->pvt->send_digit = agent_digit;
tmp->pvt->call = agent_call;
tmp->pvt->hangup = agent_hangup;
tmp->pvt->answer = agent_answer;
tmp->pvt->read = agent_read;
tmp->pvt->write = agent_write;
tmp->pvt->exception = agent_read;
tmp->pvt->indicate = agent_indicate;
tmp->pvt->fixup = agent_fixup;
tmp->pvt->bridged_channel = agent_bridgedchannel;
p->owner = tmp;
ast_mutex_lock(&usecnt_lock);
usecnt++;
ast_mutex_unlock(&usecnt_lock);
ast_update_use_count();
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;
if( ast_mutex_trylock(&p->app_lock) )
{
if (p->chan) {
ast_queue_frame(p->chan, &null_frame);
ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */
ast_mutex_lock(&p->app_lock);
ast_mutex_lock(&p->lock);
}
if( !p->chan )
{
ast_log(LOG_WARNING, "Agent disconnected while we were connecting the call\n");
p->owner = NULL;
tmp->pvt->pvt = NULL;
p->app_sleep_cond = 1;
ast_channel_free( tmp );
ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */
ast_mutex_unlock(&p->app_lock);
return NULL;
}
}
p->owning_app = pthread_self();
/* After the above step, there should not be any blockers. */
if (p->chan) {
if (ast_test_flag(p->chan, AST_FLAG_BLOCKING)) {
ast_log( LOG_ERROR, "A blocker exists after agent channel ownership acquired\n" );
CRASH;
}
ast_moh_stop(p->chan);
}
} else
ast_log(LOG_WARNING, "Unable to allocate agent channel structure\n");
return tmp;
}
/*--- read_agent_config: Read configuration data (agents.conf) ---*/
static int read_agent_config(void)
{
struct ast_config *cfg;
struct ast_variable *v;
struct agent_pvt *p, *pl, *pn;
char *general_val;
group = 0;
autologoff = 0;
wrapuptime = 0;
ackcall = 1;
cfg = ast_load(config);
if (!cfg) {
ast_log(LOG_NOTICE, "No agent configuration found -- agent support disabled\n");
return 0;
}
ast_mutex_lock(&agentlock);
p = agents;
while(p) {
p->dead = 1;
p = p->next;
}
strncpy(moh, "default", sizeof(moh) - 1);
/* set the default recording values */
recordagentcalls = 0;
createlink = 0;
strncpy(recordformat, "wav", sizeof(recordformat) - 1);
strncpy(recordformatext, "wav", sizeof(recordformatext) - 1);
urlprefix[0] = '\0';
savecallsin[0] = '\0';
/* Read in [general] section for persistance */
if ((general_val = ast_variable_retrieve(cfg, "general", "persistentagents")))
persistent_agents = ast_true(general_val);
/* 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, "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")) {
strncpy(moh, v->value, sizeof(moh) - 1);
} else if (!strcasecmp(v->name, "updatecdr")) {
if (ast_true(v->value))
updatecdr = 1;
else
updatecdr = 0;
} else if (!strcasecmp(v->name, "recordagentcalls")) {
recordagentcalls = ast_true(v->value);
} else if (!strcasecmp(v->name, "createlink")) {
createlink = ast_true(v->value);
} else if (!strcasecmp(v->name, "recordformat")) {
strncpy(recordformat, v->value, sizeof(recordformat) - 1);
if (!strcasecmp(v->value, "wav49"))
strncpy(recordformatext, "WAV", sizeof(recordformatext) - 1);
else
strncpy(recordformatext, v->value, sizeof(recordformatext) - 1);
} else if (!strcasecmp(v->name, "urlprefix")) {
strncpy(urlprefix, v->value, sizeof(urlprefix) - 2);
if (urlprefix[strlen(urlprefix) - 1] != '/')
strncat(urlprefix, "/", sizeof(urlprefix) - strlen(urlprefix) - 1);
} else if (!strcasecmp(v->name, "savecallsin")) {
if (v->value[0] == '/')
strncpy(savecallsin, v->value, sizeof(savecallsin) - 2);
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")) {
strncpy(beep, v->value, sizeof(beep) - 1);
}
v = v->next;
}
p = agents;
pl = NULL;
while(p) {
pn = p->next;
if (p->dead) {
/* Unlink */
if (pl)
pl->next = p->next;
else
agents = p->next;
/* Destroy if appropriate */
if (!p->owner) {
if (!p->chan) {
ast_mutex_destroy(&p->lock);
ast_mutex_destroy(&p->app_lock);
free(p);
} else {
/* Cause them to hang up */
ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
}
}
} else
pl = p;
p = pn;
}
ast_mutex_unlock(&agentlock);
ast_destroy(cfg);
return 0;
}
static int check_availability(struct agent_pvt *newlyavailable, int needlock)
{
struct ast_channel *chan=NULL, *parent=NULL;
struct agent_pvt *p;
int res;
if (option_debug)
ast_log(LOG_DEBUG, "Checking availability of '%s'\n", newlyavailable->agent);
if (needlock)
ast_mutex_lock(&agentlock);
p = agents;
while(p) {
if (p == newlyavailable) {
p = p->next;
continue;
}
ast_mutex_lock(&p->lock);
if (!p->abouttograb && p->pending && ((p->group && (newlyavailable->group & p->group)) || !strcmp(p->agent, newlyavailable->agent))) {
if (option_debug)
ast_log(LOG_DEBUG, "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);
p = p->next;
}
if (needlock)
ast_mutex_unlock(&agentlock);
if (parent && chan) {
if (newlyavailable->ackcall > 1) {
/* Don't do beep here */
res = 0;
} else {
if (option_debug > 2)
ast_log( LOG_DEBUG, "Playing beep, lang '%s'\n", newlyavailable->chan->language);
res = ast_streamfile(newlyavailable->chan, beep, newlyavailable->chan->language);
if (option_debug > 2)
ast_log( LOG_DEBUG, "Played beep, result '%d'\n", res);
if (!res) {
res = ast_waitstream(newlyavailable->chan, "");
ast_log( LOG_DEBUG, "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);
strncpy(parent->context, chan->context, sizeof(parent->context) - 1);
/* 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_mutex_lock(&parent->lock);
ast_set_flag(chan, AST_FLAG_ZOMBIE);
ast_channel_masquerade(parent, chan);
ast_mutex_unlock(&parent->lock);
p->abouttograb = 0;
} else {
if (option_debug)
ast_log(LOG_DEBUG, "Sneaky, parent disappeared in the mean time...\n");
agent_cleanup(newlyavailable);
}
} else {
if (option_debug)
ast_log(LOG_DEBUG, "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)
{
struct agent_pvt *p;
int res=0;
ast_log(LOG_DEBUG, "Checking beep availability of '%s'\n", newlyavailable->agent);
if (needlock)
ast_mutex_lock(&agentlock);
p = agents;
while(p) {
if (p == newlyavailable) {
p = p->next;
continue;
}
ast_mutex_lock(&p->lock);
if (!p->abouttograb && p->pending && ((p->group && (newlyavailable->group & p->group)) || !strcmp(p->agent, newlyavailable->agent))) {
if (option_debug)
ast_log(LOG_DEBUG, "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);
p = p->next;
}
if (needlock)
ast_mutex_unlock(&agentlock);
if (p) {
ast_mutex_unlock(&newlyavailable->lock);
if (option_debug > 2)
ast_log( LOG_DEBUG, "Playing beep, lang '%s'\n", newlyavailable->chan->language);
res = ast_streamfile(newlyavailable->chan, beep, newlyavailable->chan->language);
if (option_debug > 2)
ast_log( LOG_DEBUG, "Played beep, result '%d'\n", res);
if (!res) {
res = ast_waitstream(newlyavailable->chan, "");
if (option_debug)
ast_log( LOG_DEBUG, "Waited for stream, result '%d'\n", res);
}
ast_mutex_lock(&newlyavailable->lock);
}
return res;
}
/*--- agent_request: Part of the Asterisk PBX interface ---*/
static struct ast_channel *agent_request(const char *type, int format, void *data, int *cause)
{
struct agent_pvt *p;
struct ast_channel *chan = NULL;
char *s;
ast_group_t groupmatch;
int waitforagent=0;
int hasagent = 0;
struct timeval tv;
s = data;
if ((s[0] == '@') && (sscanf(s + 1, "%d", &groupmatch) == 1)) {
groupmatch = (1 << groupmatch);
} else if ((s[0] == ':') && (sscanf(s + 1, "%d", &groupmatch) == 1)) {
groupmatch = (1 << groupmatch);
waitforagent = 1;
} else {
groupmatch = 0;
}
/* Check actual logged in agents first */
ast_mutex_lock(&agentlock);
p = agents;
while(p) {
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++;
if (!p->lastdisc.tv_sec) {
/* 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);
p = p->next;
}
if (!p) {
p = agents;
while(p) {
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++;
gettimeofday(&tv, NULL);
#if 0
ast_log(LOG_NOTICE, "Time now: %ld, Time of lastdisc: %ld\n", tv.tv_sec, p->lastdisc.tv_sec);
#endif
if (!p->lastdisc.tv_sec || (tv.tv_sec > p->lastdisc.tv_sec)) {
memset(&p->lastdisc, 0, sizeof(p->lastdisc));
/* 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);
p = p->next;
}
}
if (!chan && waitforagent) {
/* No agent available -- but we're requesting to wait for one.
Allocate a place holder */
if (hasagent) {
if (option_debug)
ast_log(LOG_DEBUG, "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_log(LOG_DEBUG, "Not creating place holder for '%s' since nobody logged in\n", s);
}
if (hasagent)
*cause = AST_CAUSE_BUSY;
else
*cause = AST_CAUSE_UNREGISTERED;
ast_mutex_unlock(&agentlock);
return chan;
}
static int powerof(unsigned int v)
{
int x;
for (x=0;x<32;x++) {
if (v & (1 << x)) return x;
}
return 0;
}
static int action_agents(struct mansession *s, struct message *m)
{
struct agent_pvt *p;
char *username = NULL;
char *loginChan = NULL;
char *talkingtoChan = NULL;
char *status = NULL;
ast_mutex_lock(&agentlock);
p = agents;
while(p) {
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. */
if(!ast_strlen_zero(p->name)) {
username = p->name;
} else {
username = "None";
}
/* Set a default status. It 'should' get changed. */
status = "AGENT_UNKNOWN";
if(p->chan) {
loginChan = p->loginchan;
if(p->owner && p->owner->_bridge) {
talkingtoChan = p->chan->cid.cid_num;
status = "AGENT_ONCALL";
} else {
talkingtoChan = "n/a";
status = "AGENT_IDLE";
}
} else if(!ast_strlen_zero(p->loginchan)) {
loginChan = p->loginchan;
talkingtoChan = "n/a";
status = "AGENT_IDLE";
if(p->acknowledged) {
sprintf(loginChan, " %s (Confirmed)", loginChan);
}
} else {
loginChan = "n/a";
talkingtoChan = "n/a";
status = "AGENT_LOGGEDOFF";
}
ast_cli(s->fd, "Event: Agents\r\n"
"Agent: %s\r\n"
"Name: %s\r\n"
"Status: %s\r\n"
"LoggedInChan: %s\r\n"
"LoggedInTime: %ld\r\n"
"TalkingTo: %s\r\n"
"\r\n",
p->agent,p->name,status,loginChan,p->loginstart,talkingtoChan);
ast_mutex_unlock(&p->lock);
p = p->next;
}
ast_mutex_unlock(&agentlock);
return 0;
}
/*--- agents_show: Show agents in cli ---*/
static int agents_show(int fd, int argc, char **argv)
{
struct agent_pvt *p;
char username[AST_MAX_BUF];
char location[AST_MAX_BUF] = "";
char talkingto[AST_MAX_BUF] = "";
char moh[AST_MAX_BUF];
if (argc != 2)
return RESULT_SHOWUSAGE;
ast_mutex_lock(&agentlock);
p = agents;
while(p) {
ast_mutex_lock(&p->lock);
if (p->pending) {
if (p->group)
ast_cli(fd, "-- Pending call to group %d\n", powerof(p->group));
else
ast_cli(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 {
strncpy(talkingto, " is idle", sizeof(talkingto) - 1);
}
} else if (!ast_strlen_zero(p->loginchan)) {
snprintf(location, sizeof(location) - 20, "available at '%s'", p->loginchan);
talkingto[0] = '\0';
if (p->acknowledged)
strncat(location, " (Confirmed)", sizeof(location) - strlen(location) - 1);
} else {
strncpy(location, "not logged in", sizeof(location) - 1);
talkingto[0] = '\0';
}
if (!ast_strlen_zero(p->moh))
snprintf(moh, sizeof(moh), " (musiconhold is '%s')", p->moh);
ast_cli(fd, "%-12.12s %s%s%s%s\n", p->agent,
username, location, talkingto, moh);
}
ast_mutex_unlock(&p->lock);
p = p->next;
}
ast_mutex_unlock(&agentlock);
return RESULT_SUCCESS;
}
static char show_agents_usage[] =
"Usage: show agents\n"
" Provides summary information on agents.\n";
static struct ast_cli_entry cli_show_agents = {
{ "show", "agents", NULL }, agents_show,
"Show status of agents", show_agents_usage, NULL };
STANDARD_LOCAL_USER;
LOCAL_USER_DECL;
/*--- __login_exec: Log in agent application ---*/
static int __login_exec(struct ast_channel *chan, void *data, int callbackmode)
{
int res=0;
int tries = 0;
int max_login_tries = maxlogintries;
struct agent_pvt *p;
struct localuser *u;
struct timeval tv;
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 info[512];
char *opt_user = NULL;
char *options = NULL;
char option;
char badoption[2];
char *tmpoptions = NULL;
char *context = NULL;
char *exten = NULL;
int play_announcement = 1;
char agent_goodbye[AST_MAX_FILENAME_LEN];
int update_cdr = updatecdr;
char *filename = "agent-loginok";
strcpy(agent_goodbye, agentgoodbye);
LOCAL_USER_ADD(u);
/* Parse the arguments XXX Check for failure XXX */
strncpy(info, (char *)data, strlen((char *)data) + AST_MAX_EXTENSION-1);
opt_user = info;
/* Set Channel Specific Login Overrides */
if (pbx_builtin_getvar_helper(chan, "AGENTLMAXLOGINTRIES") && strlen(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");
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "Saw variable AGENTMAXLOGINTRIES=%s, setting max_login_tries to: %d on Channel '%s'.\n",tmpoptions,max_login_tries,chan->name);
}
if (pbx_builtin_getvar_helper(chan, "AGENTUPDATECDR") && !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");
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "Saw variable AGENTUPDATECDR=%s, setting update_cdr to: %d on Channel '%s'.\n",tmpoptions,update_cdr,chan->name);
}
if (pbx_builtin_getvar_helper(chan, "AGENTGOODBYE") && !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");
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "Saw variable AGENTGOODBYE=%s, setting agent_goodbye to: %s on Channel '%s'.\n",tmpoptions,agent_goodbye,chan->name);
}
/* End Channel Specific Login Overrides */
/* Read command line options */
if( opt_user ) {
options = strchr(opt_user, '|');
if (options) {
*options = '\0';
options++;
if (callbackmode) {
context = strchr(options, '@');
if (context) {
*context = '\0';
context++;
}
exten = options;
while(*exten && ((*exten < '0') || (*exten > '9'))) exten++;
if (!*exten)
exten = NULL;
}
}
if (options) {
while (*options) {
option = (char)options[0];
if ((option >= 0) && (option <= '9'))
{
options++;
continue;
}
if (option=='s')
play_announcement = 0;
else {
badoption[0] = option;
badoption[1] = '\0';
tmpoptions=badoption;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "Warning: option %s is unknown.\n",tmpoptions);
}
options++;
}
}
}
/* End command line options */
if (chan->_state != AST_STATE_UP)
res = ast_answer(chan);
if (!res) {
if( opt_user && !ast_strlen_zero(opt_user))
strncpy( user, opt_user, AST_MAX_AGENT - 1);
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_mutex_lock(&agentlock);
p = agents;
while(p) {
if (!strcmp(p->agent, user) && !p->pending)
strncpy(xpass, p->password, sizeof(xpass) - 1);
p = p->next;
}
ast_mutex_unlock(&agentlock);
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_mutex_lock(&agentlock);
p = agents;
while(p) {
ast_mutex_lock(&p->lock);
if (!strcmp(p->agent, user) &&
!strcmp(p->password, pass) && !p->pending) {
login_state = 1; /* Successful Login */
/* Set Channel Specific Agent Overides */
if (pbx_builtin_getvar_helper(chan, "AGENTACKCALL") && strlen(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");
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "Saw variable AGENTACKCALL=%s, setting ackcall to: %d for Agent '%s'.\n",tmpoptions,p->ackcall,p->agent);
}
if (pbx_builtin_getvar_helper(chan, "AGENTAUTOLOGOFF") && strlen(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");
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "Saw variable AGENTAUTOLOGOFF=%s, setting autologff to: %d for Agent '%s'.\n",tmpoptions,p->autologoff,p->agent);
}
if (pbx_builtin_getvar_helper(chan, "AGENTWRAPUPTIME") && strlen(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");
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "Saw variable AGENTWRAPUPTIME=%s, setting wrapuptime to: %d for Agent '%s'.\n",tmpoptions,p->wrapuptime,p->agent);
}
/* End Channel Specific Agent Overides */
if (!p->chan) {
char last_loginchan[80] = "";
long logintime;
snprintf(agent, sizeof(agent), "Agent/%s", p->agent);
if (callbackmode) {
char tmpchan[AST_MAX_BUF] = "";
int pos = 0;
/* Retrieve login chan */
for (;;) {
if (exten) {
strncpy(tmpchan, exten, sizeof(tmpchan) - 1);
res = 0;
} else
res = ast_app_getdata(chan, "agent-newlocation", tmpchan+pos, sizeof(tmpchan) - 2, 0);
if (ast_strlen_zero(tmpchan) || ast_exists_extension(chan, context && !ast_strlen_zero(context) ? context : "default", tmpchan,
1, NULL))
break;
if (exten) {
ast_log(LOG_WARNING, "Extension '%s' is not valid for automatic login of agent '%s'\n", exten, p->agent);
exten = NULL;
pos = 0;
} else {
ast_log(LOG_WARNING, "Extension '%s@%s' is not valid for automatic login of agent '%s'\n", tmpchan, context && !ast_strlen_zero(context) ? context : "default", p->agent);
res = ast_streamfile(chan, "invalid", chan->language);
if (!res)
res = ast_waitstream(chan, AST_DIGIT_ANY);
if (res > 0) {
tmpchan[0] = res;
tmpchan[1] = '\0';
pos = 1;
} else {
tmpchan[0] = '\0';
pos = 0;
}
}
}
exten = tmpchan;
if (!res) {
if (context && !ast_strlen_zero(context) && !ast_strlen_zero(tmpchan))
snprintf(p->loginchan, sizeof(p->loginchan), "%s@%s", tmpchan, context);
else {
strncpy(last_loginchan, p->loginchan, sizeof(last_loginchan) - 1);
strncpy(p->loginchan, tmpchan, sizeof(p->loginchan) - 1);
}
if (ast_strlen_zero(p->loginchan)) {
login_state = 2;
filename = "agent-loggedoff";
}
p->acknowledged = 0;
/* store/clear the global variable that stores agentid based on the callerid */
if (chan->cid.cid_num) {
char agentvar[AST_MAX_BUF];
snprintf(agentvar, sizeof(agentvar), "%s_%s",GETAGENTBYCALLERID, chan->cid.cid_num);
if (ast_strlen_zero(p->loginchan))
pbx_builtin_setvar_helper(NULL, agentvar, NULL);
else
pbx_builtin_setvar_helper(NULL, agentvar, p->agent);
}
if(update_cdr && chan->cdr)
snprintf(chan->cdr->channel, sizeof(chan->cdr->channel), "Agent/%s", p->agent);
}
} else {
p->loginchan[0] = '\0';
p->acknowledged = 0;
}
ast_mutex_unlock(&p->lock);
ast_mutex_unlock(&agentlock);
if( !res && play_announcement==1 )
res = ast_streamfile(chan, filename, chan->language);
if (!res)
ast_waitstream(chan, "");
ast_mutex_lock(&agentlock);
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) {
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 (callbackmode && !res) {
/* Just say goodbye and be done with it */
if (!ast_strlen_zero(p->loginchan)) {
if (p->loginstart == 0)
time(&p->loginstart);
manager_event(EVENT_FLAG_AGENT, "Agentcallbacklogin",
"Agent: %s\r\n"
"Loginchan: %s\r\n"
"Uniqueid: %s\r\n",
p->agent, p->loginchan, chan->uniqueid);
ast_queue_log("NONE", chan->uniqueid, agent, "AGENTCALLBACKLOGIN", "%s", p->loginchan);
if (option_verbose > 1)
ast_verbose(VERBOSE_PREFIX_2 "Callback Agent '%s' logged in on %s\n", p->agent, p->loginchan);
ast_device_state_changed("Agent/%s", p->agent);
} else {
logintime = time(NULL) - p->loginstart;
p->loginstart = 0;
manager_event(EVENT_FLAG_AGENT, "Agentcallbacklogoff",
"Agent: %s\r\n"
"Loginchan: %s\r\n"
"Logintime: %ld\r\n"
"Uniqueid: %s\r\n",
p->agent, last_loginchan, logintime, chan->uniqueid);
ast_queue_log("NONE", chan->uniqueid, agent, "AGENTCALLBACKLOGOFF", "%s|%ld|", last_loginchan, logintime);
if (option_verbose > 1)
ast_verbose(VERBOSE_PREFIX_2 "Callback Agent '%s' logged out\n", p->agent);
ast_device_state_changed("Agent/%s", p->agent);
}
ast_mutex_unlock(&agentlock);
if (!res)
res = ast_safe_sleep(chan, 500);
ast_mutex_unlock(&p->lock);
if (persistent_agents)
dump_agents();
} else if (!res) {
#ifdef HONOR_MUSIC_CLASS
/* check if the moh class was changed with setmusiconhold */
if (*(chan->musicclass))
strncpy(p->moh, chan->musicclass, sizeof(p->moh) - 1);
#endif
ast_moh_start(chan, p->moh);
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);
if (option_verbose > 1)
ast_verbose(VERBOSE_PREFIX_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_mutex_unlock(&agentlock);
ast_device_state_changed("Agent/%s", p->agent);
while (res >= 0) {
ast_mutex_lock(&p->lock);
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_mutex_lock(&agentlock);
ast_mutex_lock(&p->lock);
if (p->lastdisc.tv_sec) {
gettimeofday(&tv, NULL);
if ((tv.tv_sec - p->lastdisc.tv_sec) * 1000 +
(tv.tv_usec - p->lastdisc.tv_usec) / 1000 > p->wrapuptime) {
if (option_debug)
ast_log(LOG_DEBUG, "Wrapup time for %s expired!\n", p->agent);
memset(&p->lastdisc, 0, sizeof(p->lastdisc));
if (p->ackcall > 1)
check_beep(p, 0);
else
check_availability(p, 0);
}
}
ast_mutex_unlock(&p->lock);
ast_mutex_unlock(&agentlock);
/* Synchronize channel ownership between call to agent and itself. */
ast_mutex_lock( &p->app_lock );
ast_mutex_lock(&p->lock);
p->owning_app = pthread_self();
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 );
ast_mutex_unlock( &p->app_lock );
if ((p->ackcall > 1) && (res == 1)) {
ast_mutex_lock(&agentlock);
ast_mutex_lock(&p->lock);
check_availability(p, 0);
ast_mutex_unlock(&p->lock);
ast_mutex_unlock(&agentlock);
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);
if (option_verbose > 1)
ast_verbose(VERBOSE_PREFIX_2 "Agent '%s' logged out\n", p->agent);
/* If there is no owner, go ahead and kill it now */
ast_device_state_changed("Agent/%s", p->agent);
if (p->dead && !p->owner) {
ast_mutex_destroy(&p->lock);
ast_mutex_destroy(&p->app_lock);
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);
p = p->next;
}
if (!p)
ast_mutex_unlock(&agentlock);
if (!res && (max_login_tries==0 || tries < max_login_tries))
res = ast_app_getdata(chan, errmsg, user, sizeof(user) - 1, 0);
}
LOCAL_USER_REMOVE(u);
if (!res)
res = ast_safe_sleep(chan, 500);
/* AgentLogin() exit */
if (!callbackmode) {
return -1;
}
/* AgentCallbackLogin() exit*/
else {
/* Set variables */
if (login_state > 0) {
pbx_builtin_setvar_helper(chan, "AGENTNUMBER", user);
if (login_state==1) {
pbx_builtin_setvar_helper(chan, "AGENTSTATUS", "on");
pbx_builtin_setvar_helper(chan, "AGENTEXTEN", exten);
}
else {
pbx_builtin_setvar_helper(chan, "AGENTSTATUS", "off");
}
}
else {
pbx_builtin_setvar_helper(chan, "AGENTSTATUS", "fail");
}
if (ast_exists_extension(chan, chan->context, chan->exten, chan->priority + 1, chan->cid.cid_num))
return 0;
/* Do we need to play agent-goodbye now that we will be hanging up? */
if (play_announcement==1) {
if (!res)
res = ast_safe_sleep(chan, 1000);
res = ast_streamfile(chan, agent_goodbye, chan->language);
if (!res)
res = ast_waitstream(chan, "");
if (!res)
res = ast_safe_sleep(chan, 1000);
}
}
/* We should never get here if next priority exists when in callbackmode */
return -1;
}
static int login_exec(struct ast_channel *chan, void *data)
{
return __login_exec(chan, data, 0);
}
static int callback_exec(struct ast_channel *chan, void *data)
{
return __login_exec(chan, data, 1);
}
static int agentmonitoroutgoing_exec(struct ast_channel *chan, void *data)
{
int exitifnoagentid = 0;
int nowarnings = 0;
int changeoutgoing = 0;
int res = 0;
char agent[AST_MAX_AGENT], *tmp;
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) {
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 = agents;
strncpy(agent, tmp, sizeof(agent) - 1);
ast_mutex_lock(&agentlock);
while (p) {
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;
}
p = p->next;
}
ast_mutex_unlock(&agentlock);
} 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");
}
/* check if there is n + 101 priority */
if (res) {
if (ast_exists_extension(chan, chan->context, chan->exten, chan->priority + 101, chan->cid.cid_num)) {
chan->priority+=100;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "Going to %d priority because there is no callerid or the agentid cannot be found.\n",chan->priority);
}
else if (exitifnoagentid)
return res;
}
return 0;
}
/* Dump AgentCallbackLogin agents to the database for persistence
* (basically copied from dump_queue_members() in apps/app_queue.c)
*/
static void dump_agents(void)
{
struct agent_pvt *cur_agent = NULL;
cur_agent = agents;
while (cur_agent) {
if (cur_agent->chan != NULL) {
cur_agent = cur_agent->next;
continue;
}
if (!ast_strlen_zero(cur_agent->loginchan)) {
if (ast_db_put(pa_family, cur_agent->agent, cur_agent->loginchan)) {
ast_log(LOG_WARNING, "failed to create persistent entry!\n");
} else {
if (option_debug) {
ast_log(LOG_DEBUG, "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);
}
cur_agent = cur_agent->next;
}
}
/* Reload the persistent agents from astdb */
static void reload_agents(void)
{
char *pa_agent_num;
struct ast_db_entry *pa_db_tree = NULL;
int pa_family_len = 0;
struct agent_pvt *cur_agent = NULL;
char agent_data[80];
pa_db_tree = ast_db_gettree(pa_family, NULL);
pa_family_len = strlen(pa_family);
ast_mutex_lock(&agentlock);
while (pa_db_tree) {
pa_agent_num = pa_db_tree->key + pa_family_len + 2;
cur_agent = agents;
while (cur_agent) {
ast_mutex_lock(&cur_agent->lock);
if (strcmp(pa_agent_num, cur_agent->agent) == 0)
break;
ast_mutex_unlock(&cur_agent->lock);
cur_agent = cur_agent->next;
}
if (!cur_agent) {
ast_db_del(pa_family, pa_agent_num);
pa_db_tree = pa_db_tree->next;
continue;
} else
ast_mutex_unlock(&cur_agent->lock);
if (!ast_db_get(pa_family, pa_agent_num, agent_data, 80)) {
if (option_debug) {
ast_log(LOG_DEBUG, "Reload Agent: %s on %s\n",
cur_agent->agent, agent_data);
}
strncpy(cur_agent->loginchan,agent_data,80);
if (cur_agent->loginstart == 0)
time(&cur_agent->loginstart);
ast_device_state_changed("Agent/%s", cur_agent->agent);
}
pa_db_tree = pa_db_tree->next;
}
ast_log(LOG_NOTICE, "Agents sucessfully reloaded from database.\n");
ast_mutex_unlock(&agentlock);
if (pa_db_tree) {
ast_db_freetree(pa_db_tree);
pa_db_tree = NULL;
}
}
/*--- agent_devicestate: Part of PBX channel interface ---*/
static int agent_devicestate(void *data)
{
struct agent_pvt *p;
char *s;
ast_group_t groupmatch;
int waitforagent=0;
int res = AST_DEVICE_INVALID;
s = data;
if ((s[0] == '@') && (sscanf(s + 1, "%d", &groupmatch) == 1)) {
groupmatch = (1 << groupmatch);
} else if ((s[0] == ':') && (sscanf(s + 1, "%d", &groupmatch) == 1)) {
groupmatch = (1 << groupmatch);
waitforagent = 1;
} else {
groupmatch = 0;
}
/* Check actual logged in agents first */
ast_mutex_lock(&agentlock);
p = agents;
while(p) {
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);
p = p->next;
}
ast_mutex_unlock(&agentlock);
return res;
}
/*--- load_module: Initialize channel module ---*/
int load_module()
{
/* Make sure we can register our agent channel type */
if (ast_channel_register_ex(channeltype, tdesc, capability, agent_request, agent_devicestate)) {
ast_log(LOG_ERROR, "Unable to register channel class %s\n", channeltype);
return -1;
}
/* Dialplan applications */
ast_register_application(app, login_exec, synopsis, descrip);
ast_register_application(app2, callback_exec, synopsis2, descrip2);
ast_register_application(app3, agentmonitoroutgoing_exec, synopsis3, descrip3);
/* Manager command */
ast_manager_register2("Agents", 0, action_agents, "Agents", mandescr_agents);
/* CLI Application */
ast_cli_register(&cli_show_agents);
/* Read in the config */
read_agent_config();
if (persistent_agents)
reload_agents();
return 0;
}
int reload()
{
read_agent_config();
if (persistent_agents)
reload_agents();
return 0;
}
int unload_module()
{
struct agent_pvt *p;
/* First, take us out of the channel loop */
/* Unregister CLI application */
ast_cli_unregister(&cli_show_agents);
/* Unregister dialplan applications */
ast_unregister_application(app);
ast_unregister_application(app2);
ast_unregister_application(app3);
/* Unregister manager command */
ast_manager_unregister("Agents");
/* Unregister channel */
ast_channel_unregister(channeltype);
if (!ast_mutex_lock(&agentlock)) {
/* Hangup all interfaces if they have an owner */
p = agents;
while(p) {
if (p->owner)
ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
p = p->next;
}
agents = NULL;
ast_mutex_unlock(&agentlock);
} else {
ast_log(LOG_WARNING, "Unable to lock the monitor\n");
return -1;
}
return 0;
}
int usecount()
{
int res;
ast_mutex_lock(&usecnt_lock);
res = usecnt;
ast_mutex_unlock(&usecnt_lock);
return res;
}
char *key()
{
return ASTERISK_GPL_KEY;
}
char *description()
{
return desc;
}
Reference in New Issue View Git Blame Copy Permalink