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/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 "asterisk/data.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	DATA_EXPORT_AGENT(MEMBER)
#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, const char *dest, int timeout)
static int	agent_cleanup (struct agent_pvt *p)
static int	agent_cont_sleep (void *data)
static int	agent_devicestate (const char *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 struct ast_channel *	agent_lock_owner (struct agent_pvt *pvt)
	Locks the owning channel for a LOCKED pvt while obeying locking order. The pvt must enter this function locked and will be returned locked, but this function will unlock the pvt for a short time, so it can't be used while expecting the pvt to remain static. If function returns a non NULL channel, it will need to be unlocked and unrefed once it is no longer needed.
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 struct ast_channel *	agent_new (struct agent_pvt *p, int state, const char *linkedid)
	Create new agent channel.
static struct ast_frame *	agent_read (struct ast_channel *ast)
static struct ast_channel *	agent_request (const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *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, const char *data)
	Called by the AgentMonitorOutgoing application (from the dial plan).
static int	agents_data_provider_get (const struct ast_data_search *search, struct ast_data *data_root)
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)
	AST_DATA_STRUCTURE (agent_pvt, DATA_EXPORT_AGENT)
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 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, const char *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 int	unload_module (void)
Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .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 = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, .nonoptreq = "res_monitor,chan_local", }
static char	acceptdtmf = DEFAULT_ACCEPTDTMF
static int	ackcall
static 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 struct ast_data_handler	agents_data_provider
static struct ast_data_entry	agents_data_providers []
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 int	maxlogintries = 3
static char	moh [80] = "default"
static int	multiplelogin = 1
static const char	pa_family [] = "Agents"
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 211 of file chan_agent.c.

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

#define AST_MAX_BUF   256

Definition at line 212 of file chan_agent.c.

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

#define AST_MAX_FILENAME_LEN   256

Definition at line 213 of file chan_agent.c.

Referenced by login_exec().

#define CHECK_FORMATS	(	ast,
		p		)

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

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

#define DATA_EXPORT_AGENT

(

MEMBER

)

Definition at line 284 of file chan_agent.c.

#define DEFAULT_ACCEPTDTMF   '#'

Definition at line 218 of file chan_agent.c.

#define DEFAULT_ENDDTMF   '*'

Definition at line 219 of file chan_agent.c.

#define GETAGENTBYCALLERID   "AGENTBYCALLERID"

Definition at line 242 of file chan_agent.c.

Referenced by agentmonitoroutgoing_exec().

#define PA_MAX_LEN   2048

The maximum length of each persistent member agent database entry

Definition at line 216 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 244 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 554 of file chan_agent.c.

