Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:03 2007

Asterisk developer's documentation :: Codename Pineapple

---

chan_agent.c File Reference

---

Detailed Description

Implementation of Agents (proxy channel).

Author:

Mark Spencer <markster@digium.com>

This file is the implementation of Agents modules. It is a dynamic module that is loaded by Asterisk.

See also

• Agent configuration

Definition in file chan_agent.c.

#include "asterisk.h"
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <stdlib.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/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/options.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 dependency graph for chan_agent.c:

Go to the source code of this file.

Data Structures
struct	agent_pvt
	Structure representing an agent. More...
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	GETAGENTBYCALLERID   "AGENTBYCALLERID"
#define	PA_MAX_LEN   2048
Functions
static int	__agent_start_monitoring (struct ast_channel *ast, struct agent_pvt *p, int needlock)
static int	__login_exec (struct ast_channel *chan, void *data, int callbackmode)
	Log in agent application.
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 (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 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 int	agent_logoff_cmd (int fd, int argc, char **argv)
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_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 int	agents_show (int fd, int argc, char **argv)
static int	agents_show_online (int fd, int argc, char **argv)
static int	allow_multiple_login (char *chan, char *context)
static	AST_LIST_HEAD_STATIC (agents, agent_pvt)
	AST_MODULE_INFO (ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT,"Agent Proxy Channel",.load=load_module,.unload=unload_module,.reload=reload,)
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)
static force_inline int	powerof (unsigned int d)
static int	read_agent_config (void)
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 int	ackcall
ast_custom_function	agent_function
static const char	agent_logoff_usage []
static const struct ast_channel_tech	agent_tech
	Channel interface description for PBX integration.
static char	agentgoodbye [AST_MAX_FILENAME_LEN] = "vm-goodbye"
static const char	app [] = "AgentLogin"
static const char	app3 [] = "AgentMonitorOutgoing"
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 const char	descrip []
static const char	descrip3 []
static int	endcall
static ast_group_t	group
static const char	mandescr_agent_callback_login []
static const char	mandescr_agent_logoff []
static const char	mandescr_agents []
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	show_agents_online_usage []
static const char	show_agents_usage []
static const char	synopsis [] = "Call agent login"
static const char	synopsis3 [] = "Record agent's outgoing call"
static const char	tdesc [] = "Call Agent Proxy Channel"
static int	updatecdr = 0
static char	urlprefix [AST_MAX_BUF] = ""
static int	wrapuptime

---

Define Documentation

#define AST_MAX_AGENT   80

Agent ID or Password max length Definition at line 133 of file chan_agent.c. Referenced by __login_exec(), agent_logoff_maintenance(), agentmonitoroutgoing_exec(), and complete_agent_logoff_cmd().

#define AST_MAX_BUF   256

Definition at line 134 of file chan_agent.c. Referenced by __agent_start_monitoring(), __login_exec(), agentmonitoroutgoing_exec(), agents_show(), agents_show_online(), and set_agentbycallerid().

#define AST_MAX_FILENAME_LEN   256

Definition at line 135 of file chan_agent.c. Referenced by __login_exec().

#define CHECK_FORMATS (  ast, p   )

Definition at line 194 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 217 of file chan_agent.c. Referenced by agent_call(), agent_read(), and agent_write().

#define GETAGENTBYCALLERID   "AGENTBYCALLERID"

Definition at line 162 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 138 of file chan_agent.c.

---

Function Documentation

static int __agent_start_monitoring (  struct ast_channel *  ast, struct agent_pvt *  p, int  needlock )  [static]

Definition at line 393 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, and ast_channel::monitor. 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 ? 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 __login_exec (  struct ast_channel *  chan, void *  data, int  callbackmode )  [static]

