chan_agent.c File Reference

Implementation of Agents (proxy channel). More...

#include "asterisk.h"
#include <sys/socket.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/signal.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/rtp.h"
#include "asterisk/acl.h"
#include "asterisk/callerid.h"
#include "asterisk/file.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/musiconhold.h"
#include "asterisk/manager.h"
#include "asterisk/features.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/astdb.h"
#include "asterisk/devicestate.h"
#include "asterisk/monitor.h"
#include "asterisk/stringfields.h"
#include "asterisk/event.h"

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...
struct	agents
Defines
#define	AST_MAX_AGENT   80
#define	AST_MAX_BUF   256
#define	AST_MAX_FILENAME_LEN   256
#define	CHECK_FORMATS(ast, p)
#define	CLEANUP(ast, p)
	Cleanup moves all the relevant FD's from the 2nd to the first, but retains things properly for a timingfd XXX This might need more work if agents were logged in as agents or other totally impractical combinations XXX.
#define	DEFAULT_ACCEPTDTMF   '#'
#define	DEFAULT_ENDDTMF   '*'
#define	GETAGENTBYCALLERID   "AGENTBYCALLERID"
#define	PA_MAX_LEN   2048
Enumerations
enum	{   AGENT_FLAG_ACKCALL = (1 << 0), AGENT_FLAG_AUTOLOGOFF = (1 << 1), AGENT_FLAG_WRAPUPTIME = (1 << 2), AGENT_FLAG_ACCEPTDTMF = (1 << 3),   AGENT_FLAG_ENDDTMF = (1 << 4) }
Functions
static int	__agent_start_monitoring (struct ast_channel *ast, struct agent_pvt *p, int needlock)
static void	__reg_module (void)
static void	__unreg_module (void)
static int	action_agent_logoff (struct mansession *s, const struct message *m)
static int	action_agents (struct mansession *s, const struct message *m)
static struct agent_pvt *	add_agent (const char *agent, int pending)
static int	agent_ack_sleep (void *data)
static int	agent_answer (struct ast_channel *ast)
static struct ast_channel *	agent_bridgedchannel (struct ast_channel *chan, struct ast_channel *bridge)
static int	agent_call (struct ast_channel *ast, char *dest, int timeout)
static int	agent_cleanup (struct agent_pvt *p)
static int	agent_cont_sleep (void *data)
static int	agent_devicestate (void *data)
	Part of PBX channel interface.
static int	agent_digit_begin (struct ast_channel *ast, char digit)
static int	agent_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
static int	agent_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
static struct ast_channel *	agent_get_base_channel (struct ast_channel *chan)
	return the channel or base channel if one exists. This function assumes the channel it is called on is already locked
static int	agent_hangup (struct ast_channel *ast)
static int	agent_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen)
static int	agent_logoff (const char *agent, int soft)
static char *	agent_logoff_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	agent_logoff_maintenance (struct agent_pvt *p, char *loginchan, long logintime, const char *uniqueid, char *logcommand)
static struct ast_channel *	agent_new (struct agent_pvt *p, int state)
	Create new agent channel.
static struct ast_frame *	agent_read (struct ast_channel *ast)
static struct ast_channel *	agent_request (const char *type, int format, void *data, int *cause)
	Part of the Asterisk PBX interface.
static int	agent_sendhtml (struct ast_channel *ast, int subclass, const char *data, int datalen)
static int	agent_sendtext (struct ast_channel *ast, const char *text)
static int	agent_set_base_channel (struct ast_channel *chan, struct ast_channel *base)
static int	agent_start_monitoring (struct ast_channel *ast, int needlock)
static int	agent_write (struct ast_channel *ast, struct ast_frame *f)
static int	agentmonitoroutgoing_exec (struct ast_channel *chan, void *data)
	Called by the AgentMonitorOutgoing application (from the dial plan).
static char *	agents_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	agents_show_online (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	check_availability (struct agent_pvt *newlyavailable, int needlock)
static int	check_beep (struct agent_pvt *newlyavailable, int needlock)
static char *	complete_agent_logoff_cmd (const char *line, const char *word, int pos, int state)
static void	dump_agents (void)
	Dump AgentCallbackLogin agents to the ASTdb database for persistence.
static struct agent_pvt *	find_agent (char *agentid)
static int	function_agent (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	load_module (void)
	Initialize the Agents module. This function is being called by Asterisk when loading the module. Among other things it registers applications, cli commands and reads the cofiguration file.
static int	login_exec (struct ast_channel *chan, void *data)
	Log in agent application.
static force_inline int	powerof (unsigned int d)
static int	read_agent_config (int reload)
static int	reload (void)
static void	reload_agents (void)
	Reload the persistent agents from astdb.
static void	set_agentbycallerid (const char *callerid, const char *agent)
	store/clear the global variable that stores agentid based on the callerid
static int	unload_module (void)
Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Agent Proxy Channel" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "0901e4e500243c855563a2d78b0c03e4" , .load = load_module, .unload = unload_module, .reload = reload, }
static char	acceptdtmf = DEFAULT_ACCEPTDTMF
static int	ackcall
struct ast_custom_function	agent_function
static const char	agent_logoff_usage []
static 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 struct ast_module_info *	ast_module_info = &__mod_info
static int	autologoff
static int	autologoffunavail = 0
static char	beep [AST_MAX_BUF] = "beep"
static struct ast_cli_entry	cli_agents []
static const char	config [] = "agents.conf"
static int	endcall
static char	enddtmf = DEFAULT_ENDDTMF
static ast_group_t	group
static const char	mandescr_agent_logoff []
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	tdesc [] = "Call Agent Proxy Channel"
static int	updatecdr = 0
static char	urlprefix [AST_MAX_BUF] = ""
static int	wrapuptime

---

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.

---

Define Documentation

#define AST_MAX_AGENT   80

Agent ID or Password max length

Definition at line 191 of file chan_agent.c.

Referenced by agent_logoff_maintenance(), agentmonitoroutgoing_exec(), complete_agent_logoff_cmd(), and login_exec().

#define AST_MAX_BUF   256

Definition at line 192 of file chan_agent.c.

Referenced by __agent_start_monitoring(), agentmonitoroutgoing_exec(), agents_show(), agents_show_online(), and set_agentbycallerid().

#define AST_MAX_FILENAME_LEN   256

Definition at line 193 of file chan_agent.c.

Referenced by login_exec().

#define CHECK_FORMATS	(	ast,
		p		)

Definition at line 270 of file chan_agent.c.

Referenced by agent_read(), and agent_write().

#define CLEANUP	(	ast,
		p		)

Cleanup moves all the relevant FD's from the 2nd to the first, but retains things properly for a timingfd XXX This might need more work if agents were logged in as agents or other totally impractical combinations XXX.

Definition at line 291 of file chan_agent.c.

Referenced by agent_call(), agent_read(), and agent_write().

#define DEFAULT_ACCEPTDTMF   '#'

Definition at line 201 of file chan_agent.c.

#define DEFAULT_ENDDTMF   '*'

Definition at line 202 of file chan_agent.c.

#define GETAGENTBYCALLERID   "AGENTBYCALLERID"

Definition at line 225 of file chan_agent.c.

Referenced by agentmonitoroutgoing_exec(), and set_agentbycallerid().

#define PA_MAX_LEN   2048

The maximum length of each persistent member agent database entry

Definition at line 196 of file chan_agent.c.

---

Enumeration Type Documentation

anonymous enum

Enumerator:

AGENT_FLAG_ACKCALL
AGENT_FLAG_AUTOLOGOFF
AGENT_FLAG_WRAPUPTIME
AGENT_FLAG_ACCEPTDTMF
AGENT_FLAG_ENDDTMF

Definition at line 227 of file chan_agent.c.

     {
   AGENT_FLAG_ACKCALL = (1 << 0),
   AGENT_FLAG_AUTOLOGOFF = (1 << 1),
   AGENT_FLAG_WRAPUPTIME = (1 << 2),
   AGENT_FLAG_ACCEPTDTMF = (1 << 3),
   AGENT_FLAG_ENDDTMF = (1 << 4),
};

---

Function Documentation

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

Definition at line 486 of file chan_agent.c.

References agent_pvt::agent, ast_cdr_alloc(), ast_cdr_setuserfield(), ast_log(), AST_MAX_BUF, ast_monitor_setjoinfiles(), ast_monitor_start(), ast_verbose, ast_channel::cdr, LOG_ERROR, ast_channel::monitor, ast_channel::uniqueid, X_REC_IN, and X_REC_OUT.

Referenced by agent_start_monitoring(), and agentmonitoroutgoing_exec().

{
   char tmp[AST_MAX_BUF],tmp2[AST_MAX_BUF], *pointer;
   char filename[AST_MAX_BUF];
   int res = -1;
   if (!p)
      return -1;
   if (!ast->monitor) {
      snprintf(filename, sizeof(filename), "agent-%s-%s",p->agent, ast->uniqueid);
      /* substitute . for - */
      if ((pointer = strchr(filename, '.')))
         *pointer = '-';
      snprintf(tmp, sizeof(tmp), "%s%s", savecallsin, filename);
      ast_monitor_start(ast, recordformat, tmp, needlock, X_REC_IN | X_REC_OUT);
      ast_monitor_setjoinfiles(ast, 1);
      snprintf(tmp2, sizeof(tmp2), "%s%s.%s", urlprefix, filename, recordformatext);
#if 0
      ast_verbose("name is %s, link is %s\n",tmp, tmp2);
#endif
      if (!ast->cdr)
         ast->cdr = ast_cdr_alloc();
      ast_cdr_setuserfield(ast, tmp2);
      res = 0;
   } else
      ast_log(LOG_ERROR, "Recording already started on that call.\n");
   return res;
}

static void __reg_module

(

void

)

[static]

Definition at line 2636 of file chan_agent.c.

static void __unreg_module

(

void

)

[static]

Definition at line 2636 of file chan_agent.c.

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

Sets an agent as no longer logged in in the Manager API. It is registered on load_module() and it gets called by the manager backend.

Parameters:

	s
	m

Returns:

See also:

action_agents(), load_module().

Definition at line 1768 of file chan_agent.c.

References agent_pvt::agent, agent_logoff(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), and astman_send_error().

Referenced by load_module().

{
   const char *agent = astman_get_header(m, "Agent");
   const char *soft_s = astman_get_header(m, "Soft"); /* "true" is don't hangup */
   int soft;
   int ret; /* return value of agent_logoff */

   if (ast_strlen_zero(agent)) {
      astman_send_error(s, m, "No agent specified");
      return 0;
   }

   soft = ast_true(soft_s) ? 1 : 0;
   ret = agent_logoff(agent, soft);
   if (ret == 0)
      astman_send_ack(s, m, "Agent logged out");
   else
      astman_send_error(s, m, "No such agent");

   return 0;
}

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

Lists agents and their status to the Manager API. It is registered on load_module() and it gets called by the manager backend.

Parameters:

	s
	m

Returns:

See also:

action_agent_logoff(), load_module().

Definition at line 1565 of file chan_agent.c.

References ast_channel::_bridge, agent_pvt::acknowledged, agent_pvt::agent, ast_bridged_channel(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_ack(), agent_pvt::chan, ast_channel::cid, ast_callerid::cid_num, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::loginstart, ast_channel::name, agent_pvt::name, agent_pvt::owner, S_OR, and status.

Referenced by load_module().

{
   const char *id = astman_get_header(m,"ActionID");
   char idText[256] = "";
   char chanbuf[256];
   struct agent_pvt *p;
   char *username = NULL;
   char *loginChan = NULL;
   char *talkingto = NULL;
   char *talkingtoChan = NULL;
   char *status = NULL;

   if (!ast_strlen_zero(id))
      snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
   astman_send_ack(s, m, "Agents will follow");
   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
         ast_mutex_lock(&p->lock);

      /* Status Values:
         AGENT_LOGGEDOFF - Agent isn't logged in
         AGENT_IDLE      - Agent is logged in, and waiting for call
         AGENT_ONCALL    - Agent is logged in, and on a call
         AGENT_UNKNOWN   - Don't know anything about agent. Shouldn't ever get this. */

      username = S_OR(p->name, "None");

      /* Set a default status. It 'should' get changed. */
      status = "AGENT_UNKNOWN";

      if (!ast_strlen_zero(p->loginchan) && !p->chan) {
         loginChan = p->loginchan;
         talkingto = "n/a";
         talkingtoChan = "n/a";
         status = "AGENT_IDLE";
         if (p->acknowledged) {
            snprintf(chanbuf, sizeof(chanbuf), " %s (Confirmed)", p->loginchan);
            loginChan = chanbuf;
         }
      } else if (p->chan) {
         loginChan = ast_strdupa(p->chan->name);
         if (p->owner && p->owner->_bridge) {
            talkingto = p->chan->cid.cid_num;
            if (ast_bridged_channel(p->owner))
               talkingtoChan = ast_strdupa(ast_bridged_channel(p->owner)->name);
            else
               talkingtoChan = "n/a";
               status = "AGENT_ONCALL";
         } else {
            talkingto = "n/a";
            talkingtoChan = "n/a";
               status = "AGENT_IDLE";
         }
      } else {
         loginChan = "n/a";
         talkingto = "n/a";
         talkingtoChan = "n/a";
         status = "AGENT_LOGGEDOFF";
      }

      astman_append(s, "Event: Agents\r\n"
         "Agent: %s\r\n"
         "Name: %s\r\n"
         "Status: %s\r\n"
         "LoggedInChan: %s\r\n"
         "LoggedInTime: %d\r\n"
         "TalkingTo: %s\r\n"
         "TalkingToChan: %s\r\n"
         "%s"
         "\r\n",
         p->agent, username, status, loginChan, (int)p->loginstart, talkingto, talkingtoChan, idText);
      ast_mutex_unlock(&p->lock);
   }
   AST_LIST_UNLOCK(&agents);
   astman_append(s, "Event: AgentsComplete\r\n"
      "%s"
      "\r\n",idText);
   return 0;
}