References agent_pvt::agent, ast_cdr_alloc(), ast_cdr_setuserfield(), ast_channel_uniqueid(), ast_log(), AST_MAX_BUF, ast_monitor_setjoinfiles(), ast_monitor_start(), ast_verbose, ast_channel::cdr, LOG_ERROR, ast_channel::monitor, 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_channel_uniqueid(ast));
      /* 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 2625 of file chan_agent.c.

static void __unreg_module

(

void

)

[static]

Definition at line 2625 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 1714 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. This function locks both the pvt and the channel that owns it for a while, but does not keep these locks.

Parameters:

	s
	m

Returns:

See also:

action_agent_logoff(), load_module().

Definition at line 1555 of file chan_agent.c.

References ast_channel::_bridge, agent_pvt::agent, agent_lock_owner(), ast_bridged_channel(), ast_channel_name(), ast_channel_unlock, ast_channel_unref, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, ast_strdupa, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_ack(), ast_channel::bridge, ast_channel::caller, agent_pvt::chan, ast_party_caller::id, agent_pvt::lock, agent_pvt::loginstart, agent_pvt::name, ast_party_id::number, agent_pvt::owner, S_COR, S_OR, status, ast_party_number::str, and ast_party_number::valid.

Referenced by load_module().

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

   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) {
      struct ast_channel *owner;
      ast_mutex_lock(&p->lock);
      owner = agent_lock_owner(p);

      /* 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 (p->chan) {
         loginChan = ast_strdupa(ast_channel_name(p->chan));
         if (owner && owner->_bridge) {
            talkingto = S_COR(p->chan->caller.id.number.valid,
               p->chan->caller.id.number.str, "n/a");
            if ((bridge = ast_bridged_channel(owner))) {
               talkingtoChan = ast_strdupa(ast_channel_name(bridge));
            } 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";
      }

      if (owner) {
         ast_channel_unlock(owner);
         owner = ast_channel_unref(owner);
      }

      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 421 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_flag, agent_pvt::app_sleep_cond, args, AST_APP_ARG, ast_calloc, ast_cond_init, ast_copy_string(), AST_DECLARE_APP_ARGS, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_mutex_init, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_tvnow(), agent_pvt::autologoff, agent_pvt::dead, agent_pvt::enddtmf, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, LOG_WARNING, agent_pvt::login_wait_cond, 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_cond_init(&p->app_complete_cond, NULL);
      ast_cond_init(&p->login_wait_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 1038 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, ast_frame_subclass::integer, 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.integer;
      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 548 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 1079 of file chan_agent.c.

References ast_channel::_bridge, ast_channel_name(), ast_debug, agent_pvt::chan, 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", ast_channel_name(chan), ast_channel_name(bridge), ret ? ast_channel_name(ret) : "<none>");
   return ret;
}

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

Definition at line 819 of file chan_agent.c.

References agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_start_monitoring(), ast_channel_language(), ast_channel_name(), ast_debug, AST_DEVICE_UNAVAILABLE, ast_devstate_changed(), ast_getformatname(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_set_read_format_from_cap(), ast_set_write_format_from_cap(), ast_setstate(), AST_STATE_DIALING, AST_STATE_RINGING, AST_STATE_UP, ast_streamfile(), ast_verb, ast_waitstream(), agent_pvt::chan, CLEANUP, agent_pvt::lock, LOG_DEBUG, LOG_WARNING, ast_channel::nativeformats, agent_pvt::pending, and ast_channel::tech_pvt.

{
   struct agent_pvt *p = ast->tech_pvt;
   int res = -1;
   int newstate=0;
   struct ast_channel *chan;

   ast_mutex_lock(&p->lock);
   p->acknowledged = 0;

   if (p->pending) {
      ast_log(LOG_DEBUG, "Pretending to dial on pending agent\n");
      ast_mutex_unlock(&p->lock);
      ast_setstate(ast, AST_STATE_DIALING);
      return 0;
   }

   if (!p->chan) {
      ast_log(LOG_DEBUG, "Agent disconnected while we were connecting the call\n");
      ast_mutex_unlock(&p->lock);
      return res;
   }
   ast_verb(3, "agent_call, call to agent '%s' call on '%s'\n", p->agent, ast_channel_name(p->chan));
   ast_debug(3, "Playing beep, lang '%s'\n", ast_channel_language(p->chan));
   
   chan = p->chan;
   ast_mutex_unlock(&p->lock);

   res = ast_streamfile(chan, beep, ast_channel_language(chan));
   ast_debug(3, "Played beep, result '%d'\n", res);
   if (!res) {
      res = ast_waitstream(chan, "");
      ast_debug(3, "Waited for stream, result '%d'\n", res);
   }
   
   ast_mutex_lock(&p->lock);
   if (!p->chan) {
      /* chan went away while we were streaming, this shouldn't be possible */
      res = -1;
   }

   if (!res) {
      struct ast_format tmpfmt;
      res = ast_set_read_format_from_cap(p->chan, 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(&tmpfmt));
   } else {
      /* Agent hung-up */
      p->chan = NULL;
      ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent);
   }

   if (!res) {
      struct ast_format tmpfmt;
      res = ast_set_write_format_from_cap(p->chan, 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(&tmpfmt));
   }
   if(!res) {
      /* Call is immediately up, or might need ack */
      if (p->ackcall) {
         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 522 of file chan_agent.c.

References agent_pvt::app_complete_cond, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, ast_channel_release(), ast_cond_destroy, ast_cond_signal, ast_free, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, agent_pvt::chan, agent_pvt::dead, agent_pvt::lock, agent_pvt::login_wait_cond, agent_pvt::owner, and ast_channel::tech_pvt.

Referenced by check_availability().

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

static int agent_cont_sleep

(

void *

data

)

[static]

Definition at line 1017 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

(

const char *

data

)

[static]

Part of PBX channel interface.

Definition at line 2322 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, agent_pvt::chan, agent_pvt::group, agent_pvt::lock, agent_pvt::owner, and agent_pvt::pending.

{
   struct agent_pvt *p;
   const 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) {
               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 797 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 808 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 759 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 899 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 932 of file chan_agent.c.

References ast_channel::_bridge, ast_channel::_state, agent_pvt::abouttograb, agent_pvt::acknowledged, agent_pvt::agent, agent_pvt::app_complete_cond, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, ast_channel_lock, ast_channel_ref, ast_channel_unlock, ast_channel_unref, ast_cond_destroy, ast_cond_signal, AST_CONTROL_HOLD, ast_debug, AST_DEVICE_NOT_INUSE, ast_devstate_changed(), ast_free, ast_indicate_data(), AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, ast_samp2tv(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_state2str(), AST_STATE_UP, ast_strdupa, ast_strlen_zero(), ast_tvadd(), ast_tvnow(), agent_pvt::chan, agent_pvt::dead, agent_pvt::lastdisc, agent_pvt::lock, agent_pvt::login_wait_cond, agent_pvt::logincallerid, agent_pvt::loginstart, agent_pvt::moh, agent_pvt::owner, agent_pvt::pending, S_OR, agent_pvt::start, ast_channel::tech_pvt, and agent_pvt::wrapuptime.

Referenced by agent_request().

{
   struct agent_pvt *p = ast->tech_pvt;
   struct ast_channel *indicate_chan = NULL;
   char *tmp_moh; /* moh buffer for indicating after unlocking p */

   if (p->pending) {
      AST_LIST_LOCK(&agents);
      AST_LIST_REMOVE(&agents, p, list);
      AST_LIST_UNLOCK(&agents);
   }

   ast_mutex_lock(&p->lock);
   p->owner = NULL;
   ast->tech_pvt = NULL;
   p->app_sleep_cond = 1;
   p->acknowledged = 0;

   /* 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 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)) {
      p->start = 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 (p->dead) {
         ast_channel_lock(p->chan);
         ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
         ast_channel_unlock(p->chan);
      } else if (p->loginstart) {
         indicate_chan = ast_channel_ref(p->chan);
         tmp_moh = ast_strdupa(p->moh);
      }
   }
   ast_mutex_unlock(&p->lock);

   if (indicate_chan) {
      ast_channel_lock(indicate_chan);
      ast_indicate_data(indicate_chan, AST_CONTROL_HOLD,
         S_OR(tmp_moh, NULL),
         !ast_strlen_zero(tmp_moh) ? strlen(tmp_moh) + 1 : 0);
      ast_channel_unlock(indicate_chan);
      indicate_chan = ast_channel_unref(indicate_chan);
   }

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

   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_cond_destroy(&p->app_complete_cond);
      ast_cond_destroy(&p->login_wait_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);
      }
   }
   return 0;
}

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

Definition at line 773 of file chan_agent.c.

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

{
   struct agent_pvt *p = ast->tech_pvt;
   int res = -1;
   ast_mutex_lock(&p->lock);
   if (p->chan && !ast_check_hangup(p->chan)) {
      while (ast_channel_trylock(p->chan)) {
         int res;
         if ((res = ast_channel_unlock(ast))) {
            ast_log(LOG_ERROR, "chan_agent bug! Channel was not locked upon entry to agent_indicate: %s\n", strerror(res));
            ast_mutex_unlock(&p->lock);
            return -1;
         }
         usleep(1);
         ast_channel_lock(ast);
      }
      res = p->chan->tech->indicate ? p->chan->tech->indicate(p->chan, condition, data, datalen) : -1;
      ast_channel_unlock(p->chan);
   } else
      res = 0;
   ast_mutex_unlock(&p->lock);
   return res;
}

static struct ast_channel* agent_lock_owner

(

struct agent_pvt *

pvt

)

[static, read]

Locks the owning channel for a LOCKED pvt while obeying locking order. The pvt must enter this function locked and will be returned locked, but this function will unlock the pvt for a short time, so it can't be used while expecting the pvt to remain static. If function returns a non NULL channel, it will need to be unlocked and unrefed once it is no longer needed.

Parameters:

pvt

Pointer to the LOCKED agent_pvt for which the owner is needed locked channel which owns the pvt at the time of completion. NULL if not available.

Definition at line 386 of file chan_agent.c.

References ast_channel_lock, ast_channel_ref, ast_channel_unlock, ast_channel_unref, ast_mutex_lock, ast_mutex_unlock, agent_pvt::lock, and agent_pvt::owner.

Referenced by action_agents(), agent_logoff(), agent_read(), agents_data_provider_get(), agents_show(), and agents_show_online().

{
   struct ast_channel *owner;

   for (;;) {
      if (!pvt->owner) { /* No owner. Nothing to do. */
         return NULL;
      }

      /* If we don't ref the owner, it could be killed when we unlock the pvt. */
      owner = ast_channel_ref(pvt->owner);

      /* Locking order requires us to lock channel, then pvt. */
      ast_mutex_unlock(&pvt->lock);
      ast_channel_lock(owner);
      ast_mutex_lock(&pvt->lock);

      /* Check if owner changed during pvt unlock period */
      if (owner != pvt->owner) { /* Channel changed. Unref and do another pass. */
         ast_channel_unlock(owner);
         owner = ast_channel_unref(owner);
      } else { /* Channel stayed the same. Return it. */
         return owner;
      }
   }
}

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

Definition at line 1635 of file chan_agent.c.

References agent_pvt::agent, agent_lock_owner(), ast_channel_trylock, ast_channel_unlock, ast_channel_unref, 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, and agent_pvt::owner.

Referenced by action_agent_logoff(), and agent_logoff_cmd().

{
   struct agent_pvt *p;
   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) {
               struct ast_channel *owner;
               ast_mutex_lock(&p->lock);
               owner = agent_lock_owner(p);

               if (owner) {
                  ast_softhangup(owner, AST_SOFTHANGUP_EXPLICIT);
                  ast_channel_unlock(owner);
                  owner = ast_channel_unref(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;
         }
         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 1676 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;
   const 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 struct ast_channel* agent_new	(	struct agent_pvt *	p,
		int	state,
		const char *	linkedid
	)			[static, read]

Create new agent channel.

Definition at line 1096 of file chan_agent.c.

References agent_pvt::agent, agent_tech, ast_channel_alloc, ast_channel_language(), ast_copy_string(), ast_format_cap_add(), ast_format_cap_copy(), ast_format_copy(), ast_format_set(), AST_FORMAT_SLINEAR, ast_log(), ast_random(), agent_pvt::chan, ast_channel::context, ast_channel::exten, LOG_WARNING, 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;
#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:"", linkedid, 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:"", linkedid, 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) {
      ast_format_cap_copy(tmp->nativeformats, p->chan->nativeformats);
      ast_format_copy(&tmp->writeformat, &p->chan->writeformat);
      ast_format_copy(&tmp->rawwriteformat, &p->chan->writeformat);
      ast_format_copy(&tmp->readformat, &p->chan->readformat);
      ast_format_copy(&tmp->rawreadformat, &p->chan->readformat);
      ast_channel_language_set(tmp, ast_channel_language(p->chan));
      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 {
      ast_format_set(&tmp->writeformat, AST_FORMAT_SLINEAR, 0);
      ast_format_set(&tmp->rawwriteformat, AST_FORMAT_SLINEAR, 0);
      ast_format_set(&tmp->readformat, AST_FORMAT_SLINEAR, 0);
      ast_format_set(&tmp->rawreadformat, AST_FORMAT_SLINEAR, 0);
      ast_format_cap_add(tmp->nativeformats, &tmp->writeformat);
   }
   /* Safe, agentlock already held */
   tmp->tech_pvt = p;
   p->owner = tmp;
   tmp->priority = 1;
   return tmp;
}

static struct ast_frame * agent_read

(

struct ast_channel *

ast

)

[static, read]

Definition at line 587 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_lock_owner(), agent_start_monitoring(), AST_AGENT_FD, ast_channel_name(), ast_channel_trylock, ast_channel_unlock, ast_channel_unref, 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_log(), ast_mutex_lock, ast_mutex_unlock, ast_null_frame, ast_read(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, AST_STATE_UP, AST_TIMING_FD, ast_verb, agent_pvt::autologoff, agent_pvt::chan, CHECK_FORMATS, CLEANUP, DEADLOCK_AVOIDANCE, agent_pvt::enddtmf, f, ast_channel::fdno, ast_frame::frametype, ast_frame_subclass::integer, agent_pvt::lock, LOG_NOTICE, agent_pvt::name, agent_pvt::owner, agent_pvt::start, ast_frame::subclass, ast_channel::tech, ast_channel::tech_pvt, and ast_channel_tech::type.

{
   struct agent_pvt *p = ast->tech_pvt;
   struct ast_frame *f = NULL;
   static struct ast_frame answer_frame = { AST_FRAME_CONTROL, { AST_CONTROL_ANSWER } };
   int cur_time = time(NULL);
   struct ast_channel *owner;

   ast_mutex_lock(&p->lock);
   owner = agent_lock_owner(p);

   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, make it NULL */
      if (p->chan) {
         p->chan->_bridge = NULL;
         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);
            if (owner || p->chan) {
               if (owner) {
                  ast_softhangup(owner, AST_SOFTHANGUP_EXPLICIT);
                  ast_channel_unlock(owner);
                  owner = ast_channel_unref(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);
               }
            }
         }
      }
      switch (f->frametype) {
      case AST_FRAME_CONTROL:
         if (f->subclass.integer == AST_CONTROL_ANSWER) {
            if (p->ackcall) {
               ast_verb(3, "%s answered, waiting for '%c' to acknowledge\n", ast_channel_name(p->chan), 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.integer == p->acceptdtmf) || (f->subclass.integer == p->enddtmf && endcall)){
            ast_frfree(f);
            f = &ast_null_frame;
         }
         break;
      case AST_FRAME_DTMF_END:
         if (!p->acknowledged && (f->subclass.integer == p->acceptdtmf)) {
            ast_verb(3, "%s acknowledged\n", ast_channel_name(p->chan));
            p->acknowledged = 1;
            ast_frfree(f);
            f = &answer_frame;
         } else if (f->subclass.integer == 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;
      }
   }

   if (owner) {
      ast_channel_unlock(owner);
      owner = ast_channel_unref(owner);
   }

   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", ast_channel_name(p->chan), ast_channel_name(p->chan->_bridge));
      }
   }
   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,
		struct ast_format_cap *	cap,
		const struct ast_channel *	requestor,
		const char *	data,
		int *	cause
	)			[static, read]

Part of the Asterisk PBX interface.

Definition at line 1409 of file chan_agent.c.

References add_agent(), agent_pvt::agent, agent_hangup(), agent_new(), agent_pvt::app_complete_cond, agent_pvt::app_lock_flag, agent_pvt::app_sleep_cond, AST_CAUSE_BUSY, AST_CAUSE_UNREGISTERED, ast_channel_linkedid(), ast_cond_signal, ast_cond_wait, AST_CONTROL_UNHOLD, ast_debug, ast_indicate(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_null_frame, ast_queue_frame(), AST_STATE_DOWN, ast_tv(), ast_tvnow(), agent_pvt::chan, agent_pvt::group, agent_pvt::lastdisc, agent_pvt::lock, LOG_DEBUG, LOG_WARNING, agent_pvt::login_wait_cond, agent_pvt::owner, and agent_pvt::pending.

{
   struct agent_pvt *p;
   struct ast_channel *chan = NULL;
   const 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))) {
         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, requestor ? ast_channel_linkedid(requestor) : NULL);
            }
            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) {
               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) {
                  /* Could still get a fixed agent */
                  chan = agent_new(p, AST_STATE_DOWN, requestor ? ast_channel_linkedid(requestor) : NULL);
               }
               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, requestor ? ast_channel_linkedid(requestor) : NULL);
         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);

   if (chan) {
      ast_mutex_lock(&p->lock);
      if (p->pending) {
         ast_mutex_unlock(&p->lock);
         return chan;
      }

      if (!p->chan) {
         ast_log(LOG_DEBUG, "Agent disconnected while we were connecting the call\n");
         *cause = AST_CAUSE_UNREGISTERED;
         ast_mutex_unlock(&p->lock);
         agent_hangup(chan);
         return NULL;
      }

      /* we need to take control of the channel from the login app
       * thread */
      p->app_sleep_cond = 0;
      p->app_lock_flag = 1;

      ast_queue_frame(p->chan, &ast_null_frame);
      ast_cond_wait(&p->login_wait_cond, &p->lock);

      if (!p->chan) {
         ast_log(LOG_DEBUG, "Agent disconnected while we were connecting the call\n");
         p->app_sleep_cond = 1;
         p->app_lock_flag = 0;
         ast_cond_signal(&p->app_complete_cond);
         ast_mutex_unlock(&p->lock);
         *cause = AST_CAUSE_UNREGISTERED;
         agent_hangup(chan);
         return NULL;
      }

      ast_indicate(p->chan, AST_CONTROL_UNHOLD);
      ast_mutex_unlock(&p->lock);
   }

   return chan;
}

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

