Thu Apr 28 2011 17:15:37

Asterisk developer's documentation


chan_agent.c File Reference

Implementation of Agents (proxy channel) More...

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

Go to the source code of this file.

Data Structures

struct  agent_pvt
 Structure representing an agent. More...
struct  agents

Defines

#define AST_MAX_AGENT   80
#define AST_MAX_BUF   256
#define AST_MAX_FILENAME_LEN   256
#define CHECK_FORMATS(ast, p)
#define CLEANUP(ast, p)
 Cleanup moves all the relevant FD's from the 2nd to the first, but retains things properly for a timingfd XXX This might need more work if agents were logged in as agents or other totally impractical combinations XXX.
#define DEFAULT_ACCEPTDTMF   '#'
#define DEFAULT_ENDDTMF   '*'
#define GETAGENTBYCALLERID   "AGENTBYCALLERID"
#define PA_MAX_LEN   2048

Enumerations

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

Functions

static int __agent_start_monitoring (struct ast_channel *ast, struct agent_pvt *p, int needlock)
static void __reg_module (void)
static void __unreg_module (void)
static int action_agent_logoff (struct mansession *s, const struct message *m)
static int action_agents (struct mansession *s, const struct message *m)
static struct agent_pvtadd_agent (const char *agent, int pending)
static int agent_ack_sleep (void *data)
static int agent_answer (struct ast_channel *ast)
static struct ast_channelagent_bridgedchannel (struct ast_channel *chan, struct ast_channel *bridge)
static int agent_call (struct ast_channel *ast, char *dest, int timeout)
static int agent_cleanup (struct agent_pvt *p)
static int agent_cont_sleep (void *data)
static int agent_devicestate (void *data)
 Part of PBX channel interface.
static int agent_digit_begin (struct ast_channel *ast, char digit)
static int agent_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
static int agent_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
static struct ast_channelagent_get_base_channel (struct ast_channel *chan)
 return the channel or base channel if one exists. This function assumes the channel it is called on is already locked
static int agent_hangup (struct ast_channel *ast)
static int agent_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen)
static int agent_logoff (const char *agent, int soft)
static char * agent_logoff_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void agent_logoff_maintenance (struct agent_pvt *p, char *loginchan, long logintime, const char *uniqueid, char *logcommand)
static struct ast_channelagent_new (struct agent_pvt *p, int state)
 Create new agent channel.
static struct ast_frameagent_read (struct ast_channel *ast)
static struct ast_channelagent_request (const char *type, int format, void *data, int *cause)
 Part of the Asterisk PBX interface.
static int agent_sendhtml (struct ast_channel *ast, int subclass, const char *data, int datalen)
static int agent_sendtext (struct ast_channel *ast, const char *text)
static int agent_set_base_channel (struct ast_channel *chan, struct ast_channel *base)
static int agent_start_monitoring (struct ast_channel *ast, int needlock)
static int agent_write (struct ast_channel *ast, struct ast_frame *f)
static int agentmonitoroutgoing_exec (struct ast_channel *chan, void *data)
 Called by the AgentMonitorOutgoing application (from the dial plan).