Log in agent application. Parameters: chan  data  callbackmode  non-zero for AgentCallbackLogin Definition at line 1749 of file chan_agent.c. References ast_channel::_state, agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_ack_sleep(), agent_cont_sleep(), agent_logoff_maintenance(), allow_multiple_login(), agent_pvt::app_lock, ast_answer(), AST_APP_ARG, ast_app_getdata(), ast_best_codec(), AST_CONTROL_HOLD, AST_DECLARE_APP_ARGS, ast_device_state_changed(), AST_DIGIT_ANY, ast_exists_extension(), ast_getformatname(), ast_indicate_data(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), AST_MAX_AGENT, AST_MAX_BUF, AST_MAX_FILENAME_LEN, ast_module_user_add, ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), ast_queue_log(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_set_read_format(), ast_set_write_format(), AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_strdupa, ast_streamfile(), ast_strlen_zero(), ast_true(), ast_verbose(), ast_waitstream(), agent_pvt::autologoff, ast_channel::cdr, agent_pvt::chan, ast_module_user::chan, ast_cdr::channel, check_availability(), check_beep(), ast_channel::cid, ast_callerid::cid_num, context, agent_pvt::dead, dump_agents(), EVENT_FLAG_AGENT, free, agent_pvt::lastdisc, agent_pvt::lock, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, agent_pvt::logincallerid, agent_pvt::loginchan, agent_pvt::loginstart, manager_event, agent_pvt::moh, option_debug, option_verbose, agent_pvt::owner, agent_pvt::owning_app, parse(), agent_pvt::password, pbx_builtin_getvar_helper(), agent_pvt::pending, S_OR, set_agentbycallerid(), strsep(), VERBOSE_PREFIX_2, VERBOSE_PREFIX_3, and agent_pvt::wrapuptime. Referenced by login_exec(). { 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; char *context = NULL; int play_announcement = 1; char agent_goodbye[AST_MAX_FILENAME_LEN]; int update_cdr = updatecdr; char *filename = "agent-loginok"; char tmpchan[AST_MAX_BUF] = ""; 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)); /* 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 */ if (callbackmode && args.extension) { parse = args.extension; args.extension = strsep(&parse, "@"); context = parse; } 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) { 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 */ gettimeofday(&p->lastdisc, NULL); p->lastdisc.tv_sec++; /* Set Channel Specific Agent Overrides */ 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 Overrides */ if (!p->chan) { char last_loginchan[80] = ""; long logintime; snprintf(agent, sizeof(agent), "Agent/%s", p->agent); if (callbackmode) { int pos = 0; /* Retrieve login chan */ for (;;) { if (!ast_strlen_zero(args.extension)) { ast_copy_string(tmpchan, args.extension, sizeof(tmpchan)); res = 0; } else res = ast_app_getdata(chan, "agent-newlocation", tmpchan+pos, sizeof(tmpchan) - 2, 0); if (ast_strlen_zero(tmpchan) ) break; if(ast_exists_extension(chan, S_OR(context,"default"), tmpchan,1, NULL) ) { if(!allow_multiple_login(tmpchan,context) ) { args.extension = NULL; pos = 0; } else break; } if (args.extension) { ast_log(LOG_WARNING, "Extension '%s' is not valid for automatic login of agent '%s'\n", args.extension, p->agent); args.extension = NULL; pos = 0; } else { ast_log(LOG_WARNING, "Extension '%s@%s' is not valid for automatic login of agent '%s'\n", tmpchan, S_OR(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; } } } args.extension = tmpchan; if (!res) { set_agentbycallerid(p->logincallerid, NULL); if (!ast_strlen_zero(context) && !ast_strlen_zero(tmpchan)) snprintf(p->loginchan, sizeof(p->loginchan), "%s@%s", tmpchan, context); else { ast_copy_string(last_loginchan, p->loginchan, sizeof(last_loginchan)); ast_copy_string(p->loginchan, tmpchan, sizeof(p->loginchan)); } p->acknowledged = 0; if (ast_strlen_zero(p->loginchan)) { login_state = 2; filename = "agent-loggedoff"; } else { if (chan->cid.cid_num) { ast_copy_string(p->logincallerid, chan->cid.cid_num, sizeof(p->logincallerid)); set_agentbycallerid(p->logincallerid, p->agent); } else p->logincallerid[0] = '\0'; } if(update_cdr && chan->cdr) snprintf(chan->cdr->channel, sizeof(chan->cdr->channel), "Agent/%s", p->agent); } } else { 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 (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); if (persistent_agents) dump_agents(); } else { logintime = time(NULL) - p->loginstart; p->loginstart = 0; agent_logoff_maintenance(p, last_loginchan, logintime, chan->uniqueid, NULL); if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Callback Agent '%s' logged out\n", p->agent); } AST_LIST_UNLOCK(&agents); if (!res) res = ast_safe_sleep(chan, 500); ast_mutex_unlock(&p->lock); } else 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); 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_LIST_UNLOCK(&agents); 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_LIST_LOCK(&agents); ast_mutex_lock(&p->lock); if (p->lastdisc.tv_sec) { if (ast_tvdiff_ms(ast_tvnow(), p->lastdisc) > p->wrapuptime) { if (option_debug) ast_log(LOG_DEBUG, "Wrapup time for %s expired!\n", p->agent); p->lastdisc = ast_tv(0, 0); 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 ); 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_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); 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); } 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); /* AgentLogin() exit */ if (!callbackmode) { ast_module_user_remove(u); return -1; } else { /* AgentCallbackLogin() exit*/ /* 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", args.extension); } 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)) { ast_module_user_remove(u); return 0; } /* Do we need to play agent-goodbye now that we will be hanging up? */ if (play_announcement) { 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); } } ast_module_user_remove(u); /* We should never get here if next priority exists when in callbackmode */ return -1; }

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. Parameters: s  m  Returns: See also: action_agents(), action_agent_callback_login(), load_module(). Definition at line 1553 of file chan_agent.c. References agent_pvt::agent, agent_logoff(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), astman_send_error(), and s. 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. Parameters: s  m  Returns: See also: action_agent_logoff(), action_agent_callback_login(), load_module(). Definition at line 1392 of file chan_agent.c. References ast_channel::_bridge, agent_pvt::acknowledged, agent_pvt::agent, 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, agent_pvt::name, agent_pvt::owner, s, and S_OR. 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 *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; 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) { talkingtoChan = p->chan->cid.cid_num; status = "AGENT_ONCALL"; } else { talkingtoChan = "n/a"; status = "AGENT_IDLE"; } } else { loginChan = "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" "%s" "\r\n", p->agent, username, status, loginChan, (int)p->loginstart, 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 (  char *  agent, int  pending )  [static]

Adds an agent to the global list of agents. Parameters: 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. Returns: The just created agent. See also: agent_pvt, agents. Definition at line 277 of file chan_agent.c. References agent_pvt::ackcall, agent_pvt::agent, AST_APP_ARG, ast_calloc, AST_DECLARE_APP_ARGS, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_mutex_init(), AST_NONSTANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), agent_pvt::autologoff, agent_pvt::dead, agent_pvt::lastdisc, LOG_WARNING, agent_pvt::moh, agent_pvt::name, parse(), agent_pvt::password, 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_NONSTANDARD_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); p->owning_app = (pthread_t) -1; 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)); p->ackcall = ackcall; p->autologoff = autologoff; /* If someone reduces the wrapuptime and reloads, we want it * to change the wrapuptime immediately on all calls */ if (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 840 of file chan_agent.c. References agent_pvt::app_sleep_cond, AST_FRAME_DTMF, ast_frfree(), ast_mutex_lock(), ast_mutex_unlock(), ast_read(), ast_waitfor(), agent_pvt::chan, 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 == '#') { 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 387 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]