Definition at line 712 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 723 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 915 of file chan_agent.c.

References ast_channel_name(), ast_log(), agent_pvt::chan, LOG_ERROR, 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", ast_channel_name(chan));
      return -1;
   }
   p->chan = base;
   return 0;
}

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

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

References ast_channel_name(), ast_debug, ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_mutex_lock, ast_mutex_unlock, ast_write(), agent_pvt::chan, CHECK_FORMATS, CLEANUP, ast_frame_subclass::format, ast_frame::frametype, agent_pvt::lock, 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) ||
          (ast_format_cmp(&f->subclass.format, &p->chan->writeformat) != AST_FORMAT_CMP_NOT_EQUAL)) {
         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_channel_name(ast), ast_channel_name(p->chan));
         res = 0;
      }
   }
   CLEANUP(ast, p);
   ast_mutex_unlock(&p->lock);
   return res;
}

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

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

Parameters:

	chan
	data

Returns:

See also:

login_exec(), load_module().

Definition at line 2269 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_strlen_zero(), ast_channel::caller, ast_channel::cdr, ast_cdr::channel, GETAGENTBYCALLERID, ast_party_caller::id, LOG_WARNING, ast_party_id::number, pbx_builtin_getvar_helper(), ast_party_number::str, and ast_party_number::valid.

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->caller.id.number.valid
      && !ast_strlen_zero(chan->caller.id.number.str)) {
      const char *tmp;
      char agentvar[AST_MAX_BUF];
      snprintf(agentvar, sizeof(agentvar), "%s_%s", GETAGENTBYCALLERID,
         chan->caller.id.number.str);
      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 int agents_data_provider_get	(	const struct ast_data_search *	search,
		struct ast_data *	data_root
	)			[static]

Definition at line 2460 of file chan_agent.c.

References agent_pvt::agent, agent_lock_owner(), ast_bridged_channel(), ast_channel_data_add_structure(), ast_channel_unlock, ast_channel_unref, ast_data_add_bool(), ast_data_add_node(), ast_data_add_str(), ast_data_add_structure, ast_data_remove_node(), ast_data_search_match(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, agent_pvt::chan, agent_pvt::lock, agent_pvt::moh, agent_pvt::owner, and agent_pvt::pending.

{
   struct agent_pvt *p;
   struct ast_data *data_agent, *data_channel, *data_talkingto;

   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      struct ast_channel *owner;

      data_agent = ast_data_add_node(data_root, "agent");
      if (!data_agent) {
         continue;
      }

      ast_mutex_lock(&p->lock);
      owner = agent_lock_owner(p);

      if (!(p->pending)) {
         ast_data_add_str(data_agent, "id", p->agent);
         ast_data_add_structure(agent_pvt, data_agent, p);

         ast_data_add_bool(data_agent, "logged", p->chan ? 1 : 0);
         if (p->chan) {
            data_channel = ast_data_add_node(data_agent, "loggedon");
            if (!data_channel) {
               ast_mutex_unlock(&p->lock);
               ast_data_remove_node(data_root, data_agent);
               if (owner) {
                  ast_channel_unlock(owner);
                  owner = ast_channel_unref(owner);
               }
               continue;
            }
            ast_channel_data_add_structure(data_channel, p->chan, 0);
            if (owner && ast_bridged_channel(owner)) {
               data_talkingto = ast_data_add_node(data_agent, "talkingto");
               if (!data_talkingto) {
                  ast_mutex_unlock(&p->lock);
                  ast_data_remove_node(data_root, data_agent);
                  if (owner) {
                     ast_channel_unlock(owner);
                     owner = ast_channel_unref(owner);
                  }
                  continue;
               }
               ast_channel_data_add_structure(data_talkingto, ast_bridged_channel(owner), 0);
            }
         } else {
            ast_data_add_node(data_agent, "talkingto");
            ast_data_add_node(data_agent, "loggedon");
         }
         ast_data_add_str(data_agent, "musiconhold", p->moh);
      }

      if (owner) {
         ast_channel_unlock(owner);
         owner = ast_channel_unref(owner);
      }

      ast_mutex_unlock(&p->lock);

      /* if this agent doesn't match remove the added agent. */
      if (!ast_data_search_match(search, data_agent)) {
         ast_data_remove_node(data_root, data_agent);
      }
   }
   AST_LIST_UNLOCK(&agents);

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

References agent_pvt::agent, agent_lock_owner(), ast_cli_args::argc, ast_bridged_channel(), ast_channel_name(), ast_channel_unlock, ast_channel_unref, 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, count_agents(), ast_cli_args::fd, agent_pvt::group, agent_pvt::lock, agent_pvt::moh, 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) {
      struct ast_channel *owner;
      ast_mutex_lock(&p->lock);
      owner = agent_lock_owner(p);
      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", ast_channel_name(p->chan));
            if (owner && ast_bridged_channel(owner)) {
               snprintf(talkingto, sizeof(talkingto), " talking to %s", ast_channel_name(ast_bridged_channel(p->owner)));
            } else {
               strcpy(talkingto, " is idle");
            }
            online_agents++;
         } 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++;
      }

      if (owner) {
         ast_channel_unlock(owner);
         owner = ast_channel_unref(owner);
      }
      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 1840 of file chan_agent.c.