static char * agents_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * agents_show_online (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int check_availability (struct agent_pvt *newlyavailable, int needlock)
static int check_beep (struct agent_pvt *newlyavailable, int needlock)
static char * complete_agent_logoff_cmd (const char *line, const char *word, int pos, int state)
static void dump_agents (void)
 Dump AgentCallbackLogin agents to the ASTdb database for persistence.
static struct agent_pvtfind_agent (char *agentid)
static int function_agent (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int load_module (void)
 Initialize the Agents module. This function is being called by Asterisk when loading the module. Among other things it registers applications, cli commands and reads the cofiguration file.
static int login_exec (struct ast_channel *chan, void *data)
 Log in agent application.
static force_inline int powerof (unsigned int d)
static int read_agent_config (int reload)
static int reload (void)
static void reload_agents (void)
 Reload the persistent agents from astdb.
static void set_agentbycallerid (const char *callerid, const char *agent)
 store/clear the global variable that stores agentid based on the callerid
static int unload_module (void)

Variables

static struct ast_module_info
__MODULE_INFO_SECTION 
__mod_info = { __MODULE_INFO_GLOBALS .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Agent Proxy Channel" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .reload = reload, }
static char acceptdtmf = DEFAULT_ACCEPTDTMF
static int ackcall
struct ast_custom_function agent_function
static const char agent_logoff_usage [] = " If 'soft' is specified, do not hangup existing calls.\n"
static struct ast_channel_tech agent_tech
 Channel interface description for PBX integration.
static char agentgoodbye [AST_MAX_FILENAME_LEN] = "vm-goodbye"
static struct agents agents
static const char app [] = "AgentLogin"
static const char app3 [] = "AgentMonitorOutgoing"
static struct ast_module_infoast_module_info = &__mod_info
static int autologoff
static int autologoffunavail = 0
static char beep [AST_MAX_BUF] = "beep"
static struct ast_cli_entry cli_agents []
static const char config [] = "agents.conf"
static int endcall
static char enddtmf = DEFAULT_ENDDTMF
static ast_group_t group
static const char mandescr_agent_logoff [] = " Soft: Set to 'true' to not hangup existing calls\n"
static const char mandescr_agents [] = "Variables: NONE\n"
static int maxlogintries = 3
static char moh [80] = "default"
static int multiplelogin = 1
static const char pa_family [] = "Agents"
static int persistent_agents = 0
static int recordagentcalls = 0
static char recordformat [AST_MAX_BUF] = ""
static char recordformatext [AST_MAX_BUF] = ""
static char savecallsin [AST_MAX_BUF] = ""
static const char tdesc [] = "Call Agent Proxy Channel"
static int updatecdr = 0
static char urlprefix [AST_MAX_BUF] = ""
static int wrapuptime

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

Definition in file chan_agent.c.


Define Documentation

#define AST_MAX_AGENT   80

Agent ID or Password max length

Definition at line 191 of file chan_agent.c.

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

#define AST_MAX_BUF   256
#define AST_MAX_FILENAME_LEN   256

Definition at line 193 of file chan_agent.c.

Referenced by login_exec().

#define CHECK_FORMATS (   ast,
 
)

Definition at line 270 of file chan_agent.c.

Referenced by agent_read(), and agent_write().

#define CLEANUP (   ast,
 
)

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

Definition at line 291 of file chan_agent.c.

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

#define DEFAULT_ACCEPTDTMF   '#'

Definition at line 201 of file chan_agent.c.

#define DEFAULT_ENDDTMF   '*'

Definition at line 202 of file chan_agent.c.

#define GETAGENTBYCALLERID   "AGENTBYCALLERID"

Definition at line 225 of file chan_agent.c.

Referenced by agentmonitoroutgoing_exec(), and set_agentbycallerid().

#define PA_MAX_LEN   2048

The maximum length of each persistent member agent database entry

Definition at line 196 of file chan_agent.c.


Enumeration Type Documentation

anonymous enum
Enumerator:
AGENT_FLAG_ACKCALL 
AGENT_FLAG_AUTOLOGOFF 
AGENT_FLAG_WRAPUPTIME 
AGENT_FLAG_ACCEPTDTMF 
AGENT_FLAG_ENDDTMF 

Definition at line 227 of file chan_agent.c.

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

Function Documentation

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

Definition at line 486 of file chan_agent.c.

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

Referenced by agent_start_monitoring(), and agentmonitoroutgoing_exec().

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

Definition at line 2643 of file chan_agent.c.

static void __unreg_module ( void  ) [static]

Definition at line 2643 of file chan_agent.c.

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

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

Parameters:
s
m
Returns:
See also:
action_agents(), load_module().

Definition at line 1773 of file chan_agent.c.

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

Referenced by load_module().

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

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

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

   return 0;
}
static int action_agents ( struct mansession s,
const struct message m 
) [static]

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

Parameters:
s
m
Returns:
See also:
action_agent_logoff(), load_module().