Definition at line 881 of file chan_agent.c. References ast_channel::_bridge, ast_log(), agent_pvt::chan, LOG_DEBUG, option_debug, 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; } if (option_debug) ast_log(LOG_DEBUG, "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 623 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_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_verbose(), ast_waitstream(), agent_pvt::chan, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, CLEANUP, agent_pvt::lock, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, agent_pvt::loginchan, ast_channel::nativeformats, option_debug, option_verbose, agent_pvt::pending, agent_pvt::start, ast_channel::tech_pvt, and VERBOSE_PREFIX_3. { 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) { if (option_debug) 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); 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_verbose( VERBOSE_PREFIX_3 "agent_call, call to agent '%s' call on '%s'\n", p->agent, p->chan->name); if (option_debug > 2) ast_log(LOG_DEBUG, "Playing beep, lang '%s'\n", p->chan->language); res = ast_streamfile(p->chan, beep, p->chan->language); if (option_debug > 2) ast_log(LOG_DEBUG, "Played beep, result '%d'\n", res); if (!res) { res = ast_waitstream(p->chan, ""); if (option_debug > 2) 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)); if (option_debug > 2) 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) { res = ast_set_write_format(p->chan, ast_best_codec(p->chan->nativeformats)); if (option_debug > 2) 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_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. Parameters: p  Agent to be deleted. Returns: Always 0. Definition at line 367 of file chan_agent.c. References agent_pvt::app_lock, agent_pvt::app_sleep_cond, ast_channel_free(), ast_mutex_destroy(), ast_mutex_unlock(), agent_pvt::chan, agent_pvt::dead, free, 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). */ 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 agent_cont_sleep (  void *  data  )  [static]

Definition at line 819 of file chan_agent.c. References agent_pvt::app_sleep_cond, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), agent_pvt::lastdisc, agent_pvt::lock, LOG_DEBUG, option_debug, and agent_pvt::wrapuptime. 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) > p->wrapuptime) res = 1; } ast_mutex_unlock(&p->lock); if (option_debug > 4 && !res) ast_log(LOG_DEBUG, "agent_cont_sleep() returning %d\n", res ); return res; }

static int agent_devicestate (  void *  data  )  [static]