static struct agent_pvt* add_agent	(	const char *	agent,
		int	pending
	)			[static, read]

Adds an agent to the global list of agents.

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 357 of file chan_agent.c.

References agent_pvt::acceptdtmf, agent_pvt::ackcall, agent_pvt::agent, AGENT_FLAG_ACCEPTDTMF, AGENT_FLAG_ACKCALL, AGENT_FLAG_AUTOLOGOFF, AGENT_FLAG_ENDDTMF, AGENT_FLAG_WRAPUPTIME, agent_pvt::app_complete_cond, agent_pvt::app_lock, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, AST_APP_ARG, ast_calloc, ast_cond_init(), ast_copy_string(), AST_DECLARE_APP_ARGS, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_mutex_init(), AST_STANDARD_APP_ARGS, ast_strlen_zero(), ast_test_flag, ast_tvnow(), agent_pvt::autologoff, agent_pvt::dead, agent_pvt::enddtmf, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, LOG_WARNING, agent_pvt::moh, agent_pvt::name, parse(), agent_pvt::password, agent_pvt::pending, and agent_pvt::wrapuptime.

Referenced by agent_request(), and read_agent_config().

{
   char *parse;
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(agt);
      AST_APP_ARG(password);
      AST_APP_ARG(name);
   );
   char *password = NULL;
   char *name = NULL;
   char *agt = NULL;
   struct agent_pvt *p;

   parse = ast_strdupa(agent);

   /* Extract username (agt), password and name from agent (args). */
   AST_STANDARD_APP_ARGS(args, parse);

   if(args.argc == 0) {
      ast_log(LOG_WARNING, "A blank agent line!\n");
      return NULL;
   }

   if(ast_strlen_zero(args.agt) ) {
      ast_log(LOG_WARNING, "An agent line with no agentid!\n");
      return NULL;
   } else
      agt = args.agt;

   if(!ast_strlen_zero(args.password)) {
      password = args.password;
      while (*password && *password < 33) password++;
   }
   if(!ast_strlen_zero(args.name)) {
      name = args.name;
      while (*name && *name < 33) name++;
   }
   
   /* Are we searching for the agent here ? To see if it exists already ? */
   AST_LIST_TRAVERSE(&agents, p, list) {
      if (!pending && !strcmp(p->agent, agt))
         break;
   }
   if (!p) {
      // Build the agent.
      if (!(p = ast_calloc(1, sizeof(*p))))
         return NULL;
      ast_copy_string(p->agent, agt, sizeof(p->agent));
      ast_mutex_init(&p->lock);
      ast_mutex_init(&p->app_lock);
      ast_cond_init(&p->app_complete_cond, NULL);
      p->app_lock_flag = 0;
      p->app_sleep_cond = 1;
      p->group = group;
      p->pending = pending;
      AST_LIST_INSERT_TAIL(&agents, p, list);
   }
   
   ast_copy_string(p->password, password ? password : "", sizeof(p->password));
   ast_copy_string(p->name, name ? name : "", sizeof(p->name));
   ast_copy_string(p->moh, moh, sizeof(p->moh));
   if (!ast_test_flag(p, AGENT_FLAG_ACKCALL)) {
      p->ackcall = ackcall;
   }
   if (!ast_test_flag(p, AGENT_FLAG_AUTOLOGOFF)) {
      p->autologoff = autologoff;
   }
   if (!ast_test_flag(p, AGENT_FLAG_ACCEPTDTMF)) {
      p->acceptdtmf = acceptdtmf;
   }
   if (!ast_test_flag(p, AGENT_FLAG_ENDDTMF)) {
      p->enddtmf = enddtmf;
   }

   /* If someone reduces the wrapuptime and reloads, we want it
    * to change the wrapuptime immediately on all calls */
   if (!ast_test_flag(p, AGENT_FLAG_WRAPUPTIME) && p->wrapuptime > wrapuptime) {
      struct timeval now = ast_tvnow();
      /* XXX check what is this exactly */

      /* We won't be pedantic and check the tv_usec val */
      if (p->lastdisc.tv_sec > (now.tv_sec + wrapuptime/1000)) {
         p->lastdisc.tv_sec = now.tv_sec + wrapuptime/1000;
         p->lastdisc.tv_usec = now.tv_usec;
      }
   }
   p->wrapuptime = wrapuptime;

   if (pending)
      p->dead = 1;
   else
      p->dead = 0;
   return p;
}

static int agent_ack_sleep

(

void *

data

)

[static]

Definition at line 1028 of file chan_agent.c.

References agent_pvt::acceptdtmf, agent_pvt::app_sleep_cond, AST_FRAME_DTMF, ast_frfree, ast_mutex_lock(), ast_mutex_unlock(), ast_read(), ast_waitfor(), agent_pvt::chan, f, ast_frame::frametype, agent_pvt::lock, and ast_frame::subclass.

Referenced by login_exec().

{
   struct agent_pvt *p;
   int res=0;
   int to = 1000;
   struct ast_frame *f;

   /* Wait a second and look for something */

   p = (struct agent_pvt *) data;
   if (!p->chan) 
      return -1;

   for(;;) {
      to = ast_waitfor(p->chan, to);
      if (to < 0) 
         return -1;
      if (!to) 
         return 0;
      f = ast_read(p->chan);
      if (!f) 
         return -1;
      if (f->frametype == AST_FRAME_DTMF)
         res = f->subclass;
      else
         res = 0;
      ast_frfree(f);
      ast_mutex_lock(&p->lock);
      if (!p->app_sleep_cond) {
         ast_mutex_unlock(&p->lock);
         return 0;
      } else if (res == p->acceptdtmf) {
         ast_mutex_unlock(&p->lock);
         return 1;
      }
      ast_mutex_unlock(&p->lock);
      res = 0;
   }
   return res;
}

static int agent_answer

(

struct ast_channel *

ast

)

[static]

Definition at line 480 of file chan_agent.c.

References ast_log(), and LOG_WARNING.

{
   ast_log(LOG_WARNING, "Huh?  Agent is being asked to answer?\n");
   return -1;
}

static struct ast_channel * agent_bridgedchannel	(	struct ast_channel *	chan,
		struct ast_channel *	bridge
	)			[static, read]

Definition at line 1069 of file chan_agent.c.

References ast_channel::_bridge, ast_debug, agent_pvt::chan, ast_channel::name, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = bridge->tech_pvt;
   struct ast_channel *ret = NULL;

   if (p) {
      if (chan == p->chan)
         ret = bridge->_bridge;
      else if (chan == bridge->_bridge)
         ret = p->chan;
   }

   ast_debug(1, "Asked for bridged channel on '%s'/'%s', returning '%s'\n", chan->name, bridge->name, ret ? ret->name : "<none>");
   return ret;
}

static int agent_call	(	struct ast_channel *	ast,
		char *	dest,
		int	timeout
	)			[static]

Definition at line 770 of file chan_agent.c.

References agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_start_monitoring(), ast_best_codec(), ast_call(), ast_channel_inherit_variables(), ast_debug, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), ast_getformatname(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_callerid(), ast_set_read_format(), ast_set_write_format(), ast_setstate(), AST_STATE_DIALING, AST_STATE_RINGING, AST_STATE_UP, ast_streamfile(), ast_strlen_zero(), ast_verb, ast_waitstream(), agent_pvt::chan, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, CLEANUP, ast_channel::language, agent_pvt::lock, LOG_NOTICE, LOG_WARNING, agent_pvt::loginchan, ast_channel::name, ast_channel::nativeformats, agent_pvt::pending, agent_pvt::start, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = ast->tech_pvt;
   int res = -1;
   int newstate=0;
   ast_mutex_lock(&p->lock);
   p->acknowledged = 0;
   if (!p->chan) {
      if (p->pending) {
         ast_debug(1, "Pretending to dial on pending agent\n");
         newstate = AST_STATE_DIALING;
         res = 0;
      } else {
         ast_log(LOG_NOTICE, "Whoa, they hung up between alloc and call...  what are the odds of that?\n");
         res = -1;
      }
      ast_mutex_unlock(&p->lock);
      if (newstate)
         ast_setstate(ast, newstate);
      return res;
   } else if (!ast_strlen_zero(p->loginchan)) {
      time(&p->start);
      /* Call on this agent */
      ast_verb(3, "outgoing agentcall, to agent '%s', on '%s'\n", p->agent, p->chan->name);
      ast_set_callerid(p->chan,
         ast->cid.cid_num, ast->cid.cid_name, NULL);
      ast_channel_inherit_variables(ast, p->chan);
      res = ast_call(p->chan, p->loginchan, 0);
      CLEANUP(ast,p);
      ast_mutex_unlock(&p->lock);
      return res;
   }
   ast_verb(3, "agent_call, call to agent '%s' call on '%s'\n", p->agent, p->chan->name);
   ast_debug(3, "Playing beep, lang '%s'\n", p->chan->language);
   res = ast_streamfile(p->chan, beep, p->chan->language);
   ast_debug(3, "Played beep, result '%d'\n", res);
   if (!res) {
      res = ast_waitstream(p->chan, "");
      ast_debug(3, "Waited for stream, result '%d'\n", res);
   }
   if (!res) {
      res = ast_set_read_format(p->chan, ast_best_codec(p->chan->nativeformats));
      ast_debug(3, "Set read format, result '%d'\n", res);
      if (res)
         ast_log(LOG_WARNING, "Unable to set read format to %s\n", ast_getformatname(ast_best_codec(p->chan->nativeformats)));
   } else {
      /* Agent hung-up */
      p->chan = NULL;
      ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent);
   }

   if (!res) {
      res = ast_set_write_format(p->chan, ast_best_codec(p->chan->nativeformats));
      ast_debug(3, "Set write format, result '%d'\n", res);
      if (res)
         ast_log(LOG_WARNING, "Unable to set write format to %s\n", ast_getformatname(ast_best_codec(p->chan->nativeformats)));
   }
   if(!res) {
      /* Call is immediately up, or might need ack */
      if (p->ackcall > 1)
         newstate = AST_STATE_RINGING;
      else {
         newstate = AST_STATE_UP;
         if (recordagentcalls)
            agent_start_monitoring(ast, 0);
         p->acknowledged = 1;
      }
      res = 0;
   }
   CLEANUP(ast, p);
   ast_mutex_unlock(&p->lock);
   if (newstate)
      ast_setstate(ast, newstate);
   return res;
}

static int agent_cleanup

(

struct agent_pvt *

p

)

[static]

Deletes an agent after doing some clean up. Further documentation: How safe is this function ? What state should the agent be to be cleaned.

Parameters:

p

Agent to be deleted.

Returns:

Always 0.

Definition at line 458 of file chan_agent.c.

References agent_pvt::app_complete_cond, agent_pvt::app_lock, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, ast_channel_free(), ast_cond_destroy(), ast_cond_signal(), ast_free, ast_mutex_destroy(), agent_pvt::chan, agent_pvt::dead, agent_pvt::lock, agent_pvt::owner, and ast_channel::tech_pvt.

Referenced by check_availability().

{
   struct ast_channel *chan = p->owner;
   p->owner = NULL;
   chan->tech_pvt = NULL;
   p->app_sleep_cond = 1;
   /* Release ownership of the agent to other threads (presumably running the login app). */
   p->app_lock_flag = 0;
   ast_cond_signal(&p->app_complete_cond);
   if (chan)
      ast_channel_free(chan);
   if (p->dead) {
      ast_mutex_destroy(&p->lock);
      ast_mutex_destroy(&p->app_lock);
      ast_cond_destroy(&p->app_complete_cond);
      ast_free(p);
        }
   return 0;
}

static int agent_cont_sleep

(

void *

data

)

[static]

Definition at line 1007 of file chan_agent.c.

References agent_pvt::app_sleep_cond, ast_debug, ast_mutex_lock(), ast_mutex_unlock(), ast_tvdiff_ms(), ast_tvnow(), agent_pvt::lastdisc, and agent_pvt::lock.

Referenced by login_exec().

{
   struct agent_pvt *p;
   int res;

   p = (struct agent_pvt *)data;

   ast_mutex_lock(&p->lock);
   res = p->app_sleep_cond;
   if (p->lastdisc.tv_sec) {
      if (ast_tvdiff_ms(ast_tvnow(), p->lastdisc) > 0) 
         res = 1;
   }
   ast_mutex_unlock(&p->lock);

   if (!res)
      ast_debug(5, "agent_cont_sleep() returning %d\n", res );

   return res;
}

static int agent_devicestate

(

void *

data

)

[static]

Part of PBX channel interface.

Definition at line 2438 of file chan_agent.c.

References agent_pvt::agent, AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), agent_pvt::chan, agent_pvt::group, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::owner, agent_pvt::pending, and s.

{
   struct agent_pvt *p;
   char *s;
   ast_group_t groupmatch;
   int groupoff;
   int res = AST_DEVICE_INVALID;
   
   s = data;
   if ((s[0] == '@') && (sscanf(s + 1, "%30d", &groupoff) == 1))
      groupmatch = (1 << groupoff);
   else if ((s[0] == ':') && (sscanf(s + 1, "%30d", &groupoff) == 1)) {
      groupmatch = (1 << groupoff);
   } else 
      groupmatch = 0;

   /* Check actual logged in agents first */
   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      ast_mutex_lock(&p->lock);
      if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent))) {
         if (p->owner) {
            if (res != AST_DEVICE_INUSE)
               res = AST_DEVICE_BUSY;
         } else {
            if (res == AST_DEVICE_BUSY)
               res = AST_DEVICE_INUSE;
            if (p->chan || !ast_strlen_zero(p->loginchan)) {
               if (res == AST_DEVICE_INVALID)
                  res = AST_DEVICE_UNKNOWN;
            } else if (res == AST_DEVICE_INVALID)  
               res = AST_DEVICE_UNAVAILABLE;
         }
         if (!strcmp(data, p->agent)) {
            ast_mutex_unlock(&p->lock);
            break;
         }
      }
      ast_mutex_unlock(&p->lock);
   }
   AST_LIST_UNLOCK(&agents);
   return res;
}