References agent_pvt::agent, agent_lock_owner(), ast_cli_args::argc, ast_bridged_channel(), ast_channel_name(), ast_channel_unlock, ast_channel_unref, 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, count_agents(), ast_cli_args::fd, agent_pvt::lock, agent_pvt::moh, 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) {
      struct ast_channel *owner;

      agent_status = 0;       /* reset it to offline */
      ast_mutex_lock(&p->lock);
      owner = agent_lock_owner(p);

      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", ast_channel_name(p->chan));
         if (p->owner && ast_bridged_channel(p->owner)) {
            snprintf(talkingto, sizeof(talkingto), " talking to %s", ast_channel_name(ast_bridged_channel(p->owner)));
         } else {
            strcpy(talkingto, " is idle");
         }
         agent_status = 1;
         online_agents++;
      }

      if (owner) {
         ast_channel_unlock(owner);
         owner = ast_channel_unref(owner);
      }

      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;
}

AST_DATA_STRUCTURE	(	agent_pvt	,
		DATA_EXPORT_AGENT
	)

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

Definition at line 1309 of file chan_agent.c.

References agent_pvt::abouttograb, agent_pvt::ackcall, agent_pvt::acknowledged, agent_pvt::agent, agent_cleanup(), agent_new(), ast_channel_language(), ast_channel_linkedid(), ast_channel_masquerade(), ast_channel_name(), ast_copy_string(), ast_debug, ast_hangup(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, ast_setstate(), AST_STATE_DOWN, AST_STATE_UP, ast_streamfile(), ast_waitstream(), agent_pvt::chan, ast_channel::context, agent_pvt::group, agent_pvt::lock, 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", ast_channel_name(p->owner), newlyavailable->agent);
         /* We found a pending call, time to merge */
         chan = agent_new(newlyavailable, AST_STATE_DOWN, p->owner ? ast_channel_linkedid(p->owner) : NULL);
         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) {
         /* Don't do beep here */
         res = 0;
      } else {
         ast_debug(3, "Playing beep, lang '%s'\n", ast_channel_language(newlyavailable->chan));
         res = ast_streamfile(newlyavailable->chan, beep, ast_channel_language(newlyavailable->chan));
         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));
            ast_channel_masquerade(parent, chan);
            ast_hangup(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 1372 of file chan_agent.c.

References agent_pvt::abouttograb, agent_pvt::agent, ast_channel_language(), ast_channel_name(), 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, agent_pvt::lock, 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", ast_channel_name(p->owner), 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", ast_channel_language(newlyavailable->chan));
      res = ast_streamfile(newlyavailable->chan, beep, ast_channel_language(newlyavailable->chan));
      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 1736 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 struct agent_pvt* find_agent