Part of PBX channel interface. Definition at line 2329 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 waitforagent=0; int res = AST_DEVICE_INVALID; s = data; if ((s[0] == '@') && (sscanf(s + 1, "%d", &groupoff) == 1)) groupmatch = (1 << groupoff); else if ((s[0] == ':') && (sscanf(s + 1, "%d", &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))) { 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 603 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; int res = -1; ast_mutex_lock(&p->lock); ast_senddigit_begin(p->chan, digit); ast_mutex_unlock(&p->lock); return res; }

static int agent_digit_end (  struct ast_channel *  ast, char  digit, unsigned int  duration )  [static]

Definition at line 613 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; int res = -1; ast_mutex_lock(&p->lock); ast_senddigit_end(p->chan, digit, duration); ast_mutex_unlock(&p->lock); return res; }

static int agent_fixup (  struct ast_channel *  oldchan, struct ast_channel *  newchan )  [static]

Definition at line 576 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; }

static int agent_hangup (  struct ast_channel *  ast  )  [static]

Definition at line 718 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_lock, agent_pvt::app_sleep_cond, ast_channel_lock, ast_channel_unlock, AST_CONTROL_HOLD, ast_device_state_changed(), 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_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_state2str(), AST_STATE_RESERVED, AST_STATE_UP, ast_strlen_zero(), ast_tvadd(), agent_pvt::autologoff, agent_pvt::chan, agent_pvt::dead, free, agent_pvt::lastdisc, agent_pvt::lock, LOG_DEBUG, LOG_NOTICE, agent_pvt::loginchan, agent_pvt::loginstart, agent_pvt::moh, agent_pvt::name, option_debug, agent_pvt::owner, pbx_builtin_getvar_helper(), agent_pvt::pending, S_OR, agent_pvt::start, ast_channel::tech_pvt, 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() */ if (option_debug) 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) { 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; } if (option_debug) ast_log(LOG_DEBUG, "Hungup, howlong is %d, autologoff is %d\n", howlong, p->autologoff); if (howlong && p->autologoff && (howlong > p->autologoff)) { 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); agent_logoff_maintenance(p, p->loginchan, logintime, ast->uniqueid, "Autologoff"); } } 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) ast_device_state_changed("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); free(p); } else { if (p->chan) { /* Not dead -- check availability now */ ast_mutex_lock(&p->lock); /* Store last disconnect time */ p->lastdisc = ast_tvnow(); ast_mutex_unlock(&p->lock); } /* Release ownership of the agent to other threads (presumably running the login app). */ if (ast_strlen_zero(p->loginchan)) ast_mutex_unlock(&p->app_lock); } return 0; }

static int agent_indicate (  struct ast_channel *  ast, int  condition, const void *  data, size_t  datalen )  [static]

Definition at line 590 of file chan_agent.c. References ast_indicate_data(), 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_indicate_data(p->chan, condition, data, datalen); else res = 0; ast_mutex_unlock(&p->lock); return res; }

static int agent_logoff (  const char *  agent, int  soft )  [static]

Definition at line 1502 of file chan_agent.c. References agent_pvt::agent, agent_logoff_maintenance(), AST_LIST_TRAVERSE, ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, agent_pvt::chan, 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_TRAVERSE(&agents, p, list) { if (!strcasecmp(p->agent, agent)) { if (!soft) { if (p->owner) ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT); if (p->chan) ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT); } ret = 0; /* found an agent => return 0 */ logintime = time(NULL) - p->loginstart; p->loginstart = 0; agent_logoff_maintenance(p, p->loginchan, logintime, NULL, "CommandLogoff"); break; } } return ret; }

static int agent_logoff_cmd (  int  fd, int  argc, char **  argv )  [static]

Definition at line 1527 of file chan_agent.c. References agent_pvt::agent, agent_logoff(), ast_cli(), RESULT_SHOWUSAGE, and RESULT_SUCCESS. { int ret; char *agent; if (argc < 3 || argc > 4) return RESULT_SHOWUSAGE; if (argc == 4 && strcasecmp(argv[3], "soft")) return RESULT_SHOWUSAGE; agent = argv[2] + 6; ret = agent_logoff(agent, argc == 4); if (ret == 0) ast_cli(fd, "Logging out %s\n", agent); return RESULT_SUCCESS; }

static void agent_logoff_maintenance (  struct agent_pvt *  p, char *  loginchan, long  logintime, const char *  uniqueid, char *  logcommand )  [static]

Definition at line 1463 of file chan_agent.c. References agent_pvt::agent, ast_device_state_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 __login_exec(), 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_device_state_changed("Agent/%s", p->agent); if (persistent_agents) dump_agents(); }

static struct ast_channel* agent_new (  struct agent_pvt *  p, int  state )  [static]