static int agent_digit_begin	(	struct ast_channel *	ast,
		char	digit
	)			[static]

Definition at line 748 of file chan_agent.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_senddigit_begin(), agent_pvt::chan, agent_pvt::lock, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = ast->tech_pvt;
   ast_mutex_lock(&p->lock);
   if (p->chan) {
      ast_senddigit_begin(p->chan, digit);
   }
   ast_mutex_unlock(&p->lock);
   return 0;
}

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

Definition at line 759 of file chan_agent.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_senddigit_end(), agent_pvt::chan, agent_pvt::lock, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = ast->tech_pvt;
   ast_mutex_lock(&p->lock);
   if (p->chan) {
      ast_senddigit_end(p->chan, digit, duration);
   }
   ast_mutex_unlock(&p->lock);
   return 0;
}

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

Definition at line 715 of file chan_agent.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), agent_pvt::lock, LOG_WARNING, agent_pvt::owner, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = newchan->tech_pvt;
   ast_mutex_lock(&p->lock);
   if (p->owner != oldchan) {
      ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
      ast_mutex_unlock(&p->lock);
      return -1;
   }
   p->owner = newchan;
   ast_mutex_unlock(&p->lock);
   return 0;
}

struct ast_channel * agent_get_base_channel

(

struct ast_channel *

chan

)

[static, read]

return the channel or base channel if one exists. This function assumes the channel it is called on is already locked

Definition at line 860 of file chan_agent.c.

References ast_log(), agent_pvt::chan, LOG_ERROR, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = NULL;
   struct ast_channel *base = chan;

   /* chan is locked by the calling function */
   if (!chan || !chan->tech_pvt) {
      ast_log(LOG_ERROR, "whoa, you need a channel (0x%ld) with a tech_pvt (0x%ld) to get a base channel.\n", (long)chan, (chan)?(long)chan->tech_pvt:(long)NULL);
      return NULL;
   }
   p = chan->tech_pvt;
   if (p->chan) 
      base = p->chan;
   return base;
}

static int agent_hangup

(

struct ast_channel *

ast

)

[static]

Definition at line 893 of file chan_agent.c.

References ast_channel::_bridge, ast_channel::_state, agent_pvt::abouttograb, agent_pvt::acknowledged, agent_pvt::agent, agent_logoff_maintenance(), agent_pvt::app_complete_cond, agent_pvt::app_lock, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, ast_channel_lock, ast_channel_unlock, ast_cond_destroy(), ast_cond_signal(), AST_CONTROL_HOLD, ast_debug, AST_DEVICE_NOT_INUSE, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), ast_free, ast_hangup(), ast_indicate_data(), AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, ast_log(), ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), ast_samp2tv(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_state2str(), AST_STATE_RESERVED, AST_STATE_UP, ast_strlen_zero(), ast_tv(), ast_tvadd(), ast_tvnow(), agent_pvt::autologoff, agent_pvt::chan, agent_pvt::dead, agent_pvt::deferlogoff, dump_agents(), agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, agent_pvt::logincallerid, agent_pvt::loginchan, agent_pvt::loginstart, agent_pvt::moh, agent_pvt::name, agent_pvt::owner, pbx_builtin_getvar_helper(), agent_pvt::pending, S_OR, agent_pvt::start, status, ast_channel::tech_pvt, ast_channel::uniqueid, and agent_pvt::wrapuptime.

{
   struct agent_pvt *p = ast->tech_pvt;
   int howlong = 0;
   const char *status;
   ast_mutex_lock(&p->lock);
   p->owner = NULL;
   ast->tech_pvt = NULL;
   p->app_sleep_cond = 1;
   p->acknowledged = 0;

   /* if they really are hung up then set start to 0 so the test
    * later if we're called on an already downed channel
    * doesn't cause an agent to be logged out like when
    * agent_request() is followed immediately by agent_hangup()
    * as in apps/app_chanisavail.c:chanavail_exec()
    */

   ast_debug(1, "Hangup called for state %s\n", ast_state2str(ast->_state));
   if (p->start && (ast->_state != AST_STATE_UP)) {
      howlong = time(NULL) - p->start;
      p->start = 0;
   } else if (ast->_state == AST_STATE_RESERVED) 
      howlong = 0;
   else
      p->start = 0; 
   if (p->chan) {
      p->chan->_bridge = NULL;
      /* If they're dead, go ahead and hang up on the agent now */
      if (!ast_strlen_zero(p->loginchan)) {
         /* Store last disconnect time */
         if (p->wrapuptime)
            p->lastdisc = ast_tvadd(ast_tvnow(), ast_samp2tv(p->wrapuptime, 1000));
         else
            p->lastdisc = ast_tv(0,0);
         if (p->chan) {
            status = pbx_builtin_getvar_helper(p->chan, "CHANLOCALSTATUS");
            if (autologoffunavail && status && !strcasecmp(status, "CHANUNAVAIL")) {
               long logintime = time(NULL) - p->loginstart;
               p->loginstart = 0;
               ast_log(LOG_NOTICE, "Agent hangup: '%s' is not available now, auto logoff\n", p->name);
               agent_logoff_maintenance(p, p->loginchan, logintime, ast->uniqueid, "Chanunavail");
            }
            /* Recognize the hangup and pass it along immediately */
            ast_hangup(p->chan);
            p->chan = NULL;
            ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent);
         }
         ast_debug(1, "Hungup, howlong is %d, autologoff is %d\n", howlong, p->autologoff);
         if ((p->deferlogoff) || (howlong && p->autologoff && (howlong > p->autologoff))) {
            long logintime = time(NULL) - p->loginstart;
            p->loginstart = 0;
            if (!p->deferlogoff)
               ast_log(LOG_NOTICE, "Agent '%s' didn't answer/confirm within %d seconds (waited %d)\n", p->name, p->autologoff, howlong);
            p->deferlogoff = 0;
            agent_logoff_maintenance(p, p->loginchan, logintime, ast->uniqueid, "Autologoff");
            if (persistent_agents)
               dump_agents();
         }
      } else if (p->dead) {
         ast_channel_lock(p->chan);
         ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
         ast_channel_unlock(p->chan);
      } else if (p->loginstart) {
         ast_channel_lock(p->chan);
         ast_indicate_data(p->chan, AST_CONTROL_HOLD, 
            S_OR(p->moh, NULL),
            !ast_strlen_zero(p->moh) ? strlen(p->moh) + 1 : 0);
         ast_channel_unlock(p->chan);
      }
   }
   ast_mutex_unlock(&p->lock);

   /* Only register a device state change if the agent is still logged in */
   if (!p->loginstart) {
      p->loginchan[0] = '\0';
      p->logincallerid[0] = '\0';
      if (persistent_agents)
         dump_agents();
   } else {
      ast_devstate_changed(AST_DEVICE_NOT_INUSE, "Agent/%s", p->agent);
   }

   if (p->pending) {
      AST_LIST_LOCK(&agents);
      AST_LIST_REMOVE(&agents, p, list);
      AST_LIST_UNLOCK(&agents);
   }
   if (p->abouttograb) {
      /* Let the "about to grab" thread know this isn't valid anymore, and let it
         kill it later */
      p->abouttograb = 0;
   } else if (p->dead) {
      ast_mutex_destroy(&p->lock);
      ast_mutex_destroy(&p->app_lock);
      ast_cond_destroy(&p->app_complete_cond);
      ast_free(p);
   } else {
      if (p->chan) {
         /* Not dead -- check availability now */
         ast_mutex_lock(&p->lock);
         /* Store last disconnect time */
         p->lastdisc = ast_tvadd(ast_tvnow(), ast_samp2tv(p->wrapuptime, 1000));
         ast_mutex_unlock(&p->lock);
      }
      /* Release ownership of the agent to other threads (presumably running the login app). */
      if (ast_strlen_zero(p->loginchan)) {
         p->app_lock_flag = 0;
         ast_cond_signal(&p->app_complete_cond);
      }
   }
   return 0;
}

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

Definition at line 729 of file chan_agent.c.

References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_check_hangup(), ast_mutex_lock(), ast_mutex_unlock(), agent_pvt::chan, ast_channel_tech::indicate, agent_pvt::lock, ast_channel::tech, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = ast->tech_pvt;
   int res = -1;
   ast_mutex_lock(&p->lock);
   if (p->chan && !ast_check_hangup(p->chan)) {
      while (ast_channel_trylock(p->chan)) {
         ast_channel_unlock(ast);
         usleep(1);
         ast_channel_lock(ast);
      }
      res = p->chan->tech->indicate ? p->chan->tech->indicate(p->chan, condition, data, datalen) : -1;
      ast_channel_unlock(p->chan);
   } else
      res = 0;
   ast_mutex_unlock(&p->lock);
   return res;
}

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

Definition at line 1684 of file chan_agent.c.

References agent_pvt::agent, agent_logoff_maintenance(), ast_channel_trylock, ast_channel_unlock, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, agent_pvt::chan, DEADLOCK_AVOIDANCE, agent_pvt::deferlogoff, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::loginstart, and agent_pvt::owner.

Referenced by action_agent_logoff(), and agent_logoff_cmd().

{
   struct agent_pvt *p;
   long logintime;
   int ret = -1; /* Return -1 if no agent if found */

   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      if (!strcasecmp(p->agent, agent)) {
         ret = 0;
         if (p->owner || p->chan) {
            if (!soft) {
               ast_mutex_lock(&p->lock);

               while (p->owner && ast_channel_trylock(p->owner)) {
                  DEADLOCK_AVOIDANCE(&p->lock);
               }
               if (p->owner) {
                  ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT);
                  ast_channel_unlock(p->owner);
               }

               while (p->chan && ast_channel_trylock(p->chan)) {
                  DEADLOCK_AVOIDANCE(&p->lock);
               }
               if (p->chan) {
                  ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
                  ast_channel_unlock(p->chan);
               }

               ast_mutex_unlock(&p->lock);
            } else
               p->deferlogoff = 1;
         } else {
            logintime = time(NULL) - p->loginstart;
            p->loginstart = 0;
            agent_logoff_maintenance(p, p->loginchan, logintime, NULL, "CommandLogoff");
         }
         break;
      }
   }
   AST_LIST_UNLOCK(&agents);

   return ret;
}

static char* agent_logoff_cmd	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)			[static]

Definition at line 1730 of file chan_agent.c.

References agent_pvt::agent, agent_logoff(), ast_cli_args::argc, ast_cli_args::argv, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_agent_logoff_cmd(), ast_cli_args::fd, ast_cli_args::line, ast_cli_args::n, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   int ret;
   char *agent;

   switch (cmd) {
   case CLI_INIT:
      e->command = "agent logoff";
      e->usage =
         "Usage: agent logoff <channel> [soft]\n"
         "       Sets an agent as no longer logged in.\n"
         "       If 'soft' is specified, do not hangup existing calls.\n";
      return NULL;
   case CLI_GENERATE:
      return complete_agent_logoff_cmd(a->line, a->word, a->pos, a->n); 
   }

   if (a->argc < 3 || a->argc > 4)
      return CLI_SHOWUSAGE;
   if (a->argc == 4 && strcasecmp(a->argv[3], "soft"))
      return CLI_SHOWUSAGE;

   agent = a->argv[2] + 6;
   ret = agent_logoff(agent, a->argc == 4);
   if (ret == 0)
      ast_cli(a->fd, "Logging out %s\n", agent);

   return CLI_SUCCESS;
}

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

Definition at line 1645 of file chan_agent.c.

References agent_pvt::agent, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), AST_MAX_AGENT, ast_queue_log(), ast_strlen_zero(), dump_agents(), EVENT_FLAG_AGENT, agent_pvt::logincallerid, agent_pvt::loginchan, manager_event, and set_agentbycallerid().

Referenced by agent_hangup(), agent_logoff(), and agent_read().

{
   char *tmp = NULL;
   char agent[AST_MAX_AGENT];

   if (!ast_strlen_zero(logcommand))
      tmp = logcommand;
   else
      tmp = ast_strdupa("");

   snprintf(agent, sizeof(agent), "Agent/%s", p->agent);

   if (!ast_strlen_zero(uniqueid)) {
      manager_event(EVENT_FLAG_AGENT, "Agentcallbacklogoff",
            "Agent: %s\r\n"
            "Reason: %s\r\n"
            "Loginchan: %s\r\n"
            "Logintime: %ld\r\n"
            "Uniqueid: %s\r\n", 
            p->agent, tmp, loginchan, logintime, uniqueid);
   } else {
      manager_event(EVENT_FLAG_AGENT, "Agentcallbacklogoff",
            "Agent: %s\r\n"
            "Reason: %s\r\n"
            "Loginchan: %s\r\n"
            "Logintime: %ld\r\n",
            p->agent, tmp, loginchan, logintime);
   }

   ast_queue_log("NONE", ast_strlen_zero(uniqueid) ? "NONE" : uniqueid, agent, "AGENTCALLBACKLOGOFF", "%s|%ld|%s", loginchan, logintime, tmp);
   set_agentbycallerid(p->logincallerid, NULL);
   p->loginchan[0] ='\0';
   p->logincallerid[0] = '\0';
   ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent);
   if (persistent_agents)
      dump_agents();

}

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

Create new agent channel.

Definition at line 1086 of file chan_agent.c.