(

char *

agentid

)

[static, read]

Note:

This function expects the agent list to be locked

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

References agent_pvt::agent, args, AST_APP_ARG, ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_copy_string(), AST_DECLARE_APP_ARGS, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), AST_NONSTANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), agent_pvt::chan, find_agent(), LOG_WARNING, agent_pvt::moh, 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) {
         status = "LOGGEDIN";
      }
      ast_copy_string(buf, status, len);
   } else if (!strcasecmp(args.item, "password")) 
      ast_copy_string(buf, agent->password, len);
   else if (!strcasecmp(args.item, "name"))
      ast_copy_string(buf, agent->name, len);
   else if (!strcasecmp(args.item, "mohclass"))
      ast_copy_string(buf, agent->moh, len);
   else if (!strcasecmp(args.item, "channel")) {
      if (agent->chan) {
         ast_channel_lock(agent->chan);
         ast_copy_string(buf, ast_channel_name(agent->chan), len);
         ast_channel_unlock(agent->chan);
         tmp = strrchr(buf, '-');
         if (tmp)
            *tmp = '\0';
      } 
   } else if (!strcasecmp(args.item, "fullchannel")) {
      if (agent->chan) {
         ast_channel_lock(agent->chan);
         ast_copy_string(buf, ast_channel_name(agent->chan), len);
         ast_channel_unlock(agent->chan);
      } 
   } else if (!strcasecmp(args.item, "exten")) {
      buf[0] = '\0';
   }

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