Create new agent channel. Definition at line 899 of file chan_agent.c. References agent_pvt::agent, agent_tech, agent_pvt::app_lock, agent_pvt::app_sleep_cond, ast_channel_alloc(), ast_channel_free(), AST_CONTROL_UNHOLD, AST_FLAG_BLOCKING, AST_FORMAT_SLINEAR, ast_indicate(), ast_log(), ast_mutex_lock(), ast_mutex_trylock(), ast_mutex_unlock(), ast_null_frame, ast_queue_frame(), ast_random(), ast_string_field_set, ast_strlen_zero(), ast_test_flag, agent_pvt::chan, ast_channel::context, CRASH, ast_channel::exten, language, agent_pvt::lock, LOG_ERROR, LOG_WARNING, agent_pvt::loginchan, ast_channel::nativeformats, agent_pvt::owner, agent_pvt::owning_app, 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; #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, "Agent/P%s-%d", p->agent, ast_random() & 0xffff); else tmp = ast_channel_alloc(0, state, 0, 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; if(ast_strlen_zero(p->loginchan) && ast_mutex_trylock(&p->app_lock)) { if (p->chan) { ast_queue_frame(p->chan, &ast_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); } 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. */ ast_mutex_unlock(&p->app_lock); 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; } } ast_indicate(p->chan, AST_CONTROL_UNHOLD); 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; } } return tmp; }

static struct ast_frame * agent_read (  struct ast_channel *  ast  )  [static]