References agent_pvt::agent, agent_tech, agent_pvt::app_complete_cond, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, ast_channel_alloc, ast_channel_free(), ast_cond_signal(), AST_CONTROL_UNHOLD, ast_copy_string(), AST_FORMAT_SLINEAR, ast_indicate(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_null_frame, ast_queue_frame(), ast_random(), ast_string_field_set, ast_strlen_zero(), agent_pvt::chan, ast_channel::context, ast_channel::exten, ast_channel::language, language, agent_pvt::lock, LOG_WARNING, agent_pvt::loginchan, ast_channel::nativeformats, agent_pvt::owner, agent_pvt::pending, ast_channel::priority, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, ast_channel::tech, ast_channel::tech_pvt, and ast_channel::writeformat.

Referenced by agent_request(), and check_availability().

{
   struct ast_channel *tmp;
   int alreadylocked;
#if 0
   if (!p->chan) {
      ast_log(LOG_WARNING, "No channel? :(\n");
      return NULL;
   }
#endif   
   if (p->pending)
      tmp = ast_channel_alloc(0, state, 0, 0, "", p->chan ? p->chan->exten:"", p->chan ? p->chan->context:"", 0, "Agent/P%s-%d", p->agent, (int) ast_random() & 0xffff);
   else
      tmp = ast_channel_alloc(0, state, 0, 0, "", p->chan ? p->chan->exten:"", p->chan ? p->chan->context:"", 0, "Agent/%s", p->agent);
   if (!tmp) {
      ast_log(LOG_WARNING, "Unable to allocate agent channel structure\n");
      return NULL;
   }

   tmp->tech = &agent_tech;
   if (p->chan) {
      tmp->nativeformats = p->chan->nativeformats;
      tmp->writeformat = p->chan->writeformat;
      tmp->rawwriteformat = p->chan->writeformat;
      tmp->readformat = p->chan->readformat;
      tmp->rawreadformat = p->chan->readformat;
      ast_string_field_set(tmp, language, p->chan->language);
      ast_copy_string(tmp->context, p->chan->context, sizeof(tmp->context));
      ast_copy_string(tmp->exten, p->chan->exten, sizeof(tmp->exten));
      /* XXX Is this really all we copy form the originating channel?? */
   } else {
      tmp->nativeformats = AST_FORMAT_SLINEAR;
      tmp->writeformat = AST_FORMAT_SLINEAR;
      tmp->rawwriteformat = AST_FORMAT_SLINEAR;
      tmp->readformat = AST_FORMAT_SLINEAR;
      tmp->rawreadformat = AST_FORMAT_SLINEAR;
   }
   /* Safe, agentlock already held */
   tmp->tech_pvt = p;
   p->owner = tmp;
   tmp->priority = 1;
   /* Wake up and wait for other applications (by definition the login app)
    * to release this channel). Takes ownership of the agent channel
    * to this thread only.
    * For signalling the other thread, ast_queue_frame is used until we
    * can safely use signals for this purpose. The pselect() needs to be
    * implemented in the kernel for this.
    */
   p->app_sleep_cond = 0;

   alreadylocked = p->app_lock_flag;
   p->app_lock_flag = 1;

   if(ast_strlen_zero(p->loginchan) && alreadylocked) {
      if (p->chan) {
         ast_queue_frame(p->chan, &ast_null_frame);
         ast_mutex_unlock(&p->lock);   /* For other thread to read the condition. */
         p->app_lock_flag = 1;
         ast_mutex_lock(&p->lock);
      } else {
         ast_log(LOG_WARNING, "Agent disconnected while we were connecting the call\n");
         p->owner = NULL;
         tmp->tech_pvt = NULL;
         p->app_sleep_cond = 1;
         ast_channel_free( tmp );
         ast_mutex_unlock(&p->lock);   /* For other thread to read the condition. */
         p->app_lock_flag = 0;
         ast_cond_signal(&p->app_complete_cond);
         return NULL;
      }
   } else if (!ast_strlen_zero(p->loginchan)) {
      if (p->chan)
         ast_queue_frame(p->chan, &ast_null_frame);
      if (!p->chan) {
         ast_log(LOG_WARNING, "Agent disconnected while we were connecting the call\n");
         p->owner = NULL;
         tmp->tech_pvt = NULL;
         p->app_sleep_cond = 1;
         ast_channel_free( tmp );
         ast_mutex_unlock(&p->lock);     /* For other thread to read the condition. */
         return NULL;
      }  
   } 
   if (p->chan)
      ast_indicate(p->chan, AST_CONTROL_UNHOLD);
   return tmp;
}

static struct ast_frame * agent_read

(

struct ast_channel *

ast

)

[static, read]

Definition at line 519 of file chan_agent.c.

References ast_channel::_bridge, ast_channel::_state, agent_pvt::acceptdtmf, agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_logoff_maintenance(), agent_start_monitoring(), AST_AGENT_FD, ast_channel_trylock, ast_channel_unlock, AST_CONTROL_ANSWER, ast_copy_flags, ast_debug, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), AST_FLAG_EXCEPTION, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, ast_hangup(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_null_frame, ast_read(), ast_samp2tv(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, AST_STATE_UP, ast_strlen_zero(), AST_TIMING_FD, ast_tvadd(), ast_tvnow(), ast_verb, agent_pvt::autologoff, agent_pvt::chan, CHECK_FORMATS, CLEANUP, DEADLOCK_AVOIDANCE, agent_pvt::enddtmf, f, ast_channel::fdno, ast_frame::frametype, agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, agent_pvt::loginchan, agent_pvt::loginstart, agent_pvt::name, ast_channel::name, agent_pvt::owner, pbx_builtin_getvar_helper(), agent_pvt::start, status, ast_frame::subclass, ast_channel::tech, ast_channel::tech_pvt, ast_channel_tech::type, ast_channel::uniqueid, and agent_pvt::wrapuptime.

{
   struct agent_pvt *p = ast->tech_pvt;
   struct ast_frame *f = NULL;
   static struct ast_frame answer_frame = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
   const char *status;
   int cur_time = time(NULL);
   ast_mutex_lock(&p->lock);
   CHECK_FORMATS(ast, p);
   if (!p->start) {
      p->start = cur_time;
   }
   if (p->chan) {
      ast_copy_flags(p->chan, ast, AST_FLAG_EXCEPTION);
      p->chan->fdno = (ast->fdno == AST_AGENT_FD) ? AST_TIMING_FD : ast->fdno;
      f = ast_read(p->chan);
   } else
      f = &ast_null_frame;
   if (!f) {
      /* If there's a channel, hang it up (if it's on a callback) make it NULL */
      if (p->chan) {
         p->chan->_bridge = NULL;
         /* Note that we don't hangup if it's not a callback because Asterisk will do it
            for us when the PBX instance that called login finishes */
         if (!ast_strlen_zero(p->loginchan)) {
            if (p->chan)
               ast_debug(1, "Bridge on '%s' being cleared (2)\n", p->chan->name);
            if (p->owner->_state != AST_STATE_UP) {
               int howlong = cur_time - p->start;
               if (p->autologoff && howlong >= p->autologoff) {
                  p->loginstart = 0;
                     ast_log(LOG_NOTICE, "Agent '%s' didn't answer/confirm within %d seconds (waited %d)\n", p->name, p->autologoff, howlong);
                  agent_logoff_maintenance(p, p->loginchan, (cur_time = p->loginstart), ast->uniqueid, "Autologoff");
               }
            }
            status = pbx_builtin_getvar_helper(p->chan, "CHANLOCALSTATUS");
            if (autologoffunavail && status && !strcasecmp(status, "CHANUNAVAIL")) {
               long logintime = cur_time - p->loginstart;
               p->loginstart = 0;
               ast_log(LOG_NOTICE, "Agent read: '%s' is not available now, auto logoff\n", p->name);
               agent_logoff_maintenance(p, p->loginchan, logintime, ast->uniqueid, "Chanunavail");
            }
            ast_hangup(p->chan);
            if (p->wrapuptime && p->acknowledged)
               p->lastdisc = ast_tvadd(ast_tvnow(), ast_samp2tv(p->wrapuptime, 1000));
         }
         p->chan = NULL;
         ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent);
         p->acknowledged = 0;
      }
   } else {
      /* if acknowledgement is not required, and the channel is up, we may have missed
         an AST_CONTROL_ANSWER (if there was one), so mark the call acknowledged anyway */
      if (!p->ackcall && !p->acknowledged && p->chan && (p->chan->_state == AST_STATE_UP)) {
         p->acknowledged = 1;
      }

      if (!p->acknowledged) {
         int howlong = cur_time - p->start;
         if (p->autologoff && (howlong >= p->autologoff)) {
            ast_log(LOG_NOTICE, "Agent '%s' didn't answer/confirm within %d seconds (waited %d)\n", p->name, p->autologoff, howlong);
            agent_logoff_maintenance(p, p->loginchan, (cur_time - p->loginstart), ast->uniqueid, "Autologoff");
            if (p->owner || p->chan) {
               while (p->owner && ast_channel_trylock(p->owner)) {
                  DEADLOCK_AVOIDANCE(&p->lock);
               }
               if (p->owner) {
                  ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT);
                  ast_channel_unlock(p->owner);
               }

               while (p->chan && ast_channel_trylock(p->chan)) {
                  DEADLOCK_AVOIDANCE(&p->lock);
               }
               if (p->chan) {
                  ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
                  ast_channel_unlock(p->chan);
               }
            } else {
               long logintime;
               logintime = time(NULL) - p->loginstart;
               p->loginstart = 0;
               agent_logoff_maintenance(p, p->loginchan, logintime, NULL, "CommandLogoff");
            }
         }
      }
      switch (f->frametype) {
      case AST_FRAME_CONTROL:
         if (f->subclass == AST_CONTROL_ANSWER) {
            if (p->ackcall) {
               ast_verb(3, "%s answered, waiting for '%c' to acknowledge\n", p->chan->name, p->acceptdtmf);
               /* Don't pass answer along */
               ast_frfree(f);
               f = &ast_null_frame;
            } else {
               p->acknowledged = 1;
               /* Use the builtin answer frame for the 
                  recording start check below. */
               ast_frfree(f);
               f = &answer_frame;
            }
         }
         break;
      case AST_FRAME_DTMF_BEGIN:
         /*ignore DTMF begin's as it can cause issues with queue announce files*/
         if((!p->acknowledged && f->subclass == p->acceptdtmf) || (f->subclass == p->enddtmf && endcall)){
            ast_frfree(f);
            f = &ast_null_frame;
         }
         break;
      case AST_FRAME_DTMF_END:
         if (!p->acknowledged && (f->subclass == p->acceptdtmf)) {
            ast_verb(3, "%s acknowledged\n", p->chan->name);
            p->acknowledged = 1;
            ast_frfree(f);
            f = &answer_frame;
         } else if (f->subclass == p->enddtmf && endcall) {
            /* terminates call */
            ast_frfree(f);
            f = NULL;
         }
         break;
      case AST_FRAME_VOICE:
      case AST_FRAME_VIDEO:
         /* don't pass voice or video until the call is acknowledged */
         if (!p->acknowledged) {
            ast_frfree(f);
            f = &ast_null_frame;
         }
      default:
         /* pass everything else on through */
         break;
      }
   }

   CLEANUP(ast,p);
   if (p->chan && !p->chan->_bridge) {
      if (strcasecmp(p->chan->tech->type, "Local")) {
         p->chan->_bridge = ast;
         if (p->chan)
            ast_debug(1, "Bridge on '%s' being set to '%s' (3)\n", p->chan->name, p->chan->_bridge->name);
      }
   }
   ast_mutex_unlock(&p->lock);
   if (recordagentcalls && f == &answer_frame)
      agent_start_monitoring(ast,0);
   return f;
}

static struct ast_channel * agent_request	(	const char *	type,
		int	format,
		void *	data,
		int *	cause
	)			[static, read]

Part of the Asterisk PBX interface.

Definition at line 1452 of file chan_agent.c.

References add_agent(), agent_pvt::agent, agent_new(), AST_CAUSE_BUSY, AST_CAUSE_UNREGISTERED, ast_debug, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_request(), AST_STATE_DOWN, ast_strlen_zero(), ast_tv(), ast_tvnow(), agent_pvt::chan, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, LOG_WARNING, agent_pvt::loginchan, agent_pvt::owner, agent_pvt::pending, and s.

{
   struct agent_pvt *p;
   struct ast_channel *chan = NULL;
   char *s;
   ast_group_t groupmatch;
   int groupoff;
   int waitforagent=0;
   int hasagent = 0;
   struct timeval now;

   s = data;
   if ((s[0] == '@') && (sscanf(s + 1, "%30d", &groupoff) == 1)) {
      groupmatch = (1 << groupoff);
   } else if ((s[0] == ':') && (sscanf(s + 1, "%30d", &groupoff) == 1)) {
      groupmatch = (1 << groupoff);
      waitforagent = 1;
   } else 
      groupmatch = 0;

   /* Check actual logged in agents first */
   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      ast_mutex_lock(&p->lock);
      if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent)) &&
          ast_strlen_zero(p->loginchan)) {
         if (p->chan)
            hasagent++;
         now = ast_tvnow();
         if (!p->lastdisc.tv_sec || (now.tv_sec >= p->lastdisc.tv_sec)) {
            p->lastdisc = ast_tv(0, 0);
            /* Agent must be registered, but not have any active call, and not be in a waiting state */
            if (!p->owner && p->chan) {
               /* Fixed agent */
               chan = agent_new(p, AST_STATE_DOWN);
            }
            if (chan) {
               ast_mutex_unlock(&p->lock);
               break;
            }
         }
      }
      ast_mutex_unlock(&p->lock);
   }
   if (!p) {
      AST_LIST_TRAVERSE(&agents, p, list) {
         ast_mutex_lock(&p->lock);
         if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent))) {
            if (p->chan || !ast_strlen_zero(p->loginchan))
               hasagent++;
            now = ast_tvnow();
#if 0
            ast_log(LOG_NOTICE, "Time now: %ld, Time of lastdisc: %ld\n", now.tv_sec, p->lastdisc.tv_sec);
#endif
            if (!p->lastdisc.tv_sec || (now.tv_sec >= p->lastdisc.tv_sec)) {
               p->lastdisc = ast_tv(0, 0);
               /* Agent must be registered, but not have any active call, and not be in a waiting state */
               if (!p->owner && p->chan) {
                  /* Could still get a fixed agent */
                  chan = agent_new(p, AST_STATE_DOWN);
               } else if (!p->owner && !ast_strlen_zero(p->loginchan)) {
                  /* Adjustable agent */
                  p->chan = ast_request("Local", format, p->loginchan, cause);
                  if (p->chan)
                     chan = agent_new(p, AST_STATE_DOWN);
               }
               if (chan) {
                  ast_mutex_unlock(&p->lock);
                  break;
               }
            }
         }
         ast_mutex_unlock(&p->lock);
      }
   }

   if (!chan && waitforagent) {
      /* No agent available -- but we're requesting to wait for one.
         Allocate a place holder */
      if (hasagent) {
         ast_debug(1, "Creating place holder for '%s'\n", s);
         p = add_agent(data, 1);
         p->group = groupmatch;
         chan = agent_new(p, AST_STATE_DOWN);
         if (!chan) 
            ast_log(LOG_WARNING, "Weird...  Fix this to drop the unused pending agent\n");
      } else {
         ast_debug(1, "Not creating place holder for '%s' since nobody logged in\n", s);
      }
   }
   *cause = hasagent ? AST_CAUSE_BUSY : AST_CAUSE_UNREGISTERED;
   AST_LIST_UNLOCK(&agents);
   return chan;
}