Definition at line 1570 of file chan_agent.c.

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

Referenced by load_module().

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

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

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

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

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

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

      astman_append(s, "Event: Agents\r\n"
         "Agent: %s\r\n"
         "Name: %s\r\n"
         "Status: %s\r\n"
         "LoggedInChan: %s\r\n"
         "LoggedInTime: %d\r\n"
         "TalkingTo: %s\r\n"
         "TalkingToChan: %s\r\n"
         "%s"
         "\r\n",
         p->agent, username, status, loginChan, (int)p->loginstart, talkingto, talkingtoChan, idText);
      ast_mutex_unlock(&p->lock);
   }
   AST_LIST_UNLOCK(&agents);
   astman_append(s, "Event: AgentsComplete\r\n"
      "%s"
      "\r\n",idText);
   return 0;
}
static struct agent_pvt* add_agent ( const char *  agent,
int  pending 
) [static, read]

Adds an agent to the global list of agents.

Parameters:
agentA string with the username, password and real name of an agent. As defined in agents.conf. Example: "13,169,John Smith"
pendingIf it is pending or not.
Returns:
The just created agent.
See also:
agent_pvt, agents.

Definition at line 357 of file chan_agent.c.

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

Referenced by agent_request(), and read_agent_config().

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

   parse = ast_strdupa(agent);

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

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

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

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

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

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

   if (pending)
      p->dead = 1;
   else
      p->dead = 0;
   return p;
}
static int agent_ack_sleep ( void *  data) [static]

Definition at line 1033 of file chan_agent.c.

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

Referenced by login_exec().

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

   /* Wait a second and look for something */

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

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

Definition at line 480 of file chan_agent.c.

References ast_log(), and LOG_WARNING.

{
   ast_log(LOG_WARNING, "Huh?  Agent is being asked to answer?\n");
   return -1;
}
static struct ast_channel * agent_bridgedchannel ( struct ast_channel chan,
struct ast_channel bridge 
) [static, read]

Definition at line 1074 of file chan_agent.c.

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

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

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

   ast_debug(1, "Asked for bridged channel on '%s'/'%s', returning '%s'\n", chan->name, bridge->name, ret ? ret->name : "<none>");
   return ret;
}
static int agent_call ( struct ast_channel ast,
char *  dest,
int  timeout 
) [static]

Definition at line 775 of file chan_agent.c.

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

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

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

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

Parameters:
pAgent to be deleted.
Returns:
Always 0.

Definition at line 458 of file chan_agent.c.

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

Referenced by check_availability().

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

Definition at line 1012 of file chan_agent.c.

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

Referenced by login_exec().

{
   struct agent_pvt *p;
   int res;

   p = (struct agent_pvt *)data;

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

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

   return res;
}
static int agent_devicestate ( void *  data) [static]

Part of PBX channel interface.

Definition at line 2443 of file chan_agent.c.

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

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

   /* Check actual logged in agents first */
   AST_LIST_LOCK(&agents);
   AST_LIST_TRAVERSE(&agents, p, list) {
      ast_mutex_lock(&p->lock);
      if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent))) {
         if (p->owner) {
            if (res != AST_DEVICE_INUSE)
               res = AST_DEVICE_BUSY;
         } else {
            if (res == AST_DEVICE_BUSY)
               res = AST_DEVICE_INUSE;
            if (p->chan || !ast_strlen_zero(p->loginchan)) {
               if (res == AST_DEVICE_INVALID)
                  res = AST_DEVICE_UNKNOWN;
            } else if (res == AST_DEVICE_INVALID)  
               res = AST_DEVICE_UNAVAILABLE;
         }
         if (!strcmp(data, p->agent)) {
            ast_mutex_unlock(&p->lock);
            break;
         }
      }
      ast_mutex_unlock(&p->lock);
   }
   AST_LIST_UNLOCK(&agents);
   return res;
}
static int agent_digit_begin ( struct ast_channel ast,
char  digit 
) [static]
static int agent_digit_end ( struct ast_channel ast,
char  digit,
unsigned int  duration 
) [static]