Definition at line 426 of file chan_agent.c. References ast_channel::_bridge, ast_channel::_state, agent_pvt::ackcall, agent_pvt::acknowledged, agent_logoff_maintenance(), agent_start_monitoring(), AST_AGENT_FD, AST_CONTROL_ANSWER, ast_copy_flags, 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_STATE_UP, ast_strlen_zero(), AST_TIMING_FD, ast_tvadd(), ast_verbose(), agent_pvt::chan, CHECK_FORMATS, CLEANUP, ast_channel::fdno, ast_frame::frametype, agent_pvt::lastdisc, agent_pvt::lock, LOG_DEBUG, LOG_NOTICE, agent_pvt::loginchan, agent_pvt::loginstart, agent_pvt::name, option_debug, option_verbose, pbx_builtin_getvar_helper(), ast_frame::subclass, ast_channel::tech, ast_channel::tech_pvt, ast_channel_tech::type, VERBOSE_PREFIX_3, 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; ast_mutex_lock(&p->lock); CHECK_FORMATS(ast, p); 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 && option_debug) ast_log(LOG_DEBUG, "Bridge on '%s' being cleared (2)\n", p->chan->name); 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 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; 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; switch (f->frametype) { case AST_FRAME_CONTROL: if (f->subclass == AST_CONTROL_ANSWER) { 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 = &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: case AST_FRAME_DTMF_END: if (!p->acknowledged && (f->subclass == '#')) { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "%s acknowledged\n", p->chan->name); p->acknowledged = 1; ast_frfree(f); f = &answer_frame; } else if (f->subclass == '*' && 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 && option_debug) ast_log(LOG_DEBUG, "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]

Part of the Asterisk PBX interface. Definition at line 1279 of file chan_agent.c. References add_agent(), agent_pvt::agent, agent_new(), AST_CAUSE_BUSY, AST_CAUSE_UNREGISTERED, 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(), agent_pvt::chan, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, agent_pvt::loginchan, option_debug, 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 tv; s = data; if ((s[0] == '@') && (sscanf(s + 1, "%d", &groupoff) == 1)) { groupmatch = (1 << groupoff); } else if ((s[0] == ':') && (sscanf(s + 1, "%d", &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++; 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); } 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++; tv = ast_tvnow(); #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)) { 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) { 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 { if (option_debug) ast_log(LOG_DEBUG, "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 528 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 539 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; }

static int agent_start_monitoring (  struct ast_channel *  ast, int  needlock )  [static]

Definition at line 421 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 550 of file chan_agent.c. References AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_write(), agent_pvt::chan, CHECK_FORMATS, CLEANUP, ast_frame::frametype, agent_pvt::lock, LOG_DEBUG, option_debug, 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 { if (option_debug) ast_log(LOG_DEBUG, "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). Parameters: chan  data  Returns: See also: login_exec(), callback_login_exec(), load_module(). Todo: XXX Needs to check option priorityjump etc etc Definition at line 2193 of file chan_agent.c. References __agent_start_monitoring(), agent_pvt::agent, ast_exists_extension(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), AST_MAX_AGENT, AST_MAX_BUF, ast_verbose(), ast_channel::cdr, agent_pvt::chan, ast_module_user::chan, ast_cdr::channel, ast_channel::cid, ast_callerid::cid_num, ast_channel::context, GETAGENTBYCALLERID, LOG_WARNING, option_verbose, pbx_builtin_getvar_helper(), and VERBOSE_PREFIX_3. 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"); } /* check if there is n + 101 priority */ /*! \todo XXX Needs to check option priorityjump etc etc */ 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; }

static int agents_show (  int  fd, int  argc, char **  argv )  [static]

Show agents in cli. < Number of agents configured < Number of online agents < Number of offline agents Definition at line 1596 of file chan_agent.c. References agent_pvt::acknowledged, agent_pvt::agent, 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, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::moh, agent_pvt::name, agent_pvt::owner, agent_pvt::pending, powerof(), RESULT_SHOWUSAGE, and RESULT_SUCCESS. { struct agent_pvt *p; char username[AST_MAX_BUF]; char location[AST_MAX_BUF] = ""; char talkingto[AST_MAX_BUF] = ""; char moh[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 */ if (argc != 2) return RESULT_SHOWUSAGE; AST_LIST_LOCK(&agents); AST_LIST_TRAVERSE(&agents, p, list) { 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 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(moh, sizeof(moh), " (musiconhold is '%s')", p->moh); ast_cli(fd, "%-12.12s %s%s%s%s\n", p->agent, username, location, talkingto, moh); count_agents++; } ast_mutex_unlock(&p->lock); } AST_LIST_UNLOCK(&agents); if ( !count_agents ) ast_cli(fd, "No Agents are configured in %s\n",config); else ast_cli(fd, "%d agents configured [%d online , %d offline]\n",count_agents, online_agents, offline_agents); ast_cli(fd, "\n"); return RESULT_SUCCESS; }

static int agents_show_online (  int  fd, int  argc, char **  argv )  [static]

Definition at line 1661 of file chan_agent.c. References agent_pvt::acknowledged, agent_pvt::agent, 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, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::moh, agent_pvt::name, agent_pvt::owner, RESULT_SHOWUSAGE, and RESULT_SUCCESS. { struct agent_pvt *p; char username[AST_MAX_BUF]; char location[AST_MAX_BUF] = ""; char talkingto[AST_MAX_BUF] = ""; char moh[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 */ if (argc != 3) return RESULT_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(moh, sizeof(moh), " (musiconhold is '%s')", p->moh); if (agent_status) ast_cli(fd, "%-12.12s %s%s%s%s\n", p->agent, username, location, talkingto, moh); count_agents++; ast_mutex_unlock(&p->lock); } AST_LIST_UNLOCK(&agents); if (!count_agents) ast_cli(fd, "No Agents are configured in %s\n", config); else ast_cli(fd, "%d agents online\n", online_agents); ast_cli(fd, "\n"); return RESULT_SUCCESS; }

static int allow_multiple_login (  char *  chan, char *  context )  [static]

Definition at line 1259 of file chan_agent.c. References AST_LIST_TRAVERSE, agent_pvt::loginchan, and S_OR. Referenced by __login_exec(). { struct agent_pvt *p; char loginchan[80]; if(multiplelogin) return 1; if(!chan) return 0; snprintf(loginchan, sizeof(loginchan), "%s@%s", chan, S_OR(context, "default")); AST_LIST_TRAVERSE(&agents, p, list) { if(!strcasecmp(chan, p->loginchan)) return 0; } return -1; }

static AST_LIST_HEAD_STATIC (  agents  , agent_pvt  )  [static]

Holds the list of agents (loaded form agents.conf).

AST_MODULE_INFO (  ASTERISK_GPL_KEY  , AST_MODFLAG_DEFAULT  , "Agent Proxy Channel"  , .  load = load_module, .  unload = unload_module, .  reload = reload )

static int check_availability (  struct agent_pvt *  newlyavailable, int  needlock )  [static]

Definition at line 1143 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_FLAG_ZOMBIE, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), 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, agent_pvt::lock, LOG_DEBUG, option_debug, agent_pvt::owner, and agent_pvt::pending. Referenced by __login_exec(). { 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_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))) { 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); } if (needlock) AST_LIST_UNLOCK(&agents); 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, ""); if (option_debug) 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); 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_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 )  [static]