static int agent_sendhtml	(	struct ast_channel *	ast,
		int	subclass,
		const char *	data,
		int	datalen
	)			[static]

Definition at line 668 of file chan_agent.c.

References ast_channel_sendhtml(), ast_mutex_lock(), ast_mutex_unlock(), agent_pvt::chan, agent_pvt::lock, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = ast->tech_pvt;
   int res = -1;
   ast_mutex_lock(&p->lock);
   if (p->chan) 
      res = ast_channel_sendhtml(p->chan, subclass, data, datalen);
   ast_mutex_unlock(&p->lock);
   return res;
}

static int agent_sendtext	(	struct ast_channel *	ast,
		const char *	text
	)			[static]

Definition at line 679 of file chan_agent.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_sendtext(), agent_pvt::chan, agent_pvt::lock, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = ast->tech_pvt;
   int res = -1;
   ast_mutex_lock(&p->lock);
   if (p->chan) 
      res = ast_sendtext(p->chan, text);
   ast_mutex_unlock(&p->lock);
   return res;
}

int agent_set_base_channel	(	struct ast_channel *	chan,
		struct ast_channel *	base
	)			[static]

Definition at line 876 of file chan_agent.c.

References ast_log(), agent_pvt::chan, LOG_ERROR, ast_channel::name, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = NULL;
   
   if (!chan || !base) {
      ast_log(LOG_ERROR, "whoa, you need a channel (0x%ld) and a base channel (0x%ld) for setting.\n", (long)chan, (long)base);
      return -1;
   }
   p = chan->tech_pvt;
   if (!p) {
      ast_log(LOG_ERROR, "whoa, channel %s is missing his tech_pvt structure!!.\n", chan->name);
      return -1;
   }
   p->chan = base;
   return 0;
}

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

Definition at line 514 of file chan_agent.c.

References __agent_start_monitoring(), and ast_channel::tech_pvt.

Referenced by agent_call(), and agent_read().

{
   return __agent_start_monitoring(ast, ast->tech_pvt, needlock);
}

static int agent_write	(	struct ast_channel *	ast,
		struct ast_frame *	f
	)			[static]

Definition at line 690 of file chan_agent.c.

References ast_debug, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_mutex_lock(), ast_mutex_unlock(), ast_write(), agent_pvt::chan, CHECK_FORMATS, CLEANUP, ast_frame::frametype, agent_pvt::lock, ast_channel::name, ast_frame::subclass, ast_channel::tech_pvt, and ast_channel::writeformat.

{
   struct agent_pvt *p = ast->tech_pvt;
   int res = -1;
   CHECK_FORMATS(ast, p);
   ast_mutex_lock(&p->lock);
   if (!p->chan) 
      res = 0;
   else {
      if ((f->frametype != AST_FRAME_VOICE) ||
          (f->frametype != AST_FRAME_VIDEO) ||
          (f->subclass == p->chan->writeformat)) {
         res = ast_write(p->chan, f);
      } else {
         ast_debug(1, "Dropping one incompatible %s frame on '%s' to '%s'\n", 
            f->frametype == AST_FRAME_VOICE ? "audio" : "video",
            ast->name, p->chan->name);
         res = 0;
      }
   }
   CLEANUP(ast, p);
   ast_mutex_unlock(&p->lock);
   return res;
}

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

Called by the AgentMonitorOutgoing application (from the dial plan).

Parameters:

	chan
	data

Returns:

See also:

login_exec(), load_module().

Definition at line 2309 of file chan_agent.c.

References __agent_start_monitoring(), agent_pvt::agent, ast_copy_string(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), AST_MAX_AGENT, AST_MAX_BUF, ast_channel::cdr, ast_cdr::channel, ast_channel::cid, ast_callerid::cid_num, GETAGENTBYCALLERID, LOG_WARNING, and pbx_builtin_getvar_helper().

Referenced by load_module().

{
   int exitifnoagentid = 0;
   int nowarnings = 0;
   int changeoutgoing = 0;
   int res = 0;
   char agent[AST_MAX_AGENT];

   if (data) {
      if (strchr(data, 'd'))
         exitifnoagentid = 1;
      if (strchr(data, 'n'))
         nowarnings = 1;
      if (strchr(data, 'c'))
         changeoutgoing = 1;
   }
   if (chan->cid.cid_num) {
      const char *tmp;
      char agentvar[AST_MAX_BUF];
      snprintf(agentvar, sizeof(agentvar), "%s_%s", GETAGENTBYCALLERID, chan->cid.cid_num);
      if ((tmp = pbx_builtin_getvar_helper(NULL, agentvar))) {
         struct agent_pvt *p;
         ast_copy_string(agent, tmp, sizeof(agent));
         AST_LIST_LOCK(&agents);
         AST_LIST_TRAVERSE(&agents, p, list) {
            if (!strcasecmp(p->agent, tmp)) {
               if (changeoutgoing) snprintf(chan->cdr->channel, sizeof(chan->cdr->channel), "Agent/%s", p->agent);
               __agent_start_monitoring(chan, p, 1);
               break;
            }
         }
         AST_LIST_UNLOCK(&agents);
         
      } else {
         res = -1;
         if (!nowarnings)
            ast_log(LOG_WARNING, "Couldn't find the global variable %s, so I can't figure out which agent (if it's an agent) is placing outgoing call.\n", agentvar);
      }
   } else {
      res = -1;
      if (!nowarnings)
         ast_log(LOG_WARNING, "There is no callerid on that call, so I can't figure out which agent (if it's an agent) is placing outgoing call.\n");
   }
   if (res) {
      if (exitifnoagentid)
         return res;
   }
   return 0;
}

static char* agents_show	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)			[static]

Show agents in cli.

< Number of agents configured

< Number of online agents

< Number of offline agents

Definition at line 1817 of file chan_agent.c.

References agent_pvt::acknowledged, agent_pvt::agent, ast_cli_args::argc, ast_bridged_channel(), ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, AST_MAX_BUF, ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), ast_tvdiff_ms(), ast_tvnow(), agent_pvt::chan, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::moh, ast_channel::name, agent_pvt::name, agent_pvt::owner, agent_pvt::pending, powerof(), and ast_cli_entry::usage.

{
   struct agent_pvt *p;
   char username[AST_MAX_BUF];
   char location[AST_MAX_BUF] = "";
   char talkingto[AST_MAX_BUF] = "";
   char music[AST_MAX_BUF];
   int count_agents = 0;      /*!< Number of agents configured */
   int online_agents = 0;     /*!< Number of online agents */
   int offline_agents = 0;    /*!< Number of offline agents */

   switch (cmd) {
   case CLI_INIT:
      e->command = "agent show";
      e->usage =
         "Usage: agent show\n"
         "       Provides summary information on agents.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc != 2)
      return CLI_SHOWUSAGE;

   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      ast_mutex_lock(&p->lock);
      if (p->pending) {
         if (p->group)
            ast_cli(a->fd, "-- Pending call to group %d\n", powerof(p->group));
         else
            ast_cli(a->fd, "-- Pending call to agent %s\n", p->agent);
      } else {
         if (!ast_strlen_zero(p->name))
            snprintf(username, sizeof(username), "(%s) ", p->name);
         else
            username[0] = '\0';
         if (p->chan) {
            snprintf(location, sizeof(location), "logged in on %s", p->chan->name);
            if (p->owner && ast_bridged_channel(p->owner))
               snprintf(talkingto, sizeof(talkingto), " talking to %s", ast_bridged_channel(p->owner)->name);
             else 
               strcpy(talkingto, " is idle");
            online_agents++;
         } else if (!ast_strlen_zero(p->loginchan)) {
            if (ast_tvdiff_ms(ast_tvnow(), p->lastdisc) > 0 || !(p->lastdisc.tv_sec)) 
               snprintf(location, sizeof(location) - 20, "available at '%s'", p->loginchan);
            else 
               snprintf(location, sizeof(location) - 20, "wrapping up at '%s'", p->loginchan);
            talkingto[0] = '\0';
            online_agents++;
            if (p->acknowledged)
               strncat(location, " (Confirmed)", sizeof(location) - strlen(location) - 1);
         } else {
            strcpy(location, "not logged in");
            talkingto[0] = '\0';
            offline_agents++;
         }
         if (!ast_strlen_zero(p->moh))
            snprintf(music, sizeof(music), " (musiconhold is '%s')", p->moh);
         ast_cli(a->fd, "%-12.12s %s%s%s%s\n", p->agent, 
            username, location, talkingto, music);
         count_agents++;
      }
      ast_mutex_unlock(&p->lock);
   }
   AST_LIST_UNLOCK(&agents);
   if ( !count_agents ) 
      ast_cli(a->fd, "No Agents are configured in %s\n",config);
   else 
      ast_cli(a->fd, "%d agents configured [%d online , %d offline]\n",count_agents, online_agents, offline_agents);
   ast_cli(a->fd, "\n");
                   
   return CLI_SUCCESS;
}

static char* agents_show_online	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)			[static]

Definition at line 1895 of file chan_agent.c.

References agent_pvt::acknowledged, agent_pvt::agent, ast_cli_args::argc, ast_bridged_channel(), ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, AST_MAX_BUF, ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), agent_pvt::chan, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, agent_pvt::lock, agent_pvt::loginchan, agent_pvt::moh, ast_channel::name, agent_pvt::name, agent_pvt::owner, and ast_cli_entry::usage.

{
   struct agent_pvt *p;
   char username[AST_MAX_BUF];
   char location[AST_MAX_BUF] = "";
   char talkingto[AST_MAX_BUF] = "";
   char music[AST_MAX_BUF];
   int count_agents = 0;           /* Number of agents configured */
   int online_agents = 0;          /* Number of online agents */
   int agent_status = 0;           /* 0 means offline, 1 means online */

   switch (cmd) {
   case CLI_INIT:
      e->command = "agent show online";
      e->usage =
         "Usage: agent show online\n"
         "       Provides a list of all online agents.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc != 3)
      return CLI_SHOWUSAGE;

   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      agent_status = 0;       /* reset it to offline */
      ast_mutex_lock(&p->lock);
      if (!ast_strlen_zero(p->name))
         snprintf(username, sizeof(username), "(%s) ", p->name);
      else
         username[0] = '\0';
      if (p->chan) {
         snprintf(location, sizeof(location), "logged in on %s", p->chan->name);
         if (p->owner && ast_bridged_channel(p->owner)) 
            snprintf(talkingto, sizeof(talkingto), " talking to %s", ast_bridged_channel(p->owner)->name);
         else 
            strcpy(talkingto, " is idle");
         agent_status = 1;
         online_agents++;
      } else if (!ast_strlen_zero(p->loginchan)) {
         snprintf(location, sizeof(location) - 20, "available at '%s'", p->loginchan);
         talkingto[0] = '\0';
         agent_status = 1;
         online_agents++;
         if (p->acknowledged)
            strncat(location, " (Confirmed)", sizeof(location) - strlen(location) - 1);
      }
      if (!ast_strlen_zero(p->moh))
         snprintf(music, sizeof(music), " (musiconhold is '%s')", p->moh);
      if (agent_status)
         ast_cli(a->fd, "%-12.12s %s%s%s%s\n", p->agent, username, location, talkingto, music);
      count_agents++;
      ast_mutex_unlock(&p->lock);
   }
   AST_LIST_UNLOCK(&agents);
   if (!count_agents) 
      ast_cli(a->fd, "No Agents are configured in %s\n", config);
   else
      ast_cli(a->fd, "%d agents online\n", online_agents);
   ast_cli(a->fd, "\n");
   return CLI_SUCCESS;
}

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

Definition at line 1350 of file chan_agent.c.

References agent_pvt::abouttograb, agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_cleanup(), agent_new(), ast_channel_masquerade(), ast_copy_string(), ast_debug, AST_FLAG_ZOMBIE, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_setstate(), AST_STATE_DOWN, AST_STATE_UP, ast_streamfile(), ast_waitstream(), agent_pvt::chan, ast_channel::context, agent_pvt::group, ast_channel::language, agent_pvt::lock, ast_channel::name, agent_pvt::owner, and agent_pvt::pending.

Referenced by login_exec().