References action_agent_logoff(), action_agents(), agent_function, agent_tech, agentmonitoroutgoing_exec(), agents_data_providers, ARRAY_LEN, ast_channel_register(), ast_cli_register_multiple(), ast_custom_function_register, ast_data_register_multiple, ast_format_cap_add_all(), ast_format_cap_alloc(), ast_log(), ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_register_application_xml, ast_channel_tech::capabilities, cli_agents, EVENT_FLAG_AGENT, LOG_ERROR, login_exec(), and read_agent_config().

{
   if (!(agent_tech.capabilities = ast_format_cap_alloc())) {
      ast_log(LOG_ERROR, "ast_format_cap_alloc_nolock fail.\n");
      return AST_MODULE_LOAD_FAILURE;
   }
   ast_format_cap_add_all(agent_tech.capabilities);
   /* 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;
   /* Dialplan applications */
   ast_register_application_xml(app, login_exec);
   ast_register_application_xml(app3, agentmonitoroutgoing_exec);

   /* data tree */
   ast_data_register_multiple(agents_data_providers, ARRAY_LEN(agents_data_providers));

   /* Manager commands */
   ast_manager_register_xml("Agents", EVENT_FLAG_AGENT, action_agents);
   ast_manager_register_xml("AgentLogoff", EVENT_FLAG_AGENT, action_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,
		const char *	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 1930 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_flag, args, ast_answer(), AST_APP_ARG, ast_app_getdata(), ast_channel_language(), ast_channel_lock, ast_channel_name(), ast_channel_uniqueid(), ast_channel_unlock, ast_cond_destroy, ast_cond_signal, 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_from_cap(), ast_set_write_format_from_cap(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_strdupa, ast_streamfile(), ast_strlen_zero(), ast_true(), ast_tv(), ast_tvdiff_ms(), ast_tvnow(), ast_verb, ast_waitstream(), agent_pvt::autologoff, ast_channel::cdr, agent_pvt::chan, ast_cdr::channel, check_availability(), check_beep(), agent_pvt::dead, agent_pvt::deferlogoff, agent_pvt::enddtmf, EVENT_FLAG_AGENT, agent_pvt::lastdisc, agent_pvt::lock, LOG_NOTICE, LOG_WARNING, agent_pvt::login_wait_cond, agent_pvt::logincallerid, agent_pvt::loginstart, manager_event, agent_pvt::moh, ast_channel::nativeformats, agent_pvt::owner, parse(), pass, agent_pvt::password, pbx_builtin_getvar_helper(), agent_pvt::pending, ast_channel::readformat, S_OR, 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;
   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,ast_channel_name(chan));
   }
   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,ast_channel_name(chan));
   }
   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,ast_channel_name(chan));
   }
   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) {

            /* 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 (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->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, ast_channel_language(chan));
               if (!res)
                  ast_waitstream(chan, "");
               AST_LIST_LOCK(&agents);
               ast_mutex_lock(&p->lock);
               if (!res) {
                  struct ast_format tmpfmt;
                  res = ast_set_read_format_from_cap(chan, chan->nativeformats);
                  if (res) {
                     ast_log(LOG_WARNING, "Unable to set read format to %s\n", ast_getformatname(&tmpfmt));
                  }
               }
               if (!res) {
                  struct ast_format tmpfmt;
                  res = ast_set_write_format_from_cap(chan, chan->nativeformats);
                  if (res) {
                     ast_log(LOG_WARNING, "Unable to set write format to %s\n", ast_getformatname(&tmpfmt));
                  }
               }
               /* 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, ast_channel_name(chan), ast_channel_uniqueid(chan));
                  if (update_cdr && chan->cdr)
                     snprintf(chan->cdr->channel, sizeof(chan->cdr->channel), "Agent/%s", p->agent);
                  ast_queue_log("NONE", ast_channel_uniqueid(chan), agent, "AGENTLOGIN", "%s", ast_channel_name(chan));
                  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) {
                     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) {
                              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->lock);
                     if (p->app_lock_flag == 1) {
                        ast_cond_signal(&p->login_wait_cond);
                        ast_cond_wait(&p->app_complete_cond, &p->lock);
                     }
                     ast_mutex_unlock(&p->lock);
                     if (p->ackcall) {
                        res = agent_ack_sleep(p);
                     } else {
                        res = ast_safe_sleep_conditional( chan, 1000, agent_cont_sleep, p );
                     }
                     if (p->ackcall && (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);
                  /* Log us off if appropriate */
                  if (p->chan == chan) {
                     p->chan = NULL;
                  }

                  /* Synchronize channel ownership between call to agent and itself. */
                  if (p->app_lock_flag == 1) {
                     ast_cond_signal(&p->login_wait_cond);
                     ast_cond_wait(&p->app_complete_cond, &p->lock);
                  }

                  if (res && p->owner)
                     ast_log(LOG_WARNING, "Huh?  We broke out when there was still an owner?\n");

                  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, ast_channel_uniqueid(chan));
                  ast_queue_log("NONE", ast_channel_uniqueid(chan), agent, "AGENTLOGOFF", "%s|%ld", ast_channel_name(chan), 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_cond_destroy(&p->app_complete_cond);
                     ast_cond_destroy(&p->login_wait_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 1535 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 1145 of file chan_agent.c.

References add_agent(), agent_pvt::app_complete_cond, 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, agent_pvt::login_wait_cond, 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 *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 */
   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 (ast_true(v->value) || !strcasecmp(v->value, "always")) {
            ackcall = 1;
         }
      } 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_cond_destroy(&p->app_complete_cond);
               ast_cond_destroy(&p->login_wait_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 2583 of file chan_agent.c.

References read_agent_config().

{
   return read_agent_config(1);
}

static int unload_module

(

void

)

[static]

Definition at line 2588 of file chan_agent.c.

References agent_function, agent_tech, ARRAY_LEN, ast_channel_unregister(), ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_data_unregister, ast_format_cap_destroy(), ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_manager_unregister(), ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, ast_unregister_application(), ast_channel_tech::capabilities, 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 the data tree */
   ast_data_unregister(NULL);
   /* 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);

   agent_tech.capabilities = ast_format_cap_destroy(agent_tech.capabilities);
   return 0;
}

---

Variable Documentation

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .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 = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, .nonoptreq = "res_monitor,chan_local", } [static]

Definition at line 2625 of file chan_agent.c.

char acceptdtmf = DEFAULT_ACCEPTDTMF [static]

Definition at line 228 of file chan_agent.c.

Referenced by play_record_review().

int ackcall [static]

Definition at line 224 of file chan_agent.c.

struct ast_custom_function agent_function [static]

Initial value:

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

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

struct ast_channel_tech agent_tech [static]

Channel interface description for PBX integration.

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

struct ast_data_handler agents_data_provider [static]

Initial value:

 {
   .version = AST_DATA_HANDLER_VERSION,
   .get = agents_data_provider_get
}

Definition at line 2532 of file chan_agent.c.

struct ast_data_entry agents_data_providers[] [static]

Initial value:

 {
   AST_DATA_ENTRY("asterisk/channel/agent/list", &agents_data_provider),
}

Definition at line 2537 of file chan_agent.c.

Referenced by load_module().

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

Definition at line 206 of file chan_agent.c.

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

Definition at line 207 of file chan_agent.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 2625 of file chan_agent.c.

int autologoff [static]

Definition at line 222 of file chan_agent.c.

int autologoffunavail = 0 [static]

Definition at line 227 of file chan_agent.c.

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

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

Referenced by load_module(), and unload_module().

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

Definition at line 204 of file chan_agent.c.

int endcall [static]

Definition at line 225 of file chan_agent.c.

char enddtmf = DEFAULT_ENDDTMF [static]

Definition at line 229 of file chan_agent.c.

ast_group_t group [static]

Definition at line 221 of file chan_agent.c.

int maxlogintries = 3 [static]

Definition at line 231 of file chan_agent.c.

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

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

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

Persistent Agents astdb family

Definition at line 215 of file chan_agent.c.

int recordagentcalls = 0 [static]

Definition at line 234 of file chan_agent.c.

char recordformat[AST_MAX_BUF] = "" [static]

Definition at line 235 of file chan_agent.c.

char recordformatext[AST_MAX_BUF] = "" [static]

Definition at line 236 of file chan_agent.c.

char savecallsin[AST_MAX_BUF] = "" [static]

Definition at line 238 of file chan_agent.c.

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

Definition at line 203 of file chan_agent.c.

int updatecdr = 0 [static]

Definition at line 239 of file chan_agent.c.

char urlprefix[AST_MAX_BUF] = "" [static]

Definition at line 237 of file chan_agent.c.

Referenced by start_monitor_exec().

int wrapuptime [static]

Definition at line 223 of file chan_agent.c.