Definition at line 1217 of file chan_agent.c. References agent_pvt::abouttograb, agent_pvt::agent, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_streamfile(), ast_waitstream(), agent_pvt::chan, agent_pvt::group, agent_pvt::lock, LOG_DEBUG, option_debug, agent_pvt::owner, and agent_pvt::pending. Referenced by __login_exec(). { struct agent_pvt *p; int res=0; if (option_debug) ast_log(LOG_DEBUG, "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))) { 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); } if (needlock) AST_LIST_UNLOCK(&agents); 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; }

static char* complete_agent_logoff_cmd (  const char *  line, const char *  word, int  pos, int  state )  [static]

Definition at line 1575 of file chan_agent.c. References agent_pvt::agent, AST_LIST_TRAVERSE, AST_MAX_AGENT, ast_strdup, len, and name. { if (pos == 2) { struct agent_pvt *p; char name[AST_MAX_AGENT]; int which = 0, len = strlen(word); AST_LIST_TRAVERSE(&agents, p, list) { snprintf(name, sizeof(name), "Agent/%s", p->agent); if (!strncasecmp(word, name, len) && ++which > state) return ast_strdup(name); } } else if (pos == 3 && state == 0) return ast_strdup("soft"); return NULL; }

static void dump_agents (  void   )  [static]

Dump AgentCallbackLogin agents to the ASTdb database for persistence. Definition at line 2252 of file chan_agent.c. References agent_pvt::agent, ast_db_del(), ast_db_put(), AST_LIST_TRAVERSE, ast_log(), ast_strlen_zero(), agent_pvt::chan, LOG_DEBUG, LOG_WARNING, agent_pvt::logincallerid, agent_pvt::loginchan, and option_debug. Referenced by __login_exec(), 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 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); } } }

static struct agent_pvt* find_agent (  char *  agentid  )  [static]