{
   struct ast_channel *chan=NULL, *parent=NULL;
   struct agent_pvt *p;
   int res;

   ast_debug(1, "Checking availability of '%s'\n", newlyavailable->agent);
   if (needlock)
      AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      if (p == newlyavailable) {
         continue;
      }
      ast_mutex_lock(&p->lock);
      if (!p->abouttograb && p->pending && ((p->group && (newlyavailable->group & p->group)) || !strcmp(p->agent, newlyavailable->agent))) {
         ast_debug(1, "Call '%s' looks like a winner for agent '%s'\n", p->owner->name, newlyavailable->agent);
         /* We found a pending call, time to merge */
         chan = agent_new(newlyavailable, AST_STATE_DOWN);
         parent = p->owner;
         p->abouttograb = 1;
         ast_mutex_unlock(&p->lock);
         break;
      }
      ast_mutex_unlock(&p->lock);
   }
   if (needlock)
      AST_LIST_UNLOCK(&agents);
   if (parent && chan)  {
      if (newlyavailable->ackcall > 1) {
         /* Don't do beep here */
         res = 0;
      } else {
         ast_debug(3, "Playing beep, lang '%s'\n", newlyavailable->chan->language);
         res = ast_streamfile(newlyavailable->chan, beep, newlyavailable->chan->language);
         ast_debug(3, "Played beep, result '%d'\n", res);
         if (!res) {
            res = ast_waitstream(newlyavailable->chan, "");
            ast_debug(1, "Waited for stream, result '%d'\n", res);
         }
      }
      if (!res) {
         /* Note -- parent may have disappeared */
         if (p->abouttograb) {
            newlyavailable->acknowledged = 1;
            /* Safe -- agent lock already held */
            ast_setstate(parent, AST_STATE_UP);
            ast_setstate(chan, AST_STATE_UP);
            ast_copy_string(parent->context, chan->context, sizeof(parent->context));
            /* Go ahead and mark the channel as a zombie so that masquerade will
               destroy it for us, and we need not call ast_hangup */
            ast_set_flag(chan, AST_FLAG_ZOMBIE);
            ast_channel_masquerade(parent, chan);
            p->abouttograb = 0;
         } else {
            ast_debug(1, "Sneaky, parent disappeared in the mean time...\n");
            agent_cleanup(newlyavailable);
         }
      } else {
         ast_debug(1, "Ugh...  Agent hung up at exactly the wrong time\n");
         agent_cleanup(newlyavailable);
      }
   }
   return 0;
}

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

Definition at line 1415 of file chan_agent.c.

References agent_pvt::abouttograb, agent_pvt::agent, ast_debug, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), ast_streamfile(), ast_waitstream(), agent_pvt::chan, agent_pvt::group, ast_channel::language, agent_pvt::lock, ast_channel::name, agent_pvt::owner, and agent_pvt::pending.

Referenced by login_exec().

{
   struct agent_pvt *p;
   int res=0;

   ast_debug(1, "Checking beep availability of '%s'\n", newlyavailable->agent);
   if (needlock)
      AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      if (p == newlyavailable) {
         continue;
      }
      ast_mutex_lock(&p->lock);
      if (!p->abouttograb && p->pending && ((p->group && (newlyavailable->group & p->group)) || !strcmp(p->agent, newlyavailable->agent))) {
         ast_debug(1, "Call '%s' looks like a would-be winner for agent '%s'\n", p->owner->name, newlyavailable->agent);
         ast_mutex_unlock(&p->lock);
         break;
      }
      ast_mutex_unlock(&p->lock);
   }
   if (needlock)
      AST_LIST_UNLOCK(&agents);
   if (p) {
      ast_mutex_unlock(&newlyavailable->lock);
      ast_debug(3, "Playing beep, lang '%s'\n", newlyavailable->chan->language);
      res = ast_streamfile(newlyavailable->chan, beep, newlyavailable->chan->language);
      ast_debug(1, "Played beep, result '%d'\n", res);
      if (!res) {
         res = ast_waitstream(newlyavailable->chan, "");
         ast_debug(1, "Waited for stream, result '%d'\n", res);
      }
      ast_mutex_lock(&newlyavailable->lock);
   }
   return res;
}

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

Definition at line 1790 of file chan_agent.c.

References agent_pvt::agent, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, AST_MAX_AGENT, ast_strdup, len(), agent_pvt::loginstart, and agent_pvt::name.

Referenced by agent_logoff_cmd().

{
   char *ret = NULL;

   if (pos == 2) {
      struct agent_pvt *p;
      char name[AST_MAX_AGENT];
      int which = 0, len = strlen(word);

      AST_LIST_LOCK(&agents);
      AST_LIST_TRAVERSE(&agents, p, list) {
         snprintf(name, sizeof(name), "Agent/%s", p->agent);
         if (!strncasecmp(word, name, len) && p->loginstart && ++which > state) {
            ret = ast_strdup(name);
            break;
         }
      }
      AST_LIST_UNLOCK(&agents);
   } else if (pos == 3 && state == 0) 
      return ast_strdup("soft");
   
   return ret;
}

static void dump_agents

(

void

)

[static]

Dump AgentCallbackLogin agents to the ASTdb database for persistence.

Definition at line 2362 of file chan_agent.c.

References agent_pvt::agent, ast_db_del(), ast_db_put(), ast_debug, AST_LIST_TRAVERSE, ast_log(), ast_strlen_zero(), buf, agent_pvt::chan, LOG_WARNING, agent_pvt::logincallerid, and agent_pvt::loginchan.

Referenced by agent_hangup(), and agent_logoff_maintenance().

{
   struct agent_pvt *cur_agent = NULL;
   char buf[256];

   AST_LIST_TRAVERSE(&agents, cur_agent, list) {
      if (cur_agent->chan)
         continue;

      if (!ast_strlen_zero(cur_agent->loginchan)) {
         snprintf(buf, sizeof(buf), "%s;%s", cur_agent->loginchan, cur_agent->logincallerid);
         if (ast_db_put(pa_family, cur_agent->agent, buf))
            ast_log(LOG_WARNING, "failed to create persistent entry in ASTdb for %s!\n", buf);
         else
            ast_debug(1, "Saved Agent: %s on %s\n", cur_agent->agent, cur_agent->loginchan);
      } else {
         /* Delete -  no agent or there is an error */
         ast_db_del(pa_family, cur_agent->agent);
      }
   }
}

static struct agent_pvt* find_agent

(

char *

agentid

)

[static, read]

Note:

This function expects the agent list to be locked

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

References agent_pvt::agent, AST_APP_ARG, ast_copy_string(), AST_DECLARE_APP_ARGS, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), AST_NONSTANDARD_APP_ARGS, ast_strlen_zero(), agent_pvt::chan, find_agent(), LOG_WARNING, agent_pvt::loginchan, agent_pvt::moh, ast_channel::name, agent_pvt::name, parse(), agent_pvt::password, and status.

{
   char *parse;    
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(agentid);
      AST_APP_ARG(item);
   );
   char *tmp;
   struct agent_pvt *agent;

   buf[0] = '\0';

   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "The AGENT function requires an argument - agentid!\n");
      return -1;
   }

   parse = ast_strdupa(data);

   AST_NONSTANDARD_APP_ARGS(args, parse, ':');
   if (!args.item)
      args.item = "status";

   AST_LIST_LOCK(&agents);

   if (!(agent = find_agent(args.agentid))) {
      AST_LIST_UNLOCK(&agents);
      ast_log(LOG_WARNING, "Agent '%s' not found!\n", args.agentid);
      return -1;
   }

   if (!strcasecmp(args.item, "status")) {
      char *status = "LOGGEDOUT";
      if (agent->chan || !ast_strlen_zero(agent->loginchan)) 
         status = "LOGGEDIN"; 
      ast_copy_string(buf, status, len);
   } else if (!strcasecmp(args.item, "password")) 
      ast_copy_string(buf, agent->password, len);
   else if (!strcasecmp(args.item, "name"))
      ast_copy_string(buf, agent->name, len);
   else if (!strcasecmp(args.item, "mohclass"))
      ast_copy_string(buf, agent->moh, len);
   else if (!strcasecmp(args.item, "channel")) {
      if (agent->chan) {
         ast_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); 

   AST_LIST_UNLOCK(&agents);

   return 0;
}

static int load_module

(

void

)

[static]

Initialize the Agents module. This function is being called by Asterisk when loading the module. Among other things it registers applications, cli commands and reads the cofiguration file.

Returns:

int Always 0.

Definition at line 2567 of file chan_agent.c.