Definition at line 764 of file chan_agent.c.

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

{
   struct agent_pvt *p = ast->tech_pvt;
   ast_mutex_lock(&p->lock);
   if (p->chan) {
      ast_senddigit_end(p->chan, digit, duration);
   }
   ast_mutex_unlock(&p->lock);
   return 0;
}
static int agent_fixup ( struct ast_channel oldchan,
struct ast_channel newchan 
) [static]

Definition at line 715 of file chan_agent.c.

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

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

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

Definition at line 865 of file chan_agent.c.

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

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

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

Definition at line 898 of file chan_agent.c.

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

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

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

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

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

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

Definition at line 729 of file chan_agent.c.

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

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

Definition at line 1689 of file chan_agent.c.

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

Referenced by action_agent_logoff(), and agent_logoff_cmd().

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

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

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

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

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

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

Definition at line 1735 of file chan_agent.c.

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

{
   int ret;
   char *agent;

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

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

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

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

Definition at line 1650 of file chan_agent.c.

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

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

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

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

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

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

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

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

Create new agent channel.

Definition at line 1091 of file chan_agent.c.

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

Referenced by agent_request(), and check_availability().

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

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

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

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

Definition at line 519 of file chan_agent.c.

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

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

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

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

   CLEANUP(ast,p);
   if (p->chan && !p->chan->_bridge) {
      if (strcasecmp(p->chan->tech->type, "Local")) {
         p->chan->_bridge = ast;
         if (p->chan)
            ast_debug(1, "Bridge on '%s' being set to '%s' (3)\n", p->chan->name, p->chan->_bridge->name);
      }
   }
   ast_mutex_unlock(&p->lock);
   if (recordagentcalls && f == &answer_frame)
      agent_start_monitoring(ast,0);
   return f;
}
static struct ast_channel * agent_request ( const char *  type,
int  format,
void *  data,
int *  cause 
) [static, read]

Part of the Asterisk PBX interface.

Definition at line 1457 of file chan_agent.c.

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

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

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

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

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

Definition at line 668 of file chan_agent.c.

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

{
   struct agent_pvt *p = ast->tech_pvt;
   int res = -1;
   ast_mutex_lock(&p->lock);
   if (p->chan) 
      res = ast_channel_sendhtml(p->chan, subclass, data, datalen);
   ast_mutex_unlock(&p->lock);
   return res;
}
static int agent_sendtext ( struct ast_channel ast,
const char *  text 
) [static]

Definition at line 679 of file chan_agent.c.

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

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

Definition at line 881 of file chan_agent.c.

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

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

Definition at line 514 of file chan_agent.c.

References __agent_start_monitoring(), and ast_channel::tech_pvt.

Referenced by agent_call(), and agent_read().

{
   return __agent_start_monitoring(ast, ast->tech_pvt, needlock);
}
static int agent_write ( struct ast_channel ast,
struct ast_frame f 
) [static]

Definition at line 690 of file chan_agent.c.

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

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

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

Parameters:
chan
data
Returns:
See also:
login_exec(), load_module().

Definition at line 2314 of file chan_agent.c.

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

Referenced by load_module().

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

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

Show agents in cli.

< Number of agents configured

< Number of online agents

< Number of offline agents

Definition at line 1822 of file chan_agent.c.

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

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

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

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

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

Definition at line 1900 of file chan_agent.c.

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

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

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

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

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

Definition at line 1355 of file chan_agent.c.

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

Referenced by login_exec().

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

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

Definition at line 1420 of file chan_agent.c.

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

Referenced by login_exec().