Definition at line 2375 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 2387 of file chan_agent.c. References agent_pvt::agent, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log(), AST_NONSTANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), find_agent(), LOG_WARNING, and parse(). { 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"; if (!(agent = find_agent(args.agentid))) { 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_copy_string(buf, agent->chan->name, len); tmp = strrchr(buf, '-'); if (tmp) *tmp = '\0'; } } else if (!strcasecmp(args.item, "exten")) ast_copy_string(buf, agent->loginchan, len); 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. Returns: int Always 0. Definition at line 2462 of file chan_agent.c. References action_agent_logoff(), action_agents(), agent_function, agent_tech, agentmonitoroutgoing_exec(), ast_channel_register(), ast_cli_register_multiple(), ast_custom_function_register(), ast_log(), ast_manager_register2(), AST_MODULE_LOAD_DECLINE, ast_register_application(), 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 -1; } /* Read in the config */ if (!read_agent_config()) return AST_MODULE_LOAD_DECLINE; if (persistent_agents) reload_agents(); /* Dialplan applications */ ast_register_application(app, login_exec, synopsis, descrip); ast_register_application(app3, agentmonitoroutgoing_exec, synopsis3, descrip3); /* 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, sizeof(cli_agents) / sizeof(struct ast_cli_entry)); /* Dialplan Functions */ ast_custom_function_register(&agent_function); return 0; }

static int login_exec (  struct ast_channel *  chan, void *  data )  [static]

Called by the AgentLogin application (from the dial plan). Parameters: chan  data  Returns: See also: callback_login_exec(), agentmonitoroutgoing_exec(), load_module(). Definition at line 2180 of file chan_agent.c. References __login_exec(), and ast_module_user::chan. Referenced by load_module(). { return __login_exec(chan, data, 0); }

static force_inline int powerof (  unsigned int  d  )  [static]

Definition at line 1374 of file chan_agent.c. { int x = ffs(d); if (x) return x - 1; return 0; }

static int read_agent_config (  void   )  [static]

Read configuration data. The file named agents.conf. Returns: Always 0, or so it seems. Definition at line 994 of file chan_agent.c. References add_agent(), agent_pvt::app_lock, ast_category_browse(), ast_config_destroy(), ast_config_load(), 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, agent_pvt::dead, free, agent_pvt::lock, 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; group = 0; autologoff = 0; wrapuptime = 0; ackcall = 0; endcall = 1; cfg = ast_config_load(config); if (!cfg) { ast_log(LOG_NOTICE, "No agent configuration found -- agent support disabled\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, "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 = ast_config_load("users.conf"))) { 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(&agents, list); /* 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); } } } } AST_LIST_TRAVERSE_SAFE_END AST_LIST_UNLOCK(&agents); ast_config_destroy(cfg); return 1; }

static int reload (  void   )  [static]

Definition at line 2491 of file chan_agent.c. References read_agent_config(), and reload_agents(). { read_agent_config(); if (persistent_agents) reload_agents(); return 0; }

static void reload_agents (  void   )  [static]

Reload the persistent agents from astdb. Definition at line 2277 of file chan_agent.c. References agent_pvt::agent, ast_db_del(), ast_db_get(), ast_db_gettree(), ast_device_state_changed(), AST_LIST_LOCK, AST_LIST_TRAVERSE, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_db_entry::key, agent_pvt::lock, LOG_DEBUG, agent_pvt::logincallerid, agent_pvt::loginchan, agent_pvt::loginstart, ast_db_entry::next, option_debug, 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)) { if (option_debug) ast_log(LOG_DEBUG, "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_device_state_changed("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 706 of file chan_agent.c. References AST_MAX_BUF, ast_strlen_zero(), GETAGENTBYCALLERID, and pbx_builtin_setvar_helper(). Referenced by __login_exec(), 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 2499 of file chan_agent.c. References agent_function, agent_tech, ast_channel_unregister(), ast_cli_unregister_multiple(), ast_custom_function_unregister(), AST_LIST_HEAD_DESTROY, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_manager_unregister(), ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, ast_unregister_application(), cli_agents, free, 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, sizeof(cli_agents) / sizeof(struct ast_cli_entry)); /* 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); free(p); } AST_LIST_UNLOCK(&agents); AST_LIST_HEAD_DESTROY(&agents); return 0; }

---

Variable Documentation

int ackcall [static]

Definition at line 146 of file chan_agent.c.

struct ast_custom_function agent_function

Definition at line 2439 of file chan_agent.c. Referenced by load_module(), and unload_module().

const char agent_logoff_usage[] [static]

Initial value: "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" Definition at line 1723 of file chan_agent.c.

const struct ast_channel_tech agent_tech [static]

Channel interface description for PBX integration. Definition at line 247 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 152 of file chan_agent.c.

const char app[] = "AgentLogin" [static]

Definition at line 79 of file chan_agent.c. Referenced by action_originate(), add_extensions(), answer_exec_enable(), ast_pbx_run_app(), async_wait(), check_app_args(), check_pval_item(), feature_exec_app(), handle_context_add_extension(), handle_exec(), load_module(), pbx_builtin_execiftime(), pbx_exec(), pbx_extension_helper(), realtime_exec(), unload_module(), and unreference_cached_app().

const char app3[] = "AgentMonitorOutgoing" [static]

Definition at line 80 of file chan_agent.c.

int autologoff [static]

Definition at line 144 of file chan_agent.c.

int autologoffunavail = 0 [static]

Definition at line 149 of file chan_agent.c.

char beep[AST_MAX_BUF] = "beep" [static]

Definition at line 160 of file chan_agent.c.

struct ast_cli_entry cli_agents[] [static]

Definition at line 1728 of file chan_agent.c. Referenced by load_module(), and unload_module().

const char config[] = "agents.conf" [static]

Definition at line 77 of file chan_agent.c. Referenced by ast_bridge_call(), ast_category_append(), ast_category_browse(), ast_category_exist(), ast_category_get(), ast_channel_bridge(), ast_config_new(), ast_feature_interpret(), ast_generic_bridge(), ast_readconfig(), ast_variable_browse(), ast_variable_retrieve(), builtin_atxfer(), category_get(), do_reload(), handle_save_dialplan(), load_module(), load_odbc_config(), misdn_cfg_init(), park_exec(), parse_config(), pbx_load_module(), read_config_maps(), reload(), reload_config(), and set_config_flags().

const char descrip[] [static]

Definition at line 85 of file chan_agent.c. Referenced by aji_handle_presence(), and load_module().

const char descrip3[] [static]

Definition at line 94 of file chan_agent.c.

int endcall [static]

Definition at line 147 of file chan_agent.c.

ast_group_t group [static]

Definition at line 143 of file chan_agent.c. Referenced by ast_app_group_set_channel(), ast_get_group(), ast_makesocket(), and misdn_request().

const char mandescr_agent_callback_login[] [static]

Definition at line 122 of file chan_agent.c.

const char mandescr_agent_logoff[] [static]

Initial value: "Description: Sets an agent as no longer logged in.\n" "Variables: (Names marked with * are required)\n" " *Agent: Agent ID of the agent to log off\n" " Soft: Set to 'true' to not hangup existing calls\n" Definition at line 116 of file chan_agent.c.

const char mandescr_agents[] [static]

Initial value: "Description: Will list info about all possible agents.\n" "Variables: NONE\n" Definition at line 112 of file chan_agent.c.

int maxlogintries = 3 [static]

Definition at line 151 of file chan_agent.c.

char moh[80] = "default" [static]

Definition at line 131 of file chan_agent.c. Referenced by ast_moh_destroy(), get_mohbyname(), init_classes(), moh_generate(), moh_register(), moh_release(), mohalloc(), and monmp3thread().

int multiplelogin = 1 [static]

Definition at line 148 of file chan_agent.c.

const char pa_family[] = "/Agents" [static]

Persistent Agents astdb family Definition at line 137 of file chan_agent.c.

int persistent_agents = 0 [static]

queues.conf [general] option Definition at line 140 of file chan_agent.c.

int recorda