References action_agent_logoff(), action_agents(), agent_function, agent_tech, agentmonitoroutgoing_exec(), ARRAY_LEN, ast_channel_register(), ast_cli_register_multiple(), ast_custom_function_register, ast_log(), ast_manager_register2(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_register_application_xml, cli_agents, EVENT_FLAG_AGENT, LOG_ERROR, login_exec(), read_agent_config(), and reload_agents().

{
   /* Make sure we can register our agent channel type */
   if (ast_channel_register(&agent_tech)) {
      ast_log(LOG_ERROR, "Unable to register channel class 'Agent'\n");
      return AST_MODULE_LOAD_FAILURE;
   }
   /* Read in the config */
   if (!read_agent_config(0))
      return AST_MODULE_LOAD_DECLINE;
   if (persistent_agents)
      reload_agents();
   /* Dialplan applications */
   ast_register_application_xml(app, login_exec);
   ast_register_application_xml(app3, agentmonitoroutgoing_exec);

   /* Manager commands */
   ast_manager_register2("Agents", EVENT_FLAG_AGENT, action_agents, "Lists agents and their status", mandescr_agents);
   ast_manager_register2("AgentLogoff", EVENT_FLAG_AGENT, action_agent_logoff, "Sets an agent as no longer logged in", mandescr_agent_logoff);

   /* CLI Commands */
   ast_cli_register_multiple(cli_agents, ARRAY_LEN(cli_agents));

   /* Dialplan Functions */
   ast_custom_function_register(&agent_function);

   return AST_MODULE_LOAD_SUCCESS;
}

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

Log in agent application.

Called by the AgentLogin application (from the dial plan).

Parameters:

	chan
	data

Returns:

See also:

agentmonitoroutgoing_exec(), load_module().

Definition at line 1981 of file chan_agent.c.

References ast_channel::_state, agent_pvt::acceptdtmf, agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_ack_sleep(), agent_cont_sleep(), AGENT_FLAG_ACCEPTDTMF, AGENT_FLAG_ACKCALL, AGENT_FLAG_AUTOLOGOFF, AGENT_FLAG_ENDDTMF, AGENT_FLAG_WRAPUPTIME, agent_pvt::app_complete_cond, agent_pvt::app_lock, agent_pvt::app_lock_flag, ast_answer(), AST_APP_ARG, ast_app_getdata(), ast_best_codec(), ast_channel_lock, ast_channel_unlock, ast_cond_destroy(), ast_cond_wait(), AST_CONTROL_HOLD, ast_copy_string(), ast_debug, AST_DECLARE_APP_ARGS, AST_DEVICE_NOT_INUSE, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), ast_free, ast_getformatname(), ast_indicate_data(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), AST_MAX_AGENT, AST_MAX_FILENAME_LEN, ast_module_user_add, ast_module_user_remove, ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), ast_queue_log(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_set_flag, ast_set_read_format(), ast_set_write_format(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_streamfile(), ast_strlen_zero(), ast_true(), ast_tv(), ast_tvdiff_ms(), ast_tvnow(), ast_verb, ast_waitstream(), agent_pvt::autologoff, ast_channel::cdr, agent_pvt::chan, ast_cdr::channel, check_availability(), check_beep(), agent_pvt::dead, agent_pvt::deferlogoff, agent_pvt::enddtmf, EVENT_FLAG_AGENT, ast_channel::language, agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, LOG_WARNING, agent_pvt::logincallerid, agent_pvt::loginchan, agent_pvt::loginstart, manager_event, agent_pvt::moh, ast_channel::name, ast_channel::nativeformats, agent_pvt::owner, parse(), pass, agent_pvt::password, pbx_builtin_getvar_helper(), agent_pvt::pending, ast_channel::readformat, S_OR, ast_channel::uniqueid, update_cdr, agent_pvt::wrapuptime, and ast_channel::writeformat.

Referenced by load_module().

{
   int res=0;
   int tries = 0;
   int max_login_tries = maxlogintries;
   struct agent_pvt *p;
   struct ast_module_user *u;
   int login_state = 0;
   char user[AST_MAX_AGENT] = "";
   char pass[AST_MAX_AGENT];
   char agent[AST_MAX_AGENT] = "";
   char xpass[AST_MAX_AGENT] = "";
   char *errmsg;
   char *parse;
   AST_DECLARE_APP_ARGS(args,
              AST_APP_ARG(agent_id);
              AST_APP_ARG(options);
              AST_APP_ARG(extension);
      );
   const char *tmpoptions = NULL;
   int play_announcement = 1;
   char agent_goodbye[AST_MAX_FILENAME_LEN];
   int update_cdr = updatecdr;
   char *filename = "agent-loginok";

   u = ast_module_user_add(chan);

   parse = ast_strdupa(data);

   AST_STANDARD_APP_ARGS(args, parse);

   ast_copy_string(agent_goodbye, agentgoodbye, sizeof(agent_goodbye));

   ast_channel_lock(chan);
   /* Set Channel Specific Login Overrides */
   if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTLMAXLOGINTRIES"))) {
      max_login_tries = atoi(pbx_builtin_getvar_helper(chan, "AGENTMAXLOGINTRIES"));
      if (max_login_tries < 0)
         max_login_tries = 0;
      tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTMAXLOGINTRIES");
      ast_verb(3, "Saw variable AGENTMAXLOGINTRIES=%s, setting max_login_tries to: %d on Channel '%s'.\n",tmpoptions,max_login_tries,chan->name);
   }
   if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTUPDATECDR"))) {
      if (ast_true(pbx_builtin_getvar_helper(chan, "AGENTUPDATECDR")))
         update_cdr = 1;
      else
         update_cdr = 0;
      tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTUPDATECDR");
      ast_verb(3, "Saw variable AGENTUPDATECDR=%s, setting update_cdr to: %d on Channel '%s'.\n",tmpoptions,update_cdr,chan->name);
   }
   if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTGOODBYE"))) {
      strcpy(agent_goodbye, pbx_builtin_getvar_helper(chan, "AGENTGOODBYE"));
      tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTGOODBYE");
      ast_verb(3, "Saw variable AGENTGOODBYE=%s, setting agent_goodbye to: %s on Channel '%s'.\n",tmpoptions,agent_goodbye,chan->name);
   }
   ast_channel_unlock(chan);
   /* End Channel Specific Login Overrides */
   
   if (!ast_strlen_zero(args.options)) {
      if (strchr(args.options, 's')) {
         play_announcement = 0;
      }
   }

   if (chan->_state != AST_STATE_UP)
      res = ast_answer(chan);
   if (!res) {
      if (!ast_strlen_zero(args.agent_id))
         ast_copy_string(user, args.agent_id, AST_MAX_AGENT);
      else
         res = ast_app_getdata(chan, "agent-user", user, sizeof(user) - 1, 0);
   }
   while (!res && (max_login_tries==0 || tries < max_login_tries)) {
      tries++;
      /* Check for password */
      AST_LIST_LOCK(&agents);
      AST_LIST_TRAVERSE(&agents, p, list) {
         if (!strcmp(p->agent, user) && !p->pending)
            ast_copy_string(xpass, p->password, sizeof(xpass));
      }
      AST_LIST_UNLOCK(&agents);
      if (!res) {
         if (!ast_strlen_zero(xpass))
            res = ast_app_getdata(chan, "agent-pass", pass, sizeof(pass) - 1, 0);
         else
            pass[0] = '\0';
      }
      errmsg = "agent-incorrect";

#if 0
      ast_log(LOG_NOTICE, "user: %s, pass: %s\n", user, pass);
#endif      

      /* Check again for accuracy */
      AST_LIST_LOCK(&agents);
      AST_LIST_TRAVERSE(&agents, p, list) {
         int unlock_channel = 1;
         ast_channel_lock(chan);
         ast_mutex_lock(&p->lock);
         if (!strcmp(p->agent, user) &&
             !strcmp(p->password, pass) && !p->pending) {
            login_state = 1; /* Successful Login */

            /* Ensure we can't be gotten until we're done */
            p->lastdisc = ast_tvnow();
            p->lastdisc.tv_sec++;

            /* Set Channel Specific Agent Overrides */
            if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTACKCALL"))) {
               if (!strcasecmp(pbx_builtin_getvar_helper(chan, "AGENTACKCALL"), "always"))
                  p->ackcall = 2;
               else if (ast_true(pbx_builtin_getvar_helper(chan, "AGENTACKCALL")))
                  p->ackcall = 1;
               else
                  p->ackcall = 0;
               tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTACKCALL");
               ast_verb(3, "Saw variable AGENTACKCALL=%s, setting ackcall to: %d for Agent '%s'.\n", tmpoptions, p->ackcall, p->agent);
               ast_set_flag(p, AGENT_FLAG_ACKCALL);
            } else {
               p->ackcall = ackcall;
            }
            if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTAUTOLOGOFF"))) {
               p->autologoff = atoi(pbx_builtin_getvar_helper(chan, "AGENTAUTOLOGOFF"));
               if (p->autologoff < 0)
                  p->autologoff = 0;
               tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTAUTOLOGOFF");
               ast_verb(3, "Saw variable AGENTAUTOLOGOFF=%s, setting autologff to: %d for Agent '%s'.\n", tmpoptions, p->autologoff, p->agent);
               ast_set_flag(p, AGENT_FLAG_AUTOLOGOFF);
            } else {
               p->autologoff = autologoff;
            }
            if (!ast_strlen_zero(pbx_builtin_getvar_helper(chan, "AGENTWRAPUPTIME"))) {
               p->wrapuptime = atoi(pbx_builtin_getvar_helper(chan, "AGENTWRAPUPTIME"));
               if (p->wrapuptime < 0)
                  p->wrapuptime = 0;
               tmpoptions=pbx_builtin_getvar_helper(chan, "AGENTWRAPUPTIME");
               ast_verb(3, "Saw variable AGENTWRAPUPTIME=%s, setting wrapuptime to: %d for Agent '%s'.\n", tmpoptions, p->wrapuptime, p->agent);
               ast_set_flag(p, AGENT_FLAG_WRAPUPTIME);
            } else {
               p->wrapuptime = wrapuptime;
            }
            tmpoptions = pbx_builtin_getvar_helper(chan, "AGENTACCEPTDTMF");
            if (!ast_strlen_zero(tmpoptions)) {
               p->acceptdtmf = *tmpoptions;
               ast_verb(3, "Saw variable AGENTACCEPTDTMF=%s, setting acceptdtmf to: %c for Agent '%s'.\n", tmpoptions, p->acceptdtmf, p->agent);
               ast_set_flag(p, AGENT_FLAG_ACCEPTDTMF);
            }
            tmpoptions = pbx_builtin_getvar_helper(chan, "AGENTENDDTMF");
            if (!ast_strlen_zero(tmpoptions)) {
               p->enddtmf = *tmpoptions;
               ast_verb(3, "Saw variable AGENTENDDTMF=%s, setting enddtmf to: %c for Agent '%s'.\n", tmpoptions, p->enddtmf, p->agent);
               ast_set_flag(p, AGENT_FLAG_ENDDTMF);
            }
            ast_channel_unlock(chan);
            unlock_channel = 0;
            /* End Channel Specific Agent Overrides */
            if (!p->chan) {
               long logintime;
               snprintf(agent, sizeof(agent), "Agent/%s", p->agent);

               p->loginchan[0] = '\0';
               p->logincallerid[0] = '\0';
               p->acknowledged = 0;
               
               ast_mutex_unlock(&p->lock);
               AST_LIST_UNLOCK(&agents);
               if( !res && play_announcement==1 )
                  res = ast_streamfile(chan, filename, chan->language);
               if (!res)
                  ast_waitstream(chan, "");
               AST_LIST_LOCK(&agents);
               ast_mutex_lock(&p->lock);
               if (!res) {
                  res = ast_set_read_format(chan, ast_best_codec(chan->nativeformats));
                  if (res)
                     ast_log(LOG_WARNING, "Unable to set read format to %d\n", ast_best_codec(chan->nativeformats));
               }
               if (!res) {
                  res = ast_set_write_format(chan, ast_best_codec(chan->nativeformats));
                  if (res)
                     ast_log(LOG_WARNING, "Unable to set write format to %d\n", ast_best_codec(chan->nativeformats));
               }
               /* Check once more just in case */
               if (p->chan)
                  res = -1;
               if (!res) {
                  ast_indicate_data(chan, AST_CONTROL_HOLD, 
                     S_OR(p->moh, NULL), 
                     !ast_strlen_zero(p->moh) ? strlen(p->moh) + 1 : 0);
                  if (p->loginstart == 0)
                     time(&p->loginstart);
                  manager_event(EVENT_FLAG_AGENT, "Agentlogin",
                           "Agent: %s\r\n"
                           "Channel: %s\r\n"
                           "Uniqueid: %s\r\n",
                           p->agent, chan->name, chan->uniqueid);
                  if (update_cdr && chan->cdr)
                     snprintf(chan->cdr->channel, sizeof(chan->cdr->channel), "Agent/%s", p->agent);
                  ast_queue_log("NONE", chan->uniqueid, agent, "AGENTLOGIN", "%s", chan->name);
                  ast_verb(2, "Agent '%s' logged in (format %s/%s)\n", p->agent,
                            ast_getformatname(chan->readformat), ast_getformatname(chan->writeformat));
                  /* Login this channel and wait for it to go away */
                  p->chan = chan;
                  if (p->ackcall > 1)
                     check_beep(p, 0);
                  else
                     check_availability(p, 0);
                  ast_mutex_unlock(&p->lock);
                  AST_LIST_UNLOCK(&agents);
                  ast_devstate_changed(AST_DEVICE_NOT_INUSE, "Agent/%s", p->agent);
                  while (res >= 0) {
                     ast_mutex_lock(&p->lock);
                     if (p->deferlogoff && p->chan) {
                        ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
                        p->deferlogoff = 0;
                     }
                     if (p->chan != chan)
                        res = -1;
                     ast_mutex_unlock(&p->lock);
                     /* Yield here so other interested threads can kick in. */
                     sched_yield();
                     if (res)
                        break;

                     AST_LIST_LOCK(&agents);
                     ast_mutex_lock(&p->lock);
                     if (p->lastdisc.tv_sec) {
                        if (ast_tvdiff_ms(ast_tvnow(), p->lastdisc) > 0) {
                           ast_debug(1, "Wrapup time for %s expired!\n", p->agent);
                           p->lastdisc = ast_tv(0, 0);
                           ast_devstate_changed(AST_DEVICE_NOT_INUSE, "Agent/%s", p->agent);
                           if (p->ackcall > 1)
                              check_beep(p, 0);
                           else
                              check_availability(p, 0);
                        }
                     }
                     ast_mutex_unlock(&p->lock);
                     AST_LIST_UNLOCK(&agents);
                     /* Synchronize channel ownership between call to agent and itself. */
                     ast_mutex_lock(&p->app_lock);
                     if (p->app_lock_flag == 1) {
                        ast_cond_wait(&p->app_complete_cond, &p->app_lock);
                     }
                     ast_mutex_unlock(&p->app_lock);
                     ast_mutex_lock(&p->lock);
                     ast_mutex_unlock(&p->lock);
                     if (p->ackcall > 1) 
                        res = agent_ack_sleep(p);
                     else
                        res = ast_safe_sleep_conditional( chan, 1000, agent_cont_sleep, p );
                     if ((p->ackcall > 1)  && (res == 1)) {
                        AST_LIST_LOCK(&agents);
                        ast_mutex_lock(&p->lock);
                        check_availability(p, 0);
                        ast_mutex_unlock(&p->lock);
                        AST_LIST_UNLOCK(&agents);
                        res = 0;
                     }
                     sched_yield();
                  }
                  ast_mutex_lock(&p->lock);
                  if (res && p->owner) 
                     ast_log(LOG_WARNING, "Huh?  We broke out when there was still an owner?\n");
                  /* Log us off if appropriate */
                  if (p->chan == chan) {
                     p->chan = NULL;
                  }
                  p->acknowledged = 0;
                  logintime = time(NULL) - p->loginstart;
                  p->loginstart = 0;
                  ast_mutex_unlock(&p->lock);
                  manager_event(EVENT_FLAG_AGENT, "Agentlogoff",
                           "Agent: %s\r\n"
                           "Logintime: %ld\r\n"
                           "Uniqueid: %s\r\n",
                           p->agent, logintime, chan->uniqueid);
                  ast_queue_log("NONE", chan->uniqueid, agent, "AGENTLOGOFF", "%s|%ld", chan->name, logintime);
                  ast_verb(2, "Agent '%s' logged out\n", p->agent);
                  /* If there is no owner, go ahead and kill it now */
                  ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent);
                  if (p->dead && !p->owner) {
                     ast_mutex_destroy(&p->lock);
                     ast_mutex_destroy(&p->app_lock);
                     ast_cond_destroy(&p->app_complete_cond);
                     ast_free(p);
                  }
               }
               else {
                  ast_mutex_unlock(&p->lock);
                  p = NULL;
               }
               res = -1;
            } else {
               ast_mutex_unlock(&p->lock);
               errmsg = "agent-alreadyon";
               p = NULL;
            }
            break;
         }
         ast_mutex_unlock(&p->lock);
         if (unlock_channel) {
            ast_channel_unlock(chan);
         }
      }
      if (!p)
         AST_LIST_UNLOCK(&agents);

      if (!res && (max_login_tries==0 || tries < max_login_tries))
         res = ast_app_getdata(chan, errmsg, user, sizeof(user) - 1, 0);
   }
      
   if (!res)
      res = ast_safe_sleep(chan, 500);

   ast_module_user_remove(u);
   
   return -1;
}

static force_inline int powerof

(

unsigned int

d

)

[static]

Definition at line 1547 of file chan_agent.c.

Referenced by agents_show().

{
   int x = ffs(d);

   if (x)
      return x - 1;

   return 0;
}

static int read_agent_config

(

int

reload

)

[static]

Read configuration data. The file named agents.conf.

Returns:

Always 0, or so it seems.

Definition at line 1180 of file chan_agent.c.