{
   struct agent_pvt *p;
   int res=0;

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

Definition at line 1795 of file chan_agent.c.

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

Referenced by agent_logoff_cmd().

{
   char *ret = NULL;

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

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

Dump AgentCallbackLogin agents to the ASTdb database for persistence.

Definition at line 2367 of file chan_agent.c.

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

Referenced by agent_hangup(), and agent_logoff_maintenance().

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

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

      if (!ast_strlen_zero(cur_agent->loginchan)) {
         snprintf(buf, sizeof(buf), "%s;%s", cur_agent->loginchan, cur_agent->logincallerid);
         if (ast_db_put(pa_family, cur_agent->agent, buf))
            ast_log(LOG_WARNING, "failed to create persistent entry in ASTdb for %s!\n", buf);
         else
            ast_debug(1, "Saved Agent: %s on %s\n", cur_agent->agent, cur_agent->loginchan);
      } else {
         /* Delete -  no agent or there is an error */
         ast_db_del(pa_family, cur_agent->agent);
      }
   }
}
static struct agent_pvt* find_agent ( char *  agentid) [static, read]
Note:
This function expects the agent list to be locked

Definition at line 2490 of file chan_agent.c.

References agent_pvt::agent, and AST_LIST_TRAVERSE.

Referenced by function_agent().

{
   struct agent_pvt *cur;

   AST_LIST_TRAVERSE(&agents, cur, list) {
      if (!strcmp(cur->agent, agentid))
         break;   
   }

   return cur; 
}
static int function_agent ( struct ast_channel chan,
const char *  cmd,
char *  data,
char *  buf,
size_t  len 
) [static]

Definition at line 2502 of file chan_agent.c.

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

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

   buf[0] = '\0';

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

   parse = ast_strdupa(data);

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

   AST_LIST_LOCK(&agents);

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

   if (!strcasecmp(args.item, "status")) {
      char *status = "LOGGEDOUT";
      if (agent->chan || !ast_strlen_zero(agent->loginchan)) 
         status = "LOGGEDIN"; 
      ast_copy_string(buf, status, len);
   } else if (!strcasecmp(args.item, "password")) 
      ast_copy_string(buf, agent->password, len);
   else if (!strcasecmp(args.item, "name"))
      ast_copy_string(buf, agent->name, len);
   else if (!strcasecmp(args.item, "mohclass"))
      ast_copy_string(buf, agent->moh, len);
   else if (!strcasecmp(args.item, "channel")) {
      if (agent->chan) {
         ast_channel_lock(agent->chan);
         ast_copy_string(buf, agent->chan->name, len);
         ast_channel_unlock(agent->chan);
         tmp = strrchr(buf, '-');
         if (tmp)
            *tmp = '\0';
      } 
   } else if (!strcasecmp(args.item, "exten"))
      ast_copy_string(buf, agent->loginchan, len); 

   AST_LIST_UNLOCK(&agents);

   return 0;
}
static int load_module ( void  ) [static]

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

Returns:
int Always 0.

Definition at line 2574 of file chan_agent.c.

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

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

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

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

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

   return AST_MODULE_LOAD_SUCCESS;
}
static int login_exec ( struct ast_channel chan,
void *  data 
) [static]

Log in agent application.

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

Parameters:
chan
data
Returns:
See also:
agentmonitoroutgoing_exec(), load_module().

Definition at line 1986 of file chan_agent.c.

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

Referenced by load_module().

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

   u = ast_module_user_add(chan);

   parse = ast_strdupa(data);

   AST_STANDARD_APP_ARGS(args, parse);

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

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

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

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

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

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

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

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

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

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

   ast_module_user_remove(u);
   
   return -1;
}
static force_inline int powerof ( unsigned int  d) [static]

Definition at line 1552 of file chan_agent.c.

Referenced by agents_show().

{
   int x = ffs(d);

   if (x)
      return x - 1;

   return 0;
}
static int read_agent_config ( int  reload) [static]

Read configuration data. The file named agents.conf.

Returns:
Always 0, or so it seems.

Definition at line 1185 of file chan_agent.c.

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

Referenced by load_module(), and reload().

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

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

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

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

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

Definition at line 2603 of file chan_agent.c.

References read_agent_config(), and reload_agents().

{
   if (!read_agent_config(1)) {
      if (persistent_agents)
         reload_agents();
   }
   return 0;
}
static void reload_agents ( void  ) [static]

Reload the persistent agents from astdb.