References add_agent(), agent_pvt::app_complete_cond, agent_pvt::app_lock, ast_category_browse(), ast_cond_destroy(), ast_config_destroy(), ast_config_load, ast_copy_string(), ast_free, ast_get_group(), AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log(), ast_mutex_destroy(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_strlen_zero(), ast_true(), ast_variable_browse(), ast_variable_retrieve(), agent_pvt::chan, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, agent_pvt::dead, agent_pvt::lock, LOG_ERROR, LOG_NOTICE, ast_variable::name, ast_variable::next, agent_pvt::owner, secret, and ast_variable::value.

Referenced by load_module(), and reload().

{
   struct ast_config *cfg;
   struct ast_config *ucfg;
   struct ast_variable *v;
   struct agent_pvt *p;
   const char *general_val;
   const char *catname;
   const char *hasagent;
   int genhasagent;
   struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };

   group = 0;
   autologoff = 0;
   wrapuptime = 0;
   ackcall = 0;
   endcall = 1;
   cfg = ast_config_load(config, config_flags);
   if (!cfg) {
      ast_log(LOG_NOTICE, "No agent configuration found -- agent support disabled\n");
      return 0;
   } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
      return -1;
   } else if (cfg == CONFIG_STATUS_FILEINVALID) {
      ast_log(LOG_ERROR, "%s contains a parsing error.  Aborting\n", config);
      return 0;
   }
   if ((ucfg = ast_config_load("users.conf", config_flags))) {
      if (ucfg == CONFIG_STATUS_FILEUNCHANGED) {
         ucfg = NULL;
      } else if (ucfg == CONFIG_STATUS_FILEINVALID) {
         ast_log(LOG_ERROR, "users.conf contains a parsing error.  Aborting\n");
         return 0;
      }
   }

   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      p->dead = 1;
   }
   strcpy(moh, "default");
   /* set the default recording values */
   recordagentcalls = 0;
   strcpy(recordformat, "wav");
   strcpy(recordformatext, "wav");
   urlprefix[0] = '\0';
   savecallsin[0] = '\0';

   /* Read in [general] section for persistence */
   if ((general_val = ast_variable_retrieve(cfg, "general", "persistentagents")))
      persistent_agents = ast_true(general_val);
   multiplelogin = ast_true(ast_variable_retrieve(cfg, "general", "multiplelogin"));

   /* Read in the [agents] section */
   v = ast_variable_browse(cfg, "agents");
   while(v) {
      /* Create the interface list */
      if (!strcasecmp(v->name, "agent")) {
         add_agent(v->value, 0);
      } else if (!strcasecmp(v->name, "group")) {
         group = ast_get_group(v->value);
      } else if (!strcasecmp(v->name, "autologoff")) {
         autologoff = atoi(v->value);
         if (autologoff < 0)
            autologoff = 0;
      } else if (!strcasecmp(v->name, "ackcall")) {
         if (!strcasecmp(v->value, "always"))
            ackcall = 2;
         else if (ast_true(v->value))
            ackcall = 1;
         else
            ackcall = 0;
      } else if (!strcasecmp(v->name, "endcall")) {
         endcall = ast_true(v->value);
      } else if (!strcasecmp(v->name, "acceptdtmf")) {
         acceptdtmf = *(v->value);
         ast_log(LOG_NOTICE, "Set acceptdtmf to %c\n", acceptdtmf);
      } else if (!strcasecmp(v->name, "enddtmf")) {
         enddtmf = *(v->value);
      } else if (!strcasecmp(v->name, "wrapuptime")) {
         wrapuptime = atoi(v->value);
         if (wrapuptime < 0)
            wrapuptime = 0;
      } else if (!strcasecmp(v->name, "maxlogintries") && !ast_strlen_zero(v->value)) {
         maxlogintries = atoi(v->value);
         if (maxlogintries < 0)
            maxlogintries = 0;
      } else if (!strcasecmp(v->name, "goodbye") && !ast_strlen_zero(v->value)) {
         strcpy(agentgoodbye,v->value);
      } else if (!strcasecmp(v->name, "musiconhold")) {
         ast_copy_string(moh, v->value, sizeof(moh));
      } else if (!strcasecmp(v->name, "updatecdr")) {
         if (ast_true(v->value))
            updatecdr = 1;
         else
            updatecdr = 0;
      } else if (!strcasecmp(v->name, "autologoffunavail")) {
         if (ast_true(v->value))
            autologoffunavail = 1;
         else
            autologoffunavail = 0;
      } else if (!strcasecmp(v->name, "recordagentcalls")) {
         recordagentcalls = ast_true(v->value);
      } else if (!strcasecmp(v->name, "recordformat")) {
         ast_copy_string(recordformat, v->value, sizeof(recordformat));
         if (!strcasecmp(v->value, "wav49"))
            strcpy(recordformatext, "WAV");
         else
            ast_copy_string(recordformatext, v->value, sizeof(recordformatext));
      } else if (!strcasecmp(v->name, "urlprefix")) {
         ast_copy_string(urlprefix, v->value, sizeof(urlprefix));
         if (urlprefix[strlen(urlprefix) - 1] != '/')
            strncat(urlprefix, "/", sizeof(urlprefix) - strlen(urlprefix) - 1);
      } else if (!strcasecmp(v->name, "savecallsin")) {
         if (v->value[0] == '/')
            ast_copy_string(savecallsin, v->value, sizeof(savecallsin));
         else
            snprintf(savecallsin, sizeof(savecallsin) - 2, "/%s", v->value);
         if (savecallsin[strlen(savecallsin) - 1] != '/')
            strncat(savecallsin, "/", sizeof(savecallsin) - strlen(savecallsin) - 1);
      } else if (!strcasecmp(v->name, "custom_beep")) {
         ast_copy_string(beep, v->value, sizeof(beep));
      }
      v = v->next;
   }
   if (ucfg) {
      genhasagent = ast_true(ast_variable_retrieve(ucfg, "general", "hasagent"));
      catname = ast_category_browse(ucfg, NULL);
      while(catname) {
         if (strcasecmp(catname, "general")) {
            hasagent = ast_variable_retrieve(ucfg, catname, "hasagent");
            if (ast_true(hasagent) || (!hasagent && genhasagent)) {
               char tmp[256];
               const char *fullname = ast_variable_retrieve(ucfg, catname, "fullname");
               const char *secret = ast_variable_retrieve(ucfg, catname, "secret");
               if (!fullname)
                  fullname = "";
               if (!secret)
                  secret = "";
               snprintf(tmp, sizeof(tmp), "%s,%s,%s", catname, secret,fullname);
               add_agent(tmp, 0);
            }
         }
         catname = ast_category_browse(ucfg, catname);
      }
      ast_config_destroy(ucfg);
   }
   AST_LIST_TRAVERSE_SAFE_BEGIN(&agents, p, list) {
      if (p->dead) {
         AST_LIST_REMOVE_CURRENT(list);
         /* Destroy if  appropriate */
         if (!p->owner) {
            if (!p->chan) {
               ast_mutex_destroy(&p->lock);
               ast_mutex_destroy(&p->app_lock);
               ast_cond_destroy(&p->app_complete_cond);
               ast_free(p);
            } else {
               /* Cause them to hang up */
               ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
            }
         }
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;
   AST_LIST_UNLOCK(&agents);
   ast_config_destroy(cfg);
   return 1;
}

static int reload

(

void

)

[static]

Definition at line 2596 of file chan_agent.c.

References read_agent_config(), and reload_agents().

{
   if (!read_agent_config(1)) {
      if (persistent_agents)
         reload_agents();
   }
   return 0;
}

static void reload_agents

(

void

)

[static]

Reload the persistent agents from astdb.

Definition at line 2387 of file chan_agent.c.

References agent_pvt::agent, ast_copy_string(), ast_db_del(), ast_db_freetree(), ast_db_get(), ast_db_gettree(), ast_debug, AST_DEVICE_UNKNOWN, ast_devstate_changed(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_db_entry::key, agent_pvt::lock, LOG_NOTICE, agent_pvt::logincallerid, agent_pvt::loginchan, agent_pvt::loginstart, ast_db_entry::next, parse(), and set_agentbycallerid().

Referenced by load_module(), and reload().

{
   char *agent_num;
   struct ast_db_entry *db_tree;
   struct ast_db_entry *entry;
   struct agent_pvt *cur_agent;
   char agent_data[256];
   char *parse;
   char *agent_chan;
   char *agent_callerid;

   db_tree = ast_db_gettree(pa_family, NULL);

   AST_LIST_LOCK(&agents);
   for (entry = db_tree; entry; entry = entry->next) {
      agent_num = entry->key + strlen(pa_family) + 2;
      AST_LIST_TRAVERSE(&agents, cur_agent, list) {
         ast_mutex_lock(&cur_agent->lock);
         if (strcmp(agent_num, cur_agent->agent) == 0)
            break;
         ast_mutex_unlock(&cur_agent->lock);
      }
      if (!cur_agent) {
         ast_db_del(pa_family, agent_num);
         continue;
      } else
         ast_mutex_unlock(&cur_agent->lock);
      if (!ast_db_get(pa_family, agent_num, agent_data, sizeof(agent_data)-1)) {
         ast_debug(1, "Reload Agent from AstDB: %s on %s\n", cur_agent->agent, agent_data);
         parse = agent_data;
         agent_chan = strsep(&parse, ";");
         agent_callerid = strsep(&parse, ";");
         ast_copy_string(cur_agent->loginchan, agent_chan, sizeof(cur_agent->loginchan));
         if (agent_callerid) {
            ast_copy_string(cur_agent->logincallerid, agent_callerid, sizeof(cur_agent->logincallerid));
            set_agentbycallerid(cur_agent->logincallerid, cur_agent->agent);
         } else
            cur_agent->logincallerid[0] = '\0';
         if (cur_agent->loginstart == 0)
            time(&cur_agent->loginstart);
         ast_devstate_changed(AST_DEVICE_UNKNOWN, "Agent/%s", cur_agent->agent); 
      }
   }
   AST_LIST_UNLOCK(&agents);
   if (db_tree) {
      ast_log(LOG_NOTICE, "Agents successfully reloaded from database.\n");
      ast_db_freetree(db_tree);
   }
}

static void set_agentbycallerid	(	const char *	callerid,
		const char *	agent
	)			[static]

store/clear the global variable that stores agentid based on the callerid

Definition at line 847 of file chan_agent.c.

References AST_MAX_BUF, ast_strlen_zero(), buf, GETAGENTBYCALLERID, and pbx_builtin_setvar_helper().

Referenced by agent_logoff_maintenance(), and reload_agents().

{
   char buf[AST_MAX_BUF];

   /* if there is no Caller ID, nothing to do */
   if (ast_strlen_zero(callerid))
      return;

   snprintf(buf, sizeof(buf), "%s_%s", GETAGENTBYCALLERID, callerid);
   pbx_builtin_setvar_helper(NULL, buf, agent);
}

static int unload_module

(

void

)

[static]

Definition at line 2605 of file chan_agent.c.

References agent_function, agent_tech, ARRAY_LEN, ast_channel_unregister(), ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_manager_unregister(), ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, ast_unregister_application(), cli_agents, and agent_pvt::owner.

{
   struct agent_pvt *p;
   /* First, take us out of the channel loop */
   ast_channel_unregister(&agent_tech);
   /* Unregister dialplan functions */
   ast_custom_function_unregister(&agent_function);   
   /* Unregister CLI commands */
   ast_cli_unregister_multiple(cli_agents, ARRAY_LEN(cli_agents));
   /* Unregister dialplan applications */
   ast_unregister_application(app);
   ast_unregister_application(app3);
   /* Unregister manager command */
   ast_manager_unregister("Agents");
   ast_manager_unregister("AgentLogoff");
   /* Unregister channel */
   AST_LIST_LOCK(&agents);
   /* Hangup all interfaces if they have an owner */
   while ((p = AST_LIST_REMOVE_HEAD(&agents, list))) {
      if (p->owner)
         ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
      ast_free(p);
   }
   AST_LIST_UNLOCK(&agents);
   return 0;
}

---

Variable Documentation

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

Definition at line 2636 of file chan_agent.c.

char acceptdtmf = DEFAULT_ACCEPTDTMF [static]

Definition at line 211 of file chan_agent.c.

Referenced by play_record_review().

int ackcall [static]

Definition at line 207 of file chan_agent.c.

struct ast_custom_function agent_function

Initial value:

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

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

struct ast_channel_tech agent_tech [static]

Channel interface description for PBX integration.

Definition at line 325 of file chan_agent.c.

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

char agentgoodbye[AST_MAX_FILENAME_LEN] = "vm-goodbye" [static]

Definition at line 215 of file chan_agent.c.

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

Definition at line 176 of file chan_agent.c.

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

Definition at line 177 of file chan_agent.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 2636 of file chan_agent.c.

int autologoff [static]

Definition at line 205 of file chan_agent.c.

int autologoffunavail = 0 [static]

Definition at line 210 of file chan_agent.c.

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

Definition at line 223 of file chan_agent.c.

struct ast_cli_entry cli_agents[] [static]

Initial value:

 {
   AST_CLI_DEFINE(agents_show, "Show status of agents"),
   AST_CLI_DEFINE(agents_show_online, "Show all online agents"),
   AST_CLI_DEFINE(agent_logoff_cmd, "Sets an agent offline"),
}

Definition at line 1965 of file chan_agent.c.

Referenced by load_module(), and unload_module().

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

Definition at line 174 of file chan_agent.c.

int endcall [static]

Definition at line 208 of file chan_agent.c.

char enddtmf = DEFAULT_ENDDTMF [static]

Definition at line 212 of file chan_agent.c.

ast_group_t group [static]

Definition at line 204 of file chan_agent.c.

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 183 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 179 of file chan_agent.c.

int maxlogintries = 3 [static]

Definition at line 214 of file chan_agent.c.

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

Definition at line 189 of file chan_agent.c.

Referenced by _get_mohbyname(), dial_exec_full(), moh_generate(), moh_release(), mohalloc(), and monmp3thread().

int multiplelogin = 1 [static]

Definition at line 209 of file chan_agent.c.

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

Persistent Agents astdb family

Definition at line 195 of file chan_agent.c.

int persistent_agents = 0 [static]

queues.conf [general] option

Definition at line 198 of file chan_agent.c.

int recordagentcalls = 0 [static]

Definition at line 217 of file chan_agent.c.

char recordformat[AST_MAX_BUF] = "" [static]

Definition at line 218 of file chan_agent.c.

char recordformatext[AST_MAX_BUF] = "" [static]

Definition at line 219 of file chan_agent.c.

char savecallsin[AST_MAX_BUF] = "" [static]

Definition at line 221 of file chan_agent.c.

const char tdesc[] = "Call Agent Proxy Channel" [static]

Definition at line 173 of file chan_agent.c.

int updatecdr = 0 [static]

Definition at line 222 of file chan_agent.c.

char urlprefix[AST_MAX_BUF] = "" [static]

Definition at line 220 of file chan_agent.c.

Referenced by start_monitor_exec().

int wrapuptime [static]

Definition at line 206 of file chan_agent.c.