Definition at line 2392 of file chan_agent.c.

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

Referenced by load_module(), and reload().

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

   db_tree = ast_db_gettree(pa_family, NULL);

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

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

Definition at line 852 of file chan_agent.c.

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

Referenced by agent_logoff_maintenance(), and reload_agents().

{
   char buf[AST_MAX_BUF];

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

   snprintf(buf, sizeof(buf), "%s_%s", GETAGENTBYCALLERID, callerid);
   pbx_builtin_setvar_helper(NULL, buf, agent);
}
static int unload_module ( void  ) [static]

Definition at line 2612 of file chan_agent.c.

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

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

Variable Documentation

struct ast_module_info __MODULE_INFO_SECTION __mod_info = { __MODULE_INFO_GLOBALS .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Agent Proxy Channel" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .reload = reload, } [static]

Definition at line 2643 of file chan_agent.c.

char acceptdtmf = DEFAULT_ACCEPTDTMF [static]

Definition at line 211 of file chan_agent.c.

Referenced by play_record_review().

int ackcall [static]

Definition at line 207 of file chan_agent.c.

Initial value:
 {
   .name = "AGENT",
   .read = function_agent,
}

Definition at line 2561 of file chan_agent.c.

Referenced by load_module(), and unload_module().

const char agent_logoff_usage[] = " If 'soft' is specified, do not hangup existing calls.\n" [static]

Definition at line 1965 of file chan_agent.c.

struct ast_channel_tech agent_tech [static]

Channel interface description for PBX integration.

Definition at line 325 of file chan_agent.c.

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

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

Definition at line 215 of file chan_agent.c.

struct agents agents [static]

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

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

Definition at line 176 of file chan_agent.c.

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

Definition at line 177 of file chan_agent.c.

Definition at line 2643 of file chan_agent.c.

int autologoff [static]

Definition at line 205 of file chan_agent.c.

int autologoffunavail = 0 [static]

Definition at line 210 of file chan_agent.c.

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

Definition at line 223 of file chan_agent.c.

struct ast_cli_entry cli_agents[] [static]
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 1970 of file chan_agent.c.

Referenced by load_module(), and unload_module().

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

Definition at line 174 of file chan_agent.c.

int endcall [static]

Definition at line 208 of file chan_agent.c.

char enddtmf = DEFAULT_ENDDTMF [static]

Definition at line 212 of file chan_agent.c.

ast_group_t group [static]

Definition at line 204 of file chan_agent.c.

Referenced by ast_get_group(), common_exec(), and handle_cli_check_permissions().

const char mandescr_agent_logoff[] = " Soft: Set to 'true' to not hangup existing calls\n" [static]

Definition at line 183 of file chan_agent.c.

const char mandescr_agents[] = "Variables: NONE\n" [static]

Definition at line 179 of file chan_agent.c.

int maxlogintries = 3 [static]

Definition at line 214 of file chan_agent.c.

Referenced by login_exec().

char moh[80] = "default" [static]
int multiplelogin = 1 [static]

Definition at line 209 of file chan_agent.c.

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

Persistent Agents astdb family

Definition at line 195 of file chan_agent.c.

int persistent_agents = 0 [static]

queues.conf [general] option

Definition at line 198 of file chan_agent.c.

int recordagentcalls = 0 [static]

Definition at line 217 of file chan_agent.c.

char recordformat[AST_MAX_BUF] = "" [static]

Definition at line 218 of file chan_agent.c.

char recordformatext[AST_MAX_BUF] = "" [static]

Definition at line 219 of file chan_agent.c.

char savecallsin[AST_MAX_BUF] = "" [static]

Definition at line 221 of file chan_agent.c.

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

Definition at line 173 of file chan_agent.c.

int updatecdr = 0 [static]

Definition at line 222 of file chan_agent.c.

Referenced by login_exec().

char urlprefix[AST_MAX_BUF] = "" [static]

Definition at line 220 of file chan_agent.c.

Referenced by start_monitor_exec().

int wrapuptime [static]

Definition at line 206 of file chan_agent.c.