2002-09-02 15:20:28 +00:00
/*
2005-09-14 20:46:50 +00:00
* Asterisk - - An open source telephony toolkit .
2002-09-02 15:20:28 +00:00
*
2012-02-03 21:33:23 +00:00
* Copyright ( C ) 1999 - 2012 , Digium , Inc .
2002-09-02 15:20:28 +00:00
*
2004-08-11 19:02:46 +00:00
* Mark Spencer < markster @ digium . com >
2002-09-02 15:20:28 +00:00
*
2005-09-14 20:46:50 +00:00
* See http : //www.asterisk.org for more information about
* the Asterisk project . Please do not directly contact
* any of the maintainers of this project for assistance ;
* the project provides a web site , mailing lists and IRC
* channels for your use .
*
2002-09-02 15:20:28 +00:00
* This program is free software , distributed under the terms of
2005-09-14 20:46:50 +00:00
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree .
2002-09-02 15:20:28 +00:00
*/
2005-09-14 20:46:50 +00:00
2005-10-24 20:12:06 +00:00
/*! \file
2005-12-30 21:18:06 +00:00
*
2005-11-06 15:09:47 +00:00
* \ brief Implementation of Agents ( proxy channel )
2005-09-14 20:46:50 +00:00
*
2005-12-30 21:18:06 +00:00
* \ author Mark Spencer < markster @ digium . com >
*
2005-10-24 20:12:06 +00:00
* This file is the implementation of Agents modules .
2005-11-06 15:09:47 +00:00
* It is a dynamic module that is loaded by Asterisk .
* \ par See also
* \ arg \ ref Config_agent
*
* \ ingroup channel_drivers
2005-09-07 20:44:57 +00:00
*/
2008-01-22 17:46:43 +00:00
/*** MODULEINFO
< depend > chan_local < / depend >
2010-09-02 05:27:53 +00:00
< depend > res_monitor < / depend >
2011-07-14 20:28:54 +00:00
< support_level > core < / support_level >
2008-01-22 17:46:43 +00:00
* * */
2002-09-02 15:20:28 +00:00
2006-06-07 18:54:56 +00:00
# include "asterisk.h"
ASTERISK_FILE_VERSION ( __FILE__ , " $Revision$ " )
2005-06-07 17:06:33 +00:00
# include <sys/socket.h>
2005-06-06 21:09:59 +00:00
# include <fcntl.h>
# include <netdb.h>
2005-06-07 17:06:33 +00:00
# include <netinet/in.h>
2005-06-06 21:09:59 +00:00
# include <arpa/inet.h>
# include <sys/signal.h>
2005-04-21 06:02:45 +00:00
# include "asterisk/lock.h"
# include "asterisk/channel.h"
# include "asterisk/config.h"
# include "asterisk/module.h"
# include "asterisk/pbx.h"
# include "asterisk/sched.h"
# include "asterisk/io.h"
# include "asterisk/acl.h"
# include "asterisk/callerid.h"
# include "asterisk/file.h"
# include "asterisk/cli.h"
# include "asterisk/app.h"
# include "asterisk/musiconhold.h"
# include "asterisk/manager.h"
# include "asterisk/features.h"
# include "asterisk/utils.h"
# include "asterisk/causes.h"
# include "asterisk/astdb.h"
2005-07-08 21:14:34 +00:00
# include "asterisk/devicestate.h"
2005-11-08 04:02:35 +00:00
# include "asterisk/monitor.h"
2006-02-01 23:05:28 +00:00
# include "asterisk/stringfields.h"
2008-07-11 17:29:24 +00:00
# include "asterisk/event.h"
2010-07-08 14:48:42 +00:00
# include "asterisk/data.h"
2002-09-02 15:20:28 +00:00
2008-11-05 20:17:06 +00:00
/*** DOCUMENTATION
< application name = " AgentLogin " language = " en_US " >
< synopsis >
Call agent login .
< / synopsis >
< syntax >
< parameter name = " AgentNo " / >
< parameter name = " options " >
< optionlist >
< option name = " s " >
< para > silent login - do not announce the login ok segment after
agent logged on / off < / para >
< / option >
< / optionlist >
< / parameter >
< / syntax >
< description >
< para > Asks the agent to login to the system . Always returns < literal > - 1 < / literal > .
While logged in , the agent can receive calls and will hear a < literal > beep < / literal >
when a new call comes in . The agent can dump the call by pressing the star key . < / para >
< / description >
< see - also >
< ref type = " application " > Queue < / ref >
< ref type = " application " > AddQueueMember < / ref >
< ref type = " application " > RemoveQueueMember < / ref >
< ref type = " application " > PauseQueueMember < / ref >
< ref type = " application " > UnpauseQueueMember < / ref >
< ref type = " function " > AGENT < / ref >
< ref type = " filename " > agents . conf < / ref >
< ref type = " filename " > queues . conf < / ref >
< / see - also >
< / application >
< application name = " AgentMonitorOutgoing " language = " en_US " >
< synopsis >
Record agent ' s outgoing call .
< / synopsis >
< syntax >
< parameter name = " options " >
< optionlist >
< option name = " d " >
< para > make the app return < literal > - 1 < / literal > if there is an error condition . < / para >
< / option >
< option name = " c " >
< para > change the CDR so that the source of the call is
< literal > Agent / agent_id < / literal > < / para >
< / option >
< option name = " n " >
< para > don ' t generate the warnings when there is no callerid or the
agentid is not known . It ' s handy if you want to have one context
for agent and non - agent calls . < / para >
< / option >
< / optionlist >
< / parameter >
< / syntax >
< description >
< para > Tries to figure out the id of the agent who is placing outgoing call based on
comparison of the callerid of the current interface and the global variable
placed by the AgentCallbackLogin application . That ' s why it should be used only
with the AgentCallbackLogin app . Uses the monitoring functions in chan_agent
instead of Monitor application . That has to be configured in the
< filename > agents . conf < / filename > file . < / para >
< para > Normally the app returns < literal > 0 < / literal > unless the options are passed . < / para >
< / description >
< see - also >
< ref type = " filename " > agents . conf < / ref >
< / see - also >
< / application >
< function name = " AGENT " language = " en_US " >
< synopsis >
Gets information about an Agent
< / synopsis >
< syntax argsep = " : " >
< parameter name = " agentid " required = " true " / >
< parameter name = " item " >
< para > The valid items to retrieve are : < / para >
< enumlist >
< enum name = " status " >
< para > ( default ) The status of the agent ( LOGGEDIN | LOGGEDOUT ) < / para >
< / enum >
< enum name = " password " >
< para > The password of the agent < / para >
< / enum >
< enum name = " name " >
< para > The name of the agent < / para >
< / enum >
< enum name = " mohclass " >
< para > MusicOnHold class < / para >
< / enum >
< enum name = " channel " >
< para > The name of the active channel for the Agent ( AgentLogin ) < / para >
< / enum >
2010-06-14 19:41:43 +00:00
< enum name = " fullchannel " >
< para > The untruncated name of the active channel for the Agent ( AgentLogin ) < / para >
< / enum >
2008-11-05 20:17:06 +00:00
< / enumlist >
< / parameter >
< / syntax >
2011-01-04 21:54:20 +00:00
< description > < / description >
2008-11-05 20:17:06 +00:00
< / function >
2009-05-22 17:52:35 +00:00
< manager name = " Agents " language = " en_US " >
< synopsis >
Lists agents and their status .
< / synopsis >
< syntax >
< xi : include xpointer = " xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID']) " / >
< / syntax >
< description >
< para > Will list info about all possible agents . < / para >
< / description >
< / manager >
< manager name = " AgentLogoff " language = " en_US " >
< synopsis >
Sets an agent as no longer logged in .
< / synopsis >
< syntax >
< xi : include xpointer = " xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID']) " / >
< parameter name = " Agent " required = " true " >
< para > Agent ID of the agent to log off . < / para >
< / parameter >
< parameter name = " Soft " >
< para > Set to < literal > true < / literal > to not hangup existing calls . < / para >
< / parameter >
< / syntax >
< description >
< para > Sets an agent as no longer logged in . < / para >
< / description >
< / manager >
2008-11-05 20:17:06 +00:00
* * */
2005-03-04 06:47:24 +00:00
static const char tdesc [ ] = " Call Agent Proxy Channel " ;
static const char config [ ] = " agents.conf " ;
2002-09-02 15:20:28 +00:00
2005-03-04 06:47:24 +00:00
static const char app [ ] = " AgentLogin " ;
static const char app3 [ ] = " AgentMonitorOutgoing " ;
2002-09-02 15:20:28 +00:00
static char moh [ 80 ] = " default " ;
2006-06-14 14:46:19 +00:00
# define AST_MAX_AGENT 80 /*!< Agent ID or Password max length */
2004-02-03 16:57:00 +00:00
# define AST_MAX_BUF 256
2004-10-24 13:24:16 +00:00
# define AST_MAX_FILENAME_LEN 256
2002-09-02 15:20:28 +00:00
2007-06-07 21:17:52 +00:00
static const char pa_family [ ] = " Agents " ; /*!< Persistent Agents astdb family */
2006-06-14 14:46:19 +00:00
# define PA_MAX_LEN 2048 /*!< The maximum length of each persistent member agent database entry */
2008-07-02 20:43:55 +00:00
# define DEFAULT_ACCEPTDTMF '#'
# define DEFAULT_ENDDTMF '*'
2005-01-15 21:51:38 +00:00
static ast_group_t group ;
2003-07-22 11:06:56 +00:00
static int autologoff ;
2003-07-28 14:24:10 +00:00
static int wrapuptime ;
2003-08-05 23:57:55 +00:00
static int ackcall ;
2006-04-15 22:32:23 +00:00
static int endcall ;
2006-01-13 18:23:30 +00:00
static int autologoffunavail = 0 ;
2008-07-02 20:43:55 +00:00
static char acceptdtmf = DEFAULT_ACCEPTDTMF ;
static char enddtmf = DEFAULT_ENDDTMF ;
2003-07-01 04:08:25 +00:00
2004-10-24 13:24:16 +00:00
static int maxlogintries = 3 ;
static char agentgoodbye [ AST_MAX_FILENAME_LEN ] = " vm-goodbye " ;
2004-02-12 22:28:35 +00:00
static int recordagentcalls = 0 ;
2004-07-16 04:40:54 +00:00
static char recordformat [ AST_MAX_BUF ] = " " ;
static char recordformatext [ AST_MAX_BUF ] = " " ;
static char urlprefix [ AST_MAX_BUF ] = " " ;
static char savecallsin [ AST_MAX_BUF ] = " " ;
2004-04-03 00:41:47 +00:00
static int updatecdr = 0 ;
2004-06-28 18:40:41 +00:00
static char beep [ AST_MAX_BUF ] = " beep " ;
2004-02-03 16:57:00 +00:00
2004-02-05 21:13:17 +00:00
# define GETAGENTBYCALLERID "AGENTBYCALLERID"
2008-11-26 14:58:17 +00:00
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 ) ,
} ;
2006-06-27 20:52:52 +00:00
/*! \brief Structure representing an agent. */
2005-09-07 20:44:57 +00:00
struct agent_pvt {
2006-06-14 14:46:19 +00:00
ast_mutex_t lock ; /*!< Channel private lock */
int dead ; /*!< Poised for destruction? */
int pending ; /*!< Not a real agent -- just pending a match */
int abouttograb ; /*!< About to grab */
int autologoff ; /*!< Auto timeout time */
int ackcall ; /*!< ackcall */
2007-02-20 22:49:53 +00:00
int deferlogoff ; /*!< Defer logoff to hangup */
2008-07-02 20:43:55 +00:00
char acceptdtmf ;
char enddtmf ;
2006-06-14 14:46:19 +00:00
time_t loginstart ; /*!< When agent first logged in (0 when logged off) */
time_t start ; /*!< When call started */
struct timeval lastdisc ; /*!< When last disconnected */
int wrapuptime ; /*!< Wrapup time in ms */
ast_group_t group ; /*!< Group memberships */
int acknowledged ; /*!< Acknowledged */
char moh [ 80 ] ; /*!< Which music on hold */
char agent [ AST_MAX_AGENT ] ; /*!< Agent ID */
char password [ AST_MAX_AGENT ] ; /*!< Password for Agent login */
2002-09-02 15:20:28 +00:00
char name [ AST_MAX_AGENT ] ;
2009-01-12 20:53:04 +00:00
int app_lock_flag ;
ast_cond_t app_complete_cond ;
2011-04-22 21:33:42 +00:00
ast_cond_t login_wait_cond ;
2006-08-21 02:11:39 +00:00
volatile int app_sleep_cond ; /**< Sleep condition for the login app */
struct ast_channel * owner ; /**< Agent */
char logincallerid [ 80 ] ; /**< Caller ID they had when they logged in */
struct ast_channel * chan ; /**< Channel we use */
2008-11-26 14:58:17 +00:00
unsigned int flags ; /**< Flags show if settings were applied with channel vars */
2006-08-21 02:11:39 +00:00
AST_LIST_ENTRY ( agent_pvt ) list ; /**< Next Agent in the linked list. */
2005-09-07 20:44:57 +00:00
} ;
2010-07-08 14:48:42 +00:00
# define DATA_EXPORT_AGENT(MEMBER) \
MEMBER ( agent_pvt , autologoff , AST_DATA_INTEGER ) \
MEMBER ( agent_pvt , ackcall , AST_DATA_BOOLEAN ) \
MEMBER ( agent_pvt , deferlogoff , AST_DATA_BOOLEAN ) \
MEMBER ( agent_pvt , wrapuptime , AST_DATA_MILLISECONDS ) \
MEMBER ( agent_pvt , acknowledged , AST_DATA_BOOLEAN ) \
MEMBER ( agent_pvt , name , AST_DATA_STRING ) \
MEMBER ( agent_pvt , password , AST_DATA_PASSWORD ) \
MEMBER ( agent_pvt , acceptdtmf , AST_DATA_CHARACTER ) \
MEMBER ( agent_pvt , logincallerid , AST_DATA_STRING )
AST_DATA_STRUCTURE ( agent_pvt , DATA_EXPORT_AGENT ) ;
2006-06-14 14:46:19 +00:00
static AST_LIST_HEAD_STATIC ( agents , agent_pvt ) ; /*!< Holds the list of agents (loaded form agents.conf). */
2002-09-02 15:20:28 +00:00
2003-08-13 17:32:44 +00:00
# define CHECK_FORMATS(ast, p) do { \
if ( p - > chan ) { \
2012-02-20 23:43:27 +00:00
if ( ! ( ast_format_cap_identical ( ast_channel_nativeformats ( ast ) , ast_channel_nativeformats ( p - > chan ) ) ) ) { \
2009-11-04 14:05:12 +00:00
char tmp1 [ 256 ] , tmp2 [ 256 ] ; \
2012-02-20 23:43:27 +00:00
ast_debug ( 1 , " Native formats changing from '%s' to '%s' \n " , ast_getformatname_multiple ( tmp1 , sizeof ( tmp1 ) , ast_channel_nativeformats ( ast ) ) , ast_getformatname_multiple ( tmp2 , sizeof ( tmp2 ) , ast_channel_nativeformats ( p - > chan ) ) ) ; \
2003-08-13 17:32:44 +00:00
/* Native formats changed, reset things */ \
2012-02-20 23:43:27 +00:00
ast_format_cap_copy ( ast_channel_nativeformats ( ast ) , ast_channel_nativeformats ( p - > chan ) ) ; \
2012-02-24 00:32:20 +00:00
ast_debug ( 1 , " Resetting read to '%s' and write to '%s' \n " , ast_getformatname ( ast_channel_readformat ( ast ) ) , ast_getformatname ( ast_channel_writeformat ( ast ) ) ) ; \
ast_set_read_format ( ast , ast_channel_readformat ( ast ) ) ; \
ast_set_write_format ( ast , ast_channel_writeformat ( ast ) ) ; \
2003-08-13 17:32:44 +00:00
} \
2012-02-24 00:32:20 +00:00
if ( ( ast_format_cmp ( ast_channel_readformat ( p - > chan ) , ast_channel_rawreadformat ( ast ) ) ! = AST_FORMAT_CMP_EQUAL ) & & ! ast_channel_generator ( p - > chan ) ) \
ast_set_read_format ( p - > chan , ast_channel_rawreadformat ( ast ) ) ; \
if ( ( ast_format_cmp ( ast_channel_writeformat ( p - > chan ) , ast_channel_rawwriteformat ( ast ) ) ! = AST_FORMAT_CMP_EQUAL ) & & ! ast_channel_generator ( p - > chan ) ) \
ast_set_write_format ( p - > chan , ast_channel_rawwriteformat ( ast ) ) ; \
2003-08-13 17:32:44 +00:00
} \
} while ( 0 )
2006-06-14 14:46:19 +00:00
/*! \brief Cleanup moves all the relevant FD's from the 2nd to the first, but retains things
2003-08-23 02:11:44 +00:00
properly for a timingfd XXX This might need more work if agents were logged in as agents or other
totally impractical combinations XXX */
2002-09-02 15:20:28 +00:00
# define CLEANUP(ast, p) do { \
int x ; \
if ( p - > chan ) { \
2012-03-01 22:09:18 +00:00
for ( x = 0 ; x < AST_MAX_FDS ; x + + ) { \
if ( x ! = AST_TIMING_FD ) { \
ast_channel_set_fd ( ast , x , ast_channel_fd ( p - > chan , x ) ) ; \
} \
2003-08-23 02:11:44 +00:00
} \
2012-03-01 22:09:18 +00:00
ast_channel_set_fd ( ast , AST_AGENT_FD , ast_channel_fd ( p - > chan , AST_TIMING_FD ) ) ; \
2002-09-02 15:20:28 +00:00
} \
} while ( 0 )
2006-06-14 14:46:19 +00:00
/*--- Forward declarations */
2012-02-01 19:53:38 +00:00
static struct ast_channel * agent_request ( const char * type , struct ast_format_cap * cap , const struct ast_channel * requestor , const char * data , int * cause ) ;
static int agent_devicestate ( const char * data ) ;
2006-08-31 01:59:02 +00:00
static int agent_digit_begin ( struct ast_channel * ast , char digit ) ;
Merged revisions 51311 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r51311 | russell | 2007-01-19 11:49:38 -0600 (Fri, 19 Jan 2007) | 23 lines
Merge the changes from the /team/group/vldtmf_fixup branch.
The main bug being addressed here is a problem introduced when two SIP
channels using SIP INFO dtmf have their media directly bridged. So, when a
DTMF END frame comes into Asterisk from an incoming INFO message, Asterisk
would try to emulate a digit of some length by first sending a DTMF BEGIN
frame and sending a DTMF END later timed off of incoming audio. However,
since there was no audio coming in, the DTMF_END was never generated. This
caused DTMF based features to no longer work.
To fix this, the core now knows when a channel doesn't care about DTMF BEGIN
frames (such as a SIP channel sending INFO dtmf). If this is the case, then
Asterisk will not emulate a digit of some length, and will instead just pass
through the single DTMF END event.
Channel drivers also now get passed the length of the digit to their digit_end
callback. This improves SIP INFO support even further by enabling us to put
the real digit duration in the INFO message instead of a hard coded 250ms.
Also, for an incoming INFO message, the duration is read from the frame and
passed into the core instead of just getting ignored.
(issue #8597, maybe others...)
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@51314 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2007-01-19 18:06:03 +00:00
static int agent_digit_end ( struct ast_channel * ast , char digit , unsigned int duration ) ;
2012-02-01 19:53:38 +00:00
static int agent_call ( struct ast_channel * ast , const char * dest , int timeout ) ;
2005-03-04 06:47:24 +00:00
static int agent_hangup ( struct ast_channel * ast ) ;
static int agent_answer ( struct ast_channel * ast ) ;
static struct ast_frame * agent_read ( struct ast_channel * ast ) ;
static int agent_write ( struct ast_channel * ast , struct ast_frame * f ) ;
2005-03-28 20:48:24 +00:00
static int agent_sendhtml ( struct ast_channel * ast , int subclass , const char * data , int datalen ) ;
2005-10-14 00:46:13 +00:00
static int agent_sendtext ( struct ast_channel * ast , const char * text ) ;
2006-05-10 12:24:11 +00:00
static int agent_indicate ( struct ast_channel * ast , int condition , const void * data , size_t datalen ) ;
2005-03-04 06:47:24 +00:00
static int agent_fixup ( struct ast_channel * oldchan , struct ast_channel * newchan ) ;
static struct ast_channel * agent_bridgedchannel ( struct ast_channel * chan , struct ast_channel * bridge ) ;
2007-09-18 22:43:45 +00:00
static char * complete_agent_logoff_cmd ( const char * line , const char * word , int pos , int state ) ;
2007-09-27 23:18:09 +00:00
static struct ast_channel * agent_get_base_channel ( struct ast_channel * chan ) ;
static int agent_set_base_channel ( struct ast_channel * chan , struct ast_channel * base ) ;
2009-04-18 01:28:45 +00:00
static int agent_logoff ( const char * agent , int soft ) ;
2005-03-04 06:47:24 +00:00
2006-06-14 14:46:19 +00:00
/*! \brief Channel interface description for PBX integration */
2011-02-03 16:22:10 +00:00
static struct ast_channel_tech agent_tech = {
2006-02-01 23:05:28 +00:00
. type = " Agent " ,
2005-03-04 06:47:24 +00:00
. description = tdesc ,
. requester = agent_request ,
. devicestate = agent_devicestate ,
2006-08-31 01:59:02 +00:00
. send_digit_begin = agent_digit_begin ,
. send_digit_end = agent_digit_end ,
2005-03-04 06:47:24 +00:00
. call = agent_call ,
. hangup = agent_hangup ,
. answer = agent_answer ,
. read = agent_read ,
. write = agent_write ,
2006-06-21 20:11:09 +00:00
. write_video = agent_write ,
2005-03-04 06:47:24 +00:00
. send_html = agent_sendhtml ,
2005-10-14 00:46:13 +00:00
. send_text = agent_sendtext ,
2005-03-04 06:47:24 +00:00
. exception = agent_read ,
. indicate = agent_indicate ,
. fixup = agent_fixup ,
. bridged_channel = agent_bridgedchannel ,
2007-09-27 23:18:09 +00:00
. get_base_channel = agent_get_base_channel ,
. set_base_channel = agent_set_base_channel ,
2005-03-04 06:47:24 +00:00
} ;
2005-01-01 00:57:04 +00:00
2012-02-03 21:33:23 +00:00
/*!
* \ brief Locks the owning channel for a LOCKED pvt while obeying locking order . The pvt
* must enter this function locked and will be returned locked , but this function will
* unlock the pvt for a short time , so it can ' t be used while expecting the pvt to remain
* static . If function returns a non NULL channel , it will need to be unlocked and
* unrefed once it is no longer needed .
*
* \ param pvt Pointer to the LOCKED agent_pvt for which the owner is needed
2012-09-22 20:43:30 +00:00
* locked channel which owns the pvt at the time of completion . NULL if not available .
2012-02-03 21:33:23 +00:00
*/
static struct ast_channel * agent_lock_owner ( struct agent_pvt * pvt )
{
struct ast_channel * owner ;
for ( ; ; ) {
if ( ! pvt - > owner ) { /* No owner. Nothing to do. */
return NULL ;
}
/* If we don't ref the owner, it could be killed when we unlock the pvt. */
owner = ast_channel_ref ( pvt - > owner ) ;
/* Locking order requires us to lock channel, then pvt. */
ast_mutex_unlock ( & pvt - > lock ) ;
ast_channel_lock ( owner ) ;
ast_mutex_lock ( & pvt - > lock ) ;
/* Check if owner changed during pvt unlock period */
if ( owner ! = pvt - > owner ) { /* Channel changed. Unref and do another pass. */
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
} else { /* Channel stayed the same. Return it. */
return owner ;
}
}
}
2006-06-14 14:46:19 +00:00
/*!
2005-09-07 20:44:57 +00:00
* Adds an agent to the global list of agents .
*
2006-06-14 14:46:19 +00:00
* \ param agent A string with the username , password and real name of an agent . As defined in agents . conf . Example : " 13,169,John Smith "
* \ param pending If it is pending or not .
2005-09-07 20:44:57 +00:00
* @ return The just created agent .
2006-06-14 14:46:19 +00:00
* \ sa agent_pvt , agents .
2005-09-07 20:44:57 +00:00
*/
2007-11-14 13:18:40 +00:00
static struct agent_pvt * add_agent ( const char * agent , int pending )
2002-09-02 15:20:28 +00:00
{
2006-01-13 18:30:49 +00:00
char * parse ;
AST_DECLARE_APP_ARGS ( args ,
AST_APP_ARG ( agt ) ;
AST_APP_ARG ( password ) ;
AST_APP_ARG ( name ) ;
) ;
2005-04-15 05:51:30 +00:00
char * password = NULL ;
char * name = NULL ;
char * agt = NULL ;
2006-01-25 18:12:55 +00:00
struct agent_pvt * p ;
2005-04-15 05:51:30 +00:00
2006-05-10 13:22:15 +00:00
parse = ast_strdupa ( agent ) ;
2006-01-13 18:30:49 +00:00
/* Extract username (agt), password and name from agent (args). */
2008-01-02 21:08:33 +00:00
AST_STANDARD_APP_ARGS ( args , parse ) ;
2006-01-13 18:30:49 +00:00
if ( args . argc = = 0 ) {
2005-04-15 05:51:30 +00:00
ast_log ( LOG_WARNING , " A blank agent line! \n " ) ;
2006-01-13 18:30:49 +00:00
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 + + ;
2002-09-02 15:20:28 +00:00
}
2005-04-15 05:51:30 +00:00
2006-01-13 18:30:49 +00:00
/* Are we searching for the agent here ? To see if it exists already ? */
2006-01-25 18:12:55 +00:00
AST_LIST_TRAVERSE ( & agents , p , list ) {
2005-04-15 05:51:30 +00:00
if ( ! pending & & ! strcmp ( p - > agent , agt ) )
2002-09-02 15:20:28 +00:00
break ;
}
if ( ! p ) {
2005-09-07 20:44:57 +00:00
// Build the agent.
2006-01-11 01:20:29 +00:00
if ( ! ( p = ast_calloc ( 1 , sizeof ( * p ) ) ) )
2005-04-15 05:51:30 +00:00
return NULL ;
2006-01-11 01:20:29 +00:00
ast_copy_string ( p - > agent , agt , sizeof ( p - > agent ) ) ;
ast_mutex_init ( & p - > lock ) ;
2009-01-12 20:53:04 +00:00
ast_cond_init ( & p - > app_complete_cond , NULL ) ;
2011-04-22 21:33:42 +00:00
ast_cond_init ( & p - > login_wait_cond , NULL ) ;
2009-01-12 20:53:04 +00:00
p - > app_lock_flag = 0 ;
2006-01-11 01:20:29 +00:00
p - > app_sleep_cond = 1 ;
p - > group = group ;
p - > pending = pending ;
2006-01-25 18:12:55 +00:00
AST_LIST_INSERT_TAIL ( & agents , p , list ) ;
2002-09-02 15:20:28 +00:00
}
2005-04-15 05:51:30 +00:00
2005-08-26 20:24:16 +00:00
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 ) ) ;
2008-11-26 14:58:17 +00:00
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 ;
}
2005-04-06 16:06:05 +00:00
/* If someone reduces the wrapuptime and reloads, we want it
* to change the wrapuptime immediately on all calls */
2008-11-26 14:58:17 +00:00
if ( ! ast_test_flag ( p , AGENT_FLAG_WRAPUPTIME ) & & p - > wrapuptime > wrapuptime ) {
2005-07-15 23:00:47 +00:00
struct timeval now = ast_tvnow ( ) ;
/* XXX check what is this exactly */
2005-04-06 16:06:05 +00:00
/* 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 ;
}
}
2003-07-28 14:24:10 +00:00
p - > wrapuptime = wrapuptime ;
2005-04-06 16:06:05 +00:00
2003-07-01 16:16:28 +00:00
if ( pending )
p - > dead = 1 ;
else
p - > dead = 0 ;
return p ;
2002-09-02 15:20:28 +00:00
}
2006-06-14 14:46:19 +00:00
/*!
2005-09-14 02:12:37 +00:00
* Deletes an agent after doing some clean up .
* Further documentation : How safe is this function ? What state should the agent be to be cleaned .
2012-05-31 18:39:30 +00:00
*
* \ warning XXX This function seems to be very unsafe .
* Potential for double free and use after free among other
* problems .
*
2006-06-14 14:46:19 +00:00
* \ param p Agent to be deleted .
2006-06-27 20:52:52 +00:00
* \ returns Always 0.
2005-09-14 02:12:37 +00:00
*/
2003-07-09 22:41:51 +00:00
static int agent_cleanup ( struct agent_pvt * p )
{
2012-05-31 18:39:30 +00:00
struct ast_channel * chan ;
2011-04-22 21:33:42 +00:00
ast_mutex_lock ( & p - > lock ) ;
chan = p - > owner ;
2003-07-09 22:41:51 +00:00
p - > owner = NULL ;
/* Release ownership of the agent to other threads (presumably running the login app). */
2011-04-22 21:33:42 +00:00
p - > app_sleep_cond = 1 ;
2009-01-12 20:53:04 +00:00
p - > app_lock_flag = 0 ;
ast_cond_signal ( & p - > app_complete_cond ) ;
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
if ( chan ) {
2012-05-31 18:39:30 +00:00
ast_channel_tech_pvt_set ( chan , NULL ) ;
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
chan = ast_channel_release ( chan ) ;
}
2004-06-22 17:42:14 +00:00
if ( p - > dead ) {
2011-04-22 21:33:42 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2004-06-22 17:42:14 +00:00
ast_mutex_destroy ( & p - > lock ) ;
2009-01-12 20:53:04 +00:00
ast_cond_destroy ( & p - > app_complete_cond ) ;
2011-04-22 21:33:42 +00:00
ast_cond_destroy ( & p - > login_wait_cond ) ;
2007-06-06 21:20:11 +00:00
ast_free ( p ) ;
2012-05-31 18:39:30 +00:00
} else {
ast_mutex_unlock ( & p - > lock ) ;
}
2003-07-09 22:41:51 +00:00
return 0 ;
}
2003-07-01 16:16:28 +00:00
static int check_availability ( struct agent_pvt * newlyavailable , int needlock ) ;
2002-09-02 15:20:28 +00:00
static int agent_answer ( struct ast_channel * ast )
{
ast_log ( LOG_WARNING , " Huh? Agent is being asked to answer? \n " ) ;
return - 1 ;
}
2004-02-05 21:13:17 +00:00
static int __agent_start_monitoring ( struct ast_channel * ast , struct agent_pvt * p , int needlock )
2004-02-03 16:57:00 +00:00
{
char tmp [ AST_MAX_BUF ] , tmp2 [ AST_MAX_BUF ] , * pointer ;
char filename [ AST_MAX_BUF ] ;
int res = - 1 ;
if ( ! p )
return - 1 ;
2012-02-20 23:43:27 +00:00
if ( ! ast_channel_monitor ( ast ) ) {
2012-01-24 20:12:09 +00:00
snprintf ( filename , sizeof ( filename ) , " agent-%s-%s " , p - > agent , ast_channel_uniqueid ( ast ) ) ;
2004-02-10 21:14:48 +00:00
/* substitute . for - */
if ( ( pointer = strchr ( filename , ' . ' ) ) )
2004-02-03 16:57:00 +00:00
* pointer = ' - ' ;
2007-07-18 13:59:01 +00:00
snprintf ( tmp , sizeof ( tmp ) , " %s%s " , savecallsin , filename ) ;
2007-07-10 15:07:25 +00:00
ast_monitor_start ( ast , recordformat , tmp , needlock , X_REC_IN | X_REC_OUT ) ;
2004-02-03 16:57:00 +00:00
ast_monitor_setjoinfiles ( ast , 1 ) ;
2007-07-18 13:59:01 +00:00
snprintf ( tmp2 , sizeof ( tmp2 ) , " %s%s.%s " , urlprefix , filename , recordformatext ) ;
2004-02-03 16:57:00 +00:00
#if 0
ast_verbose ( " name is %s, link is %s \n " , tmp , tmp2 ) ;
# endif
2012-02-20 23:43:27 +00:00
if ( ! ast_channel_cdr ( ast ) )
ast_channel_cdr_set ( ast , ast_cdr_alloc ( ) ) ;
2004-02-03 16:57:00 +00:00
ast_cdr_setuserfield ( ast , tmp2 ) ;
res = 0 ;
} else
ast_log ( LOG_ERROR , " Recording already started on that call. \n " ) ;
return res ;
}
2004-02-05 21:13:17 +00:00
static int agent_start_monitoring ( struct ast_channel * ast , int needlock )
{
2012-02-20 23:43:27 +00:00
return __agent_start_monitoring ( ast , ast_channel_tech_pvt ( ast ) , needlock ) ;
2004-02-05 21:13:17 +00:00
}
2004-12-31 00:58:44 +00:00
static struct ast_frame * agent_read ( struct ast_channel * ast )
2002-09-02 15:20:28 +00:00
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2002-09-02 15:20:28 +00:00
struct ast_frame * f = NULL ;
2009-11-04 14:05:12 +00:00
static struct ast_frame answer_frame = { AST_FRAME_CONTROL , { AST_CONTROL_ANSWER } } ;
2009-04-18 01:28:45 +00:00
int cur_time = time ( NULL ) ;
2012-02-03 21:33:23 +00:00
struct ast_channel * owner ;
2009-04-18 01:28:45 +00:00
ast_mutex_lock ( & p - > lock ) ;
2012-02-03 21:33:23 +00:00
owner = agent_lock_owner ( p ) ;
2003-08-13 17:32:44 +00:00
CHECK_FORMATS ( ast , p ) ;
2009-04-18 01:28:45 +00:00
if ( ! p - > start ) {
p - > start = cur_time ;
}
2003-08-13 01:12:19 +00:00
if ( p - > chan ) {
2012-03-13 18:20:34 +00:00
ast_copy_flags ( ast_channel_flags ( p - > chan ) , ast_channel_flags ( ast ) , AST_FLAG_EXCEPTION ) ;
2012-02-20 23:43:27 +00:00
ast_channel_fdno_set ( p - > chan , ( ast_channel_fdno ( ast ) = = AST_AGENT_FD ) ? AST_TIMING_FD : ast_channel_fdno ( ast ) ) ;
2002-09-02 15:20:28 +00:00
f = ast_read ( p - > chan ) ;
2003-08-13 01:12:19 +00:00
} else
2006-01-31 17:18:58 +00:00
f = & ast_null_frame ;
2002-09-02 15:20:28 +00:00
if ( ! f ) {
2009-05-30 01:04:57 +00:00
/* If there's a channel, make it NULL */
2003-07-27 04:27:18 +00:00
if ( p - > chan ) {
2012-03-13 18:20:34 +00:00
ast_channel_internal_bridged_channel_set ( p - > chan , NULL ) ;
2002-09-02 15:20:28 +00:00
p - > chan = NULL ;
2008-07-25 21:20:03 +00:00
ast_devstate_changed ( AST_DEVICE_UNAVAILABLE , " Agent/%s " , p - > agent ) ;
2003-08-06 01:39:42 +00:00
p - > acknowledged = 0 ;
2003-07-27 04:27:18 +00:00
}
2009-04-18 01:28:45 +00:00
} 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 */
2012-02-20 23:43:27 +00:00
if ( ! p - > ackcall & & ! p - > acknowledged & & p - > chan & & ( ast_channel_state ( p - > chan ) = = AST_STATE_UP ) ) {
2009-04-18 01:28:45 +00:00
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 ) ;
2012-02-03 21:33:23 +00:00
if ( owner | | p - > chan ) {
if ( owner ) {
ast_softhangup ( owner , AST_SOFTHANGUP_EXPLICIT ) ;
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
2010-01-19 18:46:11 +00:00
}
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 ) ;
}
}
2009-04-18 01:28:45 +00:00
}
}
switch ( f - > frametype ) {
case AST_FRAME_CONTROL :
2009-11-04 14:05:12 +00:00
if ( f - > subclass . integer = = AST_CONTROL_ANSWER ) {
2009-04-18 01:28:45 +00:00
if ( p - > ackcall ) {
2012-01-09 22:15:50 +00:00
ast_verb ( 3 , " %s answered, waiting for '%c' to acknowledge \n " , ast_channel_name ( p - > chan ) , p - > acceptdtmf ) ;
2009-04-18 01:28:45 +00:00
/* Don't pass answer along */
ast_frfree ( f ) ;
f = & ast_null_frame ;
} else {
p - > acknowledged = 1 ;
/* Use the builtin answer frame for the
2005-06-18 16:38:48 +00:00
recording start check below . */
2009-04-18 01:28:45 +00:00
ast_frfree ( f ) ;
f = & answer_frame ;
}
}
break ;
2006-08-31 01:59:02 +00:00
case AST_FRAME_DTMF_BEGIN :
2007-08-27 21:09:37 +00:00
/*ignore DTMF begin's as it can cause issues with queue announce files*/
2009-11-04 14:05:12 +00:00
if ( ( ! p - > acknowledged & & f - > subclass . integer = = p - > acceptdtmf ) | | ( f - > subclass . integer = = p - > enddtmf & & endcall ) ) {
2007-08-27 21:09:37 +00:00
ast_frfree ( f ) ;
f = & ast_null_frame ;
}
break ;
2009-04-18 01:28:45 +00:00
case AST_FRAME_DTMF_END :
2009-11-04 14:05:12 +00:00
if ( ! p - > acknowledged & & ( f - > subclass . integer = = p - > acceptdtmf ) ) {
Resolve FORWARD_NULL static analysis warnings
This resolves core findings from ASTERISK-19650 numbers 0-2, 6, 7, 9-11, 14-20,
22-24, 28, 30-32, 34-36, 42-56, 82-84, 87, 89-90, 93-102, 104, 105, 109-111,
and 115. Finding numbers 26, 33, and 29 were already resolved. Those skipped
were either extended/deprecated or in areas of code that shouldn't be
disturbed.
(Closes issue ASTERISK-19650)
........
Merged revisions 366167 from http://svn.asterisk.org/svn/asterisk/branches/1.8
........
Merged revisions 366168 from http://svn.asterisk.org/svn/asterisk/branches/10
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@366169 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2012-05-10 20:56:09 +00:00
if ( p - > chan ) {
ast_verb ( 3 , " %s acknowledged \n " , ast_channel_name ( p - > chan ) ) ;
}
2009-04-18 01:28:45 +00:00
p - > acknowledged = 1 ;
ast_frfree ( f ) ;
f = & answer_frame ;
2009-11-04 14:05:12 +00:00
} else if ( f - > subclass . integer = = p - > enddtmf & & endcall ) {
2009-04-18 01:28:45 +00:00
/* 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 ;
}
2006-08-31 01:59:02 +00:00
default :
/* pass everything else on through */
break ;
2009-04-18 01:28:45 +00:00
}
}
2005-04-05 21:30:24 +00:00
2012-02-03 21:33:23 +00:00
if ( owner ) {
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
}
2002-09-02 15:20:28 +00:00
CLEANUP ( ast , p ) ;
2012-03-13 18:20:34 +00:00
if ( p - > chan & & ! ast_channel_internal_bridged_channel ( p - > chan ) ) {
2012-02-20 23:43:27 +00:00
if ( strcasecmp ( ast_channel_tech ( p - > chan ) - > type , " Local " ) ) {
2012-03-13 18:20:34 +00:00
ast_channel_internal_bridged_channel_set ( p - > chan , ast ) ;
2007-06-14 19:39:12 +00:00
if ( p - > chan )
2012-03-13 18:20:34 +00:00
ast_debug ( 1 , " Bridge on '%s' being set to '%s' (3) \n " , ast_channel_name ( p - > chan ) , ast_channel_name ( ast_channel_internal_bridged_channel ( p - > chan ) ) ) ;
2005-02-14 23:20:01 +00:00
}
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2004-02-12 22:28:35 +00:00
if ( recordagentcalls & & f = = & answer_frame )
2004-02-03 16:57:00 +00:00
agent_start_monitoring ( ast , 0 ) ;
2002-09-02 15:20:28 +00:00
return f ;
}
2005-03-28 20:48:24 +00:00
static int agent_sendhtml ( struct ast_channel * ast , int subclass , const char * data , int datalen )
2005-02-10 06:36:09 +00:00
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2005-02-10 06:36:09 +00:00
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 ;
}
2005-10-14 00:46:13 +00:00
static int agent_sendtext ( struct ast_channel * ast , const char * text )
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2005-10-14 00:46:13 +00:00
int res = - 1 ;
ast_mutex_lock ( & p - > lock ) ;
if ( p - > chan )
res = ast_sendtext ( p - > chan , text ) ;
ast_mutex_unlock ( & p - > lock ) ;
return res ;
}
2002-09-02 15:20:28 +00:00
static int agent_write ( struct ast_channel * ast , struct ast_frame * f )
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2002-09-02 15:20:28 +00:00
int res = - 1 ;
2003-08-13 17:32:44 +00:00
CHECK_FORMATS ( ast , p ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2006-06-21 20:11:09 +00:00
if ( ! p - > chan )
res = 0 ;
else {
2003-08-13 17:32:44 +00:00
if ( ( f - > frametype ! = AST_FRAME_VOICE ) | |
2006-06-21 20:11:09 +00:00
( f - > frametype ! = AST_FRAME_VIDEO ) | |
2012-02-24 00:32:20 +00:00
( ast_format_cmp ( & f - > subclass . format , ast_channel_writeformat ( p - > chan ) ) ! = AST_FORMAT_CMP_NOT_EQUAL ) ) {
2003-08-13 17:32:44 +00:00
res = ast_write ( p - > chan , f ) ;
} else {
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Dropping one incompatible %s frame on '%s' to '%s' \n " ,
f - > frametype = = AST_FRAME_VOICE ? " audio " : " video " ,
2012-01-09 22:15:50 +00:00
ast_channel_name ( ast ) , ast_channel_name ( p - > chan ) ) ;
2003-08-13 17:32:44 +00:00
res = 0 ;
}
2006-06-21 20:11:09 +00:00
}
2002-09-02 15:20:28 +00:00
CLEANUP ( ast , p ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
return res ;
}
2004-04-08 19:19:24 +00:00
static int agent_fixup ( struct ast_channel * oldchan , struct ast_channel * newchan )
2002-09-02 15:20:28 +00:00
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( newchan ) ;
2004-04-08 19:28:05 +00:00
ast_mutex_lock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
if ( p - > owner ! = oldchan ) {
ast_log ( LOG_WARNING , " old channel wasn't %p but was %p \n " , oldchan , p - > owner ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
return - 1 ;
}
p - > owner = newchan ;
2004-04-08 19:28:05 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
return 0 ;
}
2006-05-10 12:24:11 +00:00
static int agent_indicate ( struct ast_channel * ast , int condition , const void * data , size_t datalen )
2002-09-02 15:20:28 +00:00
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2002-09-02 15:20:28 +00:00
int res = - 1 ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2008-11-10 21:14:44 +00:00
if ( p - > chan & & ! ast_check_hangup ( p - > chan ) ) {
while ( ast_channel_trylock ( p - > chan ) ) {
2010-07-03 02:36:31 +00:00
if ( ( res = ast_channel_unlock ( ast ) ) ) {
Fix negative return handling in channel drivers
In chan_agent, while handling a channel indicate, the agent channel driver
must obtain a lock on both the agent channel, as well as the channel the
agent channel is using. To do so, it attempts to lock the other channel
first, then unlock the agent channel which is locked prior to entry into
the indicate handler. If this unlock fails with a negative return value,
which can occur if the object passed to agent_indicate is an invalid ao2
object or is NULL, the return value is passed directly to strerror, which
can only accept positive integer values.
In chan_dahdi, the return value of dahdi_get_index is used to directly
index into the sub-channel array. If dahd_get_index returns a negative
value, it would use that value to index into the array, which could cause
an invalid memory access. If dahdi_get_index returns a negative number,
we now default to SUB_REAL.
(issue ASTERISK-19655)
Reported by: Matt Jordan
Review: https://reviewboard.asterisk.org/r/1863/
........
Merged revisions 362204 from http://svn.asterisk.org/svn/asterisk/branches/1.8
........
Merged revisions 362205 from http://svn.asterisk.org/svn/asterisk/branches/10
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@362206 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2012-04-16 21:58:06 +00:00
ast_log ( LOG_ERROR , " chan_agent bug! Channel was not locked upon entry to agent_indicate: %s \n " , res > 0 ? strerror ( res ) : " Bad ao2obj data " ) ;
2010-07-03 02:36:31 +00:00
ast_mutex_unlock ( & p - > lock ) ;
return - 1 ;
}
2008-11-10 21:14:44 +00:00
usleep ( 1 ) ;
ast_channel_lock ( ast ) ;
}
2012-02-20 23:43:27 +00:00
res = ast_channel_tech ( p - > chan ) - > indicate ? ast_channel_tech ( p - > chan ) - > indicate ( p - > chan , condition , data , datalen ) : - 1 ;
2008-11-10 21:14:44 +00:00
ast_channel_unlock ( p - > chan ) ;
} else
2003-07-01 16:16:28 +00:00
res = 0 ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
return res ;
}
2006-08-31 01:59:02 +00:00
static int agent_digit_begin ( struct ast_channel * ast , char digit )
2002-09-02 15:20:28 +00:00
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2008-03-18 17:59:18 +00:00
if ( p - > chan ) {
ast_senddigit_begin ( p - > chan , digit ) ;
}
2006-08-31 01:59:02 +00:00
ast_mutex_unlock ( & p - > lock ) ;
Merged revisions 62218 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r62218 | russell | 2007-04-27 16:10:51 -0500 (Fri, 27 Apr 2007) | 11 lines
Fix a weird problem where when a caller talking to someone sitting behind an
agent channel sent a digit, the digit would be played to the agent for forever.
This is because chan_agent always returned -1 from its send_digit_begin and _end
callbacks. This non-zero return value indicates to the Asterisk core that it
would like an inband DTMF generator put on the channel. However, this is the
wrong thing to do. It should *always* return 0, instead. When the digit begin
and end functions are called on the proxied channel, the underlying channel
will indicate whether inband DTMF is needed or not, and the generator will be
put on that one, and not the Agent channel.
(issue #9615, #9616, reported by jiddings and BigJimmy, and fixed by me)
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@62219 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2007-04-27 21:11:46 +00:00
return 0 ;
2006-08-31 01:59:02 +00:00
}
Merged revisions 51311 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r51311 | russell | 2007-01-19 11:49:38 -0600 (Fri, 19 Jan 2007) | 23 lines
Merge the changes from the /team/group/vldtmf_fixup branch.
The main bug being addressed here is a problem introduced when two SIP
channels using SIP INFO dtmf have their media directly bridged. So, when a
DTMF END frame comes into Asterisk from an incoming INFO message, Asterisk
would try to emulate a digit of some length by first sending a DTMF BEGIN
frame and sending a DTMF END later timed off of incoming audio. However,
since there was no audio coming in, the DTMF_END was never generated. This
caused DTMF based features to no longer work.
To fix this, the core now knows when a channel doesn't care about DTMF BEGIN
frames (such as a SIP channel sending INFO dtmf). If this is the case, then
Asterisk will not emulate a digit of some length, and will instead just pass
through the single DTMF END event.
Channel drivers also now get passed the length of the digit to their digit_end
callback. This improves SIP INFO support even further by enabling us to put
the real digit duration in the INFO message instead of a hard coded 250ms.
Also, for an incoming INFO message, the duration is read from the frame and
passed into the core instead of just getting ignored.
(issue #8597, maybe others...)
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@51314 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2007-01-19 18:06:03 +00:00
static int agent_digit_end ( struct ast_channel * ast , char digit , unsigned int duration )
2006-08-31 01:59:02 +00:00
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2006-08-31 01:59:02 +00:00
ast_mutex_lock ( & p - > lock ) ;
2008-03-18 17:59:18 +00:00
if ( p - > chan ) {
ast_senddigit_end ( p - > chan , digit , duration ) ;
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
Merged revisions 62218 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r62218 | russell | 2007-04-27 16:10:51 -0500 (Fri, 27 Apr 2007) | 11 lines
Fix a weird problem where when a caller talking to someone sitting behind an
agent channel sent a digit, the digit would be played to the agent for forever.
This is because chan_agent always returned -1 from its send_digit_begin and _end
callbacks. This non-zero return value indicates to the Asterisk core that it
would like an inband DTMF generator put on the channel. However, this is the
wrong thing to do. It should *always* return 0, instead. When the digit begin
and end functions are called on the proxied channel, the underlying channel
will indicate whether inband DTMF is needed or not, and the generator will be
put on that one, and not the Agent channel.
(issue #9615, #9616, reported by jiddings and BigJimmy, and fixed by me)
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@62219 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2007-04-27 21:11:46 +00:00
return 0 ;
2002-09-02 15:20:28 +00:00
}
2012-02-01 19:53:38 +00:00
static int agent_call ( struct ast_channel * ast , const char * dest , int timeout )
2002-09-02 15:20:28 +00:00
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2002-09-02 15:20:28 +00:00
int res = - 1 ;
2005-01-15 23:31:19 +00:00
int newstate = 0 ;
2011-04-22 21:33:42 +00:00
struct ast_channel * chan ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2003-08-21 16:42:13 +00:00
p - > acknowledged = 0 ;
2011-04-22 21:33:42 +00:00
if ( p - > pending ) {
ast_log ( LOG_DEBUG , " Pretending to dial on pending agent \n " ) ;
ast_mutex_unlock ( & p - > lock ) ;
ast_setstate ( ast , AST_STATE_DIALING ) ;
return 0 ;
}
2003-07-01 16:16:28 +00:00
if ( ! p - > chan ) {
2011-04-22 21:33:42 +00:00
ast_log ( LOG_DEBUG , " Agent disconnected while we were connecting the call \n " ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2003-07-01 16:16:28 +00:00
return res ;
}
2012-01-09 22:15:50 +00:00
ast_verb ( 3 , " agent_call, call to agent '%s' call on '%s' \n " , p - > agent , ast_channel_name ( p - > chan ) ) ;
2012-01-24 20:12:09 +00:00
ast_debug ( 3 , " Playing beep, lang '%s' \n " , ast_channel_language ( p - > chan ) ) ;
2011-04-22 21:33:42 +00:00
chan = p - > chan ;
ast_mutex_unlock ( & p - > lock ) ;
2012-01-24 20:12:09 +00:00
res = ast_streamfile ( chan , beep , ast_channel_language ( chan ) ) ;
2007-06-14 19:39:12 +00:00
ast_debug ( 3 , " Played beep, result '%d' \n " , res ) ;
2003-03-20 17:21:54 +00:00
if ( ! res ) {
2011-04-22 21:33:42 +00:00
res = ast_waitstream ( chan , " " ) ;
2007-06-14 19:39:12 +00:00
ast_debug ( 3 , " Waited for stream, result '%d' \n " , res ) ;
2003-03-20 17:21:54 +00:00
}
2011-04-22 21:33:42 +00:00
ast_mutex_lock ( & p - > lock ) ;
if ( ! p - > chan ) {
/* chan went away while we were streaming, this shouldn't be possible */
res = - 1 ;
}
2002-09-02 15:20:28 +00:00
if ( ! res ) {
2011-02-03 16:22:10 +00:00
struct ast_format tmpfmt ;
2012-02-20 23:43:27 +00:00
res = ast_set_read_format_from_cap ( p - > chan , ast_channel_nativeformats ( p - > chan ) ) ;
2007-06-14 19:39:12 +00:00
ast_debug ( 3 , " Set read format, result '%d' \n " , res ) ;
2002-09-02 15:20:28 +00:00
if ( res )
2011-02-03 16:22:10 +00:00
ast_log ( LOG_WARNING , " Unable to set read format to %s \n " , ast_getformatname ( & tmpfmt ) ) ;
2003-07-01 16:16:28 +00:00
} else {
2004-12-19 21:13:41 +00:00
/* Agent hung-up */
2003-03-20 17:21:54 +00:00
p - > chan = NULL ;
2008-07-25 21:20:03 +00:00
ast_devstate_changed ( AST_DEVICE_UNAVAILABLE , " Agent/%s " , p - > agent ) ;
2003-03-20 17:21:54 +00:00
}
2002-09-02 15:20:28 +00:00
if ( ! res ) {
2011-02-03 16:22:10 +00:00
struct ast_format tmpfmt ;
2012-02-20 23:43:27 +00:00
res = ast_set_write_format_from_cap ( p - > chan , ast_channel_nativeformats ( p - > chan ) ) ;
2007-06-14 19:39:12 +00:00
ast_debug ( 3 , " Set write format, result '%d' \n " , res ) ;
2002-09-02 15:20:28 +00:00
if ( res )
2011-02-03 16:22:10 +00:00
ast_log ( LOG_WARNING , " Unable to set write format to %s \n " , ast_getformatname ( & tmpfmt ) ) ;
2002-09-02 15:20:28 +00:00
}
2006-06-27 20:52:52 +00:00
if ( ! res ) {
2003-08-21 16:42:13 +00:00
/* Call is immediately up, or might need ack */
2009-05-30 01:04:57 +00:00
if ( p - > ackcall ) {
2005-01-15 23:31:19 +00:00
newstate = AST_STATE_RINGING ;
2009-05-30 01:04:57 +00:00
} else {
2005-01-15 23:31:19 +00:00
newstate = AST_STATE_UP ;
2004-02-12 22:28:35 +00:00
if ( recordagentcalls )
2006-06-27 20:52:52 +00:00
agent_start_monitoring ( ast , 0 ) ;
2003-08-21 16:42:13 +00:00
p - > acknowledged = 1 ;
}
res = 0 ;
2003-03-20 17:21:54 +00:00
}
2006-06-27 20:52:52 +00:00
CLEANUP ( ast , p ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2005-01-15 23:31:19 +00:00
if ( newstate )
ast_setstate ( ast , newstate ) ;
2002-09-02 15:20:28 +00:00
return res ;
}
2007-10-01 21:31:16 +00:00
/*! \brief return the channel or base channel if one exists. This function assumes the channel it is called on is already locked */
2007-09-27 23:18:09 +00:00
struct ast_channel * agent_get_base_channel ( struct ast_channel * chan )
{
struct agent_pvt * p = NULL ;
2007-10-01 21:31:16 +00:00
struct ast_channel * base = chan ;
/* chan is locked by the calling function */
2012-02-20 23:43:27 +00:00
if ( ! chan | | ! ast_channel_tech_pvt ( chan ) ) {
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 ) ast_channel_tech_pvt ( chan ) : ( long ) NULL ) ;
2007-10-01 21:31:16 +00:00
return NULL ;
2007-09-27 23:18:09 +00:00
}
2012-02-20 23:43:27 +00:00
p = ast_channel_tech_pvt ( chan ) ;
2007-10-01 21:31:16 +00:00
if ( p - > chan )
base = p - > chan ;
2007-09-27 23:18:09 +00:00
return base ;
}
int agent_set_base_channel ( struct ast_channel * chan , struct ast_channel * base )
{
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 ;
}
2012-02-20 23:43:27 +00:00
p = ast_channel_tech_pvt ( chan ) ;
2007-09-27 23:18:09 +00:00
if ( ! p ) {
2012-01-09 22:15:50 +00:00
ast_log ( LOG_ERROR , " whoa, channel %s is missing his tech_pvt structure!!. \n " , ast_channel_name ( chan ) ) ;
2007-09-27 23:18:09 +00:00
return - 1 ;
}
p - > chan = base ;
return 0 ;
}
2002-09-02 15:20:28 +00:00
static int agent_hangup ( struct ast_channel * ast )
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( ast ) ;
2012-02-03 21:33:23 +00:00
struct ast_channel * indicate_chan = NULL ;
char * tmp_moh ; /* moh buffer for indicating after unlocking p */
if ( p - > pending ) {
AST_LIST_LOCK ( & agents ) ;
AST_LIST_REMOVE ( & agents , p , list ) ;
AST_LIST_UNLOCK ( & agents ) ;
}
2009-05-30 01:04:57 +00:00
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
p - > owner = NULL ;
2012-02-20 23:43:27 +00:00
ast_channel_tech_pvt_set ( ast , NULL ) ;
2002-12-06 16:22:19 +00:00
p - > app_sleep_cond = 1 ;
2003-08-21 16:42:13 +00:00
p - > acknowledged = 0 ;
2004-10-16 15:01:59 +00:00
2011-04-22 21:33:42 +00:00
/* 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 ) ;
2004-10-16 15:01:59 +00:00
/* 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 ( )
*/
2012-02-20 23:43:27 +00:00
ast_debug ( 1 , " Hangup called for state %s \n " , ast_state2str ( ast_channel_state ( ast ) ) ) ;
if ( p - > start & & ( ast_channel_state ( ast ) ! = AST_STATE_UP ) ) {
2004-10-16 15:01:59 +00:00
p - > start = 0 ;
2011-05-03 20:45:32 +00:00
} else
2012-02-03 21:33:23 +00:00
p - > start = 0 ;
2002-09-02 15:20:28 +00:00
if ( p - > chan ) {
2012-03-13 18:20:34 +00:00
ast_channel_internal_bridged_channel_set ( p - > chan , NULL ) ;
2002-09-02 15:20:28 +00:00
/* If they're dead, go ahead and hang up on the agent now */
2009-05-30 01:04:57 +00:00
if ( p - > dead ) {
2002-09-02 15:20:28 +00:00
ast_softhangup ( p - > chan , AST_SOFTHANGUP_EXPLICIT ) ;
2006-07-07 16:16:41 +00:00
} else if ( p - > loginstart ) {
2012-02-03 21:33:23 +00:00
indicate_chan = ast_channel_ref ( p - > chan ) ;
tmp_moh = ast_strdupa ( p - > moh ) ;
2003-07-14 02:31:56 +00:00
}
2003-07-01 16:16:28 +00:00
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2007-02-28 19:00:24 +00:00
2012-02-03 21:33:23 +00:00
if ( indicate_chan ) {
ast_indicate_data ( indicate_chan , AST_CONTROL_HOLD ,
S_OR ( tmp_moh , NULL ) ,
! ast_strlen_zero ( tmp_moh ) ? strlen ( tmp_moh ) + 1 : 0 ) ;
indicate_chan = ast_channel_unref ( indicate_chan ) ;
}
2006-07-07 16:16:41 +00:00
/* Only register a device state change if the agent is still logged in */
2007-02-28 19:00:24 +00:00
if ( ! p - > loginstart ) {
p - > logincallerid [ 0 ] = ' \0 ' ;
} else {
2008-07-25 21:20:03 +00:00
ast_devstate_changed ( AST_DEVICE_NOT_INUSE , " Agent/%s " , p - > agent ) ;
2007-02-28 19:00:24 +00:00
}
2002-12-06 16:22:19 +00:00
2003-07-09 22:41:51 +00:00
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 ) {
2004-06-22 17:42:14 +00:00
ast_mutex_destroy ( & p - > lock ) ;
2009-01-12 20:53:04 +00:00
ast_cond_destroy ( & p - > app_complete_cond ) ;
2011-04-22 21:33:42 +00:00
ast_cond_destroy ( & p - > login_wait_cond ) ;
2007-06-06 21:20:11 +00:00
ast_free ( p ) ;
2003-08-27 15:59:43 +00:00
} else {
if ( p - > chan ) {
/* Not dead -- check availability now */
ast_mutex_lock ( & p - > lock ) ;
/* Store last disconnect time */
2007-07-10 19:07:25 +00:00
p - > lastdisc = ast_tvadd ( ast_tvnow ( ) , ast_samp2tv ( p - > wrapuptime , 1000 ) ) ;
2003-08-27 15:59:43 +00:00
ast_mutex_unlock ( & p - > lock ) ;
}
2003-07-01 16:16:28 +00:00
}
2002-09-02 15:20:28 +00:00
return 0 ;
}
2002-12-06 16:22:19 +00:00
static int agent_cont_sleep ( void * data )
{
struct agent_pvt * p ;
int res ;
p = ( struct agent_pvt * ) data ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2002-12-06 16:22:19 +00:00
res = p - > app_sleep_cond ;
2003-07-28 14:24:10 +00:00
if ( p - > lastdisc . tv_sec ) {
2007-07-10 19:07:25 +00:00
if ( ast_tvdiff_ms ( ast_tvnow ( ) , p - > lastdisc ) > 0 )
2003-07-28 14:24:10 +00:00
res = 1 ;
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2006-06-27 20:52:52 +00:00
2007-06-14 19:39:12 +00:00
if ( ! res )
ast_debug ( 5 , " agent_cont_sleep() returning %d \n " , res ) ;
2006-06-27 20:52:52 +00:00
2002-12-06 16:22:19 +00:00
return res ;
}
2006-06-27 20:52:52 +00:00
static int agent_ack_sleep ( void * data )
2003-08-26 00:36:03 +00:00
{
struct agent_pvt * p ;
2003-08-26 03:50:01 +00:00
int res = 0 ;
2003-08-26 00:36:03 +00:00
int to = 1000 ;
2003-08-26 18:50:46 +00:00
struct ast_frame * f ;
2012-11-07 19:15:26 +00:00
struct timeval start = ast_tvnow ( ) ;
int ms ;
2003-08-26 00:36:03 +00:00
/* Wait a second and look for something */
2006-06-27 20:52:52 +00:00
p = ( struct agent_pvt * ) data ;
if ( ! p - > chan )
return - 1 ;
2012-11-07 19:15:26 +00:00
while ( ( ms = ast_remaining_ms ( start , to ) ) ) {
ms = ast_waitfor ( p - > chan , ms ) ;
if ( ms < 0 ) {
2006-06-27 20:52:52 +00:00
return - 1 ;
2012-11-07 19:15:26 +00:00
}
if ( ms = = 0 ) {
2006-06-27 20:52:52 +00:00
return 0 ;
2012-11-07 19:15:26 +00:00
}
2006-06-27 20:52:52 +00:00
f = ast_read ( p - > chan ) ;
if ( ! f )
return - 1 ;
if ( f - > frametype = = AST_FRAME_DTMF )
2009-11-04 14:05:12 +00:00
res = f - > subclass . integer ;
2006-06-27 20:52:52 +00:00
else
2003-08-26 00:36:03 +00:00
res = 0 ;
2006-06-27 20:52:52 +00:00
ast_frfree ( f ) ;
ast_mutex_lock ( & p - > lock ) ;
if ( ! p - > app_sleep_cond ) {
ast_mutex_unlock ( & p - > lock ) ;
return 0 ;
2008-07-02 20:43:55 +00:00
} else if ( res = = p - > acceptdtmf ) {
2006-06-27 20:52:52 +00:00
ast_mutex_unlock ( & p - > lock ) ;
return 1 ;
2003-08-26 00:36:03 +00:00
}
2006-06-27 20:52:52 +00:00
ast_mutex_unlock ( & p - > lock ) ;
res = 0 ;
}
2012-11-07 19:15:26 +00:00
return 0 ;
2003-08-26 00:36:03 +00:00
}
2004-10-23 12:19:47 +00:00
static struct ast_channel * agent_bridgedchannel ( struct ast_channel * chan , struct ast_channel * bridge )
{
2012-02-20 23:43:27 +00:00
struct agent_pvt * p = ast_channel_tech_pvt ( bridge ) ;
2006-06-27 20:52:52 +00:00
struct ast_channel * ret = NULL ;
2004-10-23 12:19:47 +00:00
Merged revisions 7265-7266,7268-7275 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.2
........
r7265 | oej | 2005-12-01 17:18:14 -0600 (Thu, 01 Dec 2005) | 2 lines
Changing bug report address to the Asterisk issue tracker
........
r7266 | kpfleming | 2005-12-01 17:18:29 -0600 (Thu, 01 Dec 2005) | 3 lines
Makefile 'update' target now supports updating from Subversion repositories (issue #5875)
remove support for 'patches' subdirectory, it's no longer useful
........
r7268 | kpfleming | 2005-12-01 17:34:58 -0600 (Thu, 01 Dec 2005) | 2 lines
ensure channel's scheduling context is freed (issue #5788)
........
r7269 | kpfleming | 2005-12-01 17:49:44 -0600 (Thu, 01 Dec 2005) | 2 lines
don't block waiting for the Festival server forever when it goes away (issue #5882)
........
r7270 | kpfleming | 2005-12-01 18:26:12 -0600 (Thu, 01 Dec 2005) | 2 lines
allow variables to exist on both 'halves' of the Local channel (issue #5810)
........
r7271 | kpfleming | 2005-12-01 18:28:48 -0600 (Thu, 01 Dec 2005) | 2 lines
protect agent_bridgedchannel() from segfaulting when there is no bridged channel (issue #5879)
........
r7272 | kpfleming | 2005-12-01 18:39:00 -0600 (Thu, 01 Dec 2005) | 3 lines
properly handle password changes when mailbox is last line of config file and not followed by a newline (issue #5870)
reformat password changing code to conform to coding guidelines (issue #5870)
........
r7273 | kpfleming | 2005-12-01 18:42:40 -0600 (Thu, 01 Dec 2005) | 2 lines
allow previous context-searching behavior to be used if desired (issue #5899)
........
r7274 | kpfleming | 2005-12-01 18:51:15 -0600 (Thu, 01 Dec 2005) | 2 lines
inherit channel variables into channels created by Page() application (issue #5888)
........
r7275 | oej | 2005-12-01 18:52:13 -0600 (Thu, 01 Dec 2005) | 2 lines
Bug #5907. Improve SIP INFO DTMF debugging output. (1.2 & Trunk)
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7276 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-02 01:01:11 +00:00
if ( p ) {
if ( chan = = p - > chan )
2012-03-13 18:20:34 +00:00
ret = ast_channel_internal_bridged_channel ( bridge ) ;
else if ( chan = = ast_channel_internal_bridged_channel ( bridge ) )
Merged revisions 7265-7266,7268-7275 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.2
........
r7265 | oej | 2005-12-01 17:18:14 -0600 (Thu, 01 Dec 2005) | 2 lines
Changing bug report address to the Asterisk issue tracker
........
r7266 | kpfleming | 2005-12-01 17:18:29 -0600 (Thu, 01 Dec 2005) | 3 lines
Makefile 'update' target now supports updating from Subversion repositories (issue #5875)
remove support for 'patches' subdirectory, it's no longer useful
........
r7268 | kpfleming | 2005-12-01 17:34:58 -0600 (Thu, 01 Dec 2005) | 2 lines
ensure channel's scheduling context is freed (issue #5788)
........
r7269 | kpfleming | 2005-12-01 17:49:44 -0600 (Thu, 01 Dec 2005) | 2 lines
don't block waiting for the Festival server forever when it goes away (issue #5882)
........
r7270 | kpfleming | 2005-12-01 18:26:12 -0600 (Thu, 01 Dec 2005) | 2 lines
allow variables to exist on both 'halves' of the Local channel (issue #5810)
........
r7271 | kpfleming | 2005-12-01 18:28:48 -0600 (Thu, 01 Dec 2005) | 2 lines
protect agent_bridgedchannel() from segfaulting when there is no bridged channel (issue #5879)
........
r7272 | kpfleming | 2005-12-01 18:39:00 -0600 (Thu, 01 Dec 2005) | 3 lines
properly handle password changes when mailbox is last line of config file and not followed by a newline (issue #5870)
reformat password changing code to conform to coding guidelines (issue #5870)
........
r7273 | kpfleming | 2005-12-01 18:42:40 -0600 (Thu, 01 Dec 2005) | 2 lines
allow previous context-searching behavior to be used if desired (issue #5899)
........
r7274 | kpfleming | 2005-12-01 18:51:15 -0600 (Thu, 01 Dec 2005) | 2 lines
inherit channel variables into channels created by Page() application (issue #5888)
........
r7275 | oej | 2005-12-01 18:52:13 -0600 (Thu, 01 Dec 2005) | 2 lines
Bug #5907. Improve SIP INFO DTMF debugging output. (1.2 & Trunk)
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7276 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-02 01:01:11 +00:00
ret = p - > chan ;
}
2012-01-09 22:15:50 +00:00
ast_debug ( 1 , " Asked for bridged channel on '%s'/'%s', returning '%s' \n " , ast_channel_name ( chan ) , ast_channel_name ( bridge ) , ret ? ast_channel_name ( ret ) : " <none> " ) ;
2005-02-01 07:09:56 +00:00
return ret ;
2004-10-23 12:19:47 +00:00
}
2006-06-27 20:52:52 +00:00
/*! \brief Create new agent channel */
2012-06-26 21:45:22 +00:00
static struct ast_channel * agent_new ( struct agent_pvt * p , int state , const char * linkedid , struct ast_callid * callid )
2002-09-02 15:20:28 +00:00
{
struct ast_channel * tmp ;
2003-07-01 16:16:28 +00:00
#if 0
2002-09-02 15:20:28 +00:00
if ( ! p - > chan ) {
ast_log ( LOG_WARNING , " No channel? :( \n " ) ;
return NULL ;
}
2003-07-01 16:16:28 +00:00
# endif
2006-11-07 21:47:49 +00:00
if ( p - > pending )
2012-02-13 17:27:06 +00:00
tmp = ast_channel_alloc ( 0 , state , 0 , 0 , " " , p - > chan ? ast_channel_exten ( p - > chan ) : " " , p - > chan ? ast_channel_context ( p - > chan ) : " " , linkedid , 0 , " Agent/P%s-%d " , p - > agent , ( int ) ast_random ( ) & 0xffff ) ;
2006-11-07 21:47:49 +00:00
else
2012-02-13 17:27:06 +00:00
tmp = ast_channel_alloc ( 0 , state , 0 , 0 , " " , p - > chan ? ast_channel_exten ( p - > chan ) : " " , p - > chan ? ast_channel_context ( p - > chan ) : " " , linkedid , 0 , " Agent/%s " , p - > agent ) ;
2006-06-27 20:52:52 +00:00
if ( ! tmp ) {
ast_log ( LOG_WARNING , " Unable to allocate agent channel structure \n " ) ;
return NULL ;
}
2012-06-26 21:45:22 +00:00
if ( callid ) {
ast_channel_callid_set ( tmp , callid ) ;
}
2012-02-20 23:43:27 +00:00
ast_channel_tech_set ( tmp , & agent_tech ) ;
2006-06-27 20:52:52 +00:00
if ( p - > chan ) {
2012-02-20 23:43:27 +00:00
ast_format_cap_copy ( ast_channel_nativeformats ( tmp ) , ast_channel_nativeformats ( p - > chan ) ) ;
2012-02-24 00:32:20 +00:00
ast_format_copy ( ast_channel_writeformat ( tmp ) , ast_channel_writeformat ( p - > chan ) ) ;
ast_format_copy ( ast_channel_rawwriteformat ( tmp ) , ast_channel_writeformat ( p - > chan ) ) ;
ast_format_copy ( ast_channel_readformat ( tmp ) , ast_channel_readformat ( p - > chan ) ) ;
ast_format_copy ( ast_channel_rawreadformat ( tmp ) , ast_channel_readformat ( p - > chan ) ) ;
2012-01-24 20:12:09 +00:00
ast_channel_language_set ( tmp , ast_channel_language ( p - > chan ) ) ;
2012-02-13 17:27:06 +00:00
ast_channel_context_set ( tmp , ast_channel_context ( p - > chan ) ) ;
ast_channel_exten_set ( tmp , ast_channel_exten ( p - > chan ) ) ;
2006-06-27 20:52:52 +00:00
/* XXX Is this really all we copy form the originating channel?? */
} else {
2012-02-24 00:32:20 +00:00
ast_format_set ( ast_channel_writeformat ( tmp ) , AST_FORMAT_SLINEAR , 0 ) ;
ast_format_set ( ast_channel_rawwriteformat ( tmp ) , AST_FORMAT_SLINEAR , 0 ) ;
ast_format_set ( ast_channel_readformat ( tmp ) , AST_FORMAT_SLINEAR , 0 ) ;
ast_format_set ( ast_channel_rawreadformat ( tmp ) , AST_FORMAT_SLINEAR , 0 ) ;
ast_format_cap_add ( ast_channel_nativeformats ( tmp ) , ast_channel_writeformat ( tmp ) ) ;
2006-06-27 20:52:52 +00:00
}
/* Safe, agentlock already held */
2012-02-20 23:43:27 +00:00
ast_channel_tech_pvt_set ( tmp , p ) ;
2006-06-27 20:52:52 +00:00
p - > owner = tmp ;
2012-02-20 23:43:27 +00:00
ast_channel_priority_set ( tmp , 1 ) ;
2002-09-02 15:20:28 +00:00
return tmp ;
}
2006-06-14 14:46:19 +00:00
/*!
2005-09-07 20:44:57 +00:00
* Read configuration data . The file named agents . conf .
*
2006-06-27 20:52:52 +00:00
* \ returns Always 0 , or so it seems .
2005-09-07 20:44:57 +00:00
*/
2007-08-16 21:09:46 +00:00
static int read_agent_config ( int reload )
2002-09-02 15:20:28 +00:00
{
struct ast_config * cfg ;
2006-09-20 22:09:45 +00:00
struct ast_config * ucfg ;
2002-09-02 15:20:28 +00:00
struct ast_variable * v ;
2006-01-25 18:12:55 +00:00
struct agent_pvt * p ;
2006-09-20 22:09:45 +00:00
const char * catname ;
const char * hasagent ;
int genhasagent ;
2007-08-16 21:09:46 +00:00
struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 } ;
2004-12-31 00:58:44 +00:00
2003-07-01 04:08:25 +00:00
group = 0 ;
2003-07-22 11:06:56 +00:00
autologoff = 0 ;
2003-07-28 14:24:10 +00:00
wrapuptime = 0 ;
2005-02-14 23:20:01 +00:00
ackcall = 0 ;
2006-04-15 22:32:23 +00:00
endcall = 1 ;
2007-08-16 21:09:46 +00:00
cfg = ast_config_load ( config , config_flags ) ;
2002-09-02 15:20:28 +00:00
if ( ! cfg ) {
ast_log ( LOG_NOTICE , " No agent configuration found -- agent support disabled \n " ) ;
return 0 ;
2008-09-12 23:30:03 +00:00
} else if ( cfg = = CONFIG_STATUS_FILEUNCHANGED ) {
2007-08-16 21:09:46 +00:00
return - 1 ;
2008-09-12 23:30:03 +00:00
} 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 ;
}
}
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2002-09-02 15:20:28 +00:00
p - > dead = 1 ;
}
2005-08-26 20:24:16 +00:00
strcpy ( moh , " default " ) ;
2004-02-03 16:57:00 +00:00
/* set the default recording values */
recordagentcalls = 0 ;
2005-08-26 20:24:16 +00:00
strcpy ( recordformat , " wav " ) ;
strcpy ( recordformatext , " wav " ) ;
2004-07-16 04:40:54 +00:00
urlprefix [ 0 ] = ' \0 ' ;
savecallsin [ 0 ] = ' \0 ' ;
2004-02-03 16:57:00 +00:00
2005-01-01 00:57:04 +00:00
/* Read in the [agents] section */
2002-09-02 15:20:28 +00:00
v = ast_variable_browse ( cfg , " agents " ) ;
while ( v ) {
/* Create the interface list */
if ( ! strcasecmp ( v - > name , " agent " ) ) {
2003-07-01 16:16:28 +00:00
add_agent ( v - > value , 0 ) ;
2003-07-01 04:08:25 +00:00
} else if ( ! strcasecmp ( v - > name , " group " ) ) {
group = ast_get_group ( v - > value ) ;
2003-07-22 11:06:56 +00:00
} else if ( ! strcasecmp ( v - > name , " autologoff " ) ) {
autologoff = atoi ( v - > value ) ;
if ( autologoff < 0 )
autologoff = 0 ;
2003-08-05 23:57:55 +00:00
} else if ( ! strcasecmp ( v - > name , " ackcall " ) ) {
2009-05-30 01:04:57 +00:00
if ( ast_true ( v - > value ) | | ! strcasecmp ( v - > value , " always " ) ) {
2004-12-31 00:58:44 +00:00
ackcall = 1 ;
2009-05-30 01:04:57 +00:00
}
2006-04-15 22:32:23 +00:00
} else if ( ! strcasecmp ( v - > name , " endcall " ) ) {
endcall = ast_true ( v - > value ) ;
2008-07-02 20:43:55 +00:00
} 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 ) ;
2003-07-28 14:24:10 +00:00
} else if ( ! strcasecmp ( v - > name , " wrapuptime " ) ) {
wrapuptime = atoi ( v - > value ) ;
if ( wrapuptime < 0 )
wrapuptime = 0 ;
2004-10-24 13:24:16 +00:00
} 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 ) ;
2002-09-02 15:20:28 +00:00
} else if ( ! strcasecmp ( v - > name , " musiconhold " ) ) {
2005-08-26 20:24:16 +00:00
ast_copy_string ( moh , v - > value , sizeof ( moh ) ) ;
2004-04-03 00:41:47 +00:00
} else if ( ! strcasecmp ( v - > name , " updatecdr " ) ) {
2004-10-24 13:24:16 +00:00
if ( ast_true ( v - > value ) )
updatecdr = 1 ;
else
updatecdr = 0 ;
2006-01-13 18:23:30 +00:00
} else if ( ! strcasecmp ( v - > name , " autologoffunavail " ) ) {
if ( ast_true ( v - > value ) )
autologoffunavail = 1 ;
else
autologoffunavail = 0 ;
2004-02-03 16:57:00 +00:00
} else if ( ! strcasecmp ( v - > name , " recordagentcalls " ) ) {
recordagentcalls = ast_true ( v - > value ) ;
} else if ( ! strcasecmp ( v - > name , " recordformat " ) ) {
2005-08-26 20:24:16 +00:00
ast_copy_string ( recordformat , v - > value , sizeof ( recordformat ) ) ;
2008-10-09 21:47:02 +00:00
if ( ! strcasecmp ( v - > value , " wav49 " ) )
2005-08-26 20:24:16 +00:00
strcpy ( recordformatext , " WAV " ) ;
2008-10-09 21:47:02 +00:00
else
2005-08-26 20:24:16 +00:00
ast_copy_string ( recordformatext , v - > value , sizeof ( recordformatext ) ) ;
2004-02-03 16:57:00 +00:00
} else if ( ! strcasecmp ( v - > name , " urlprefix " ) ) {
2005-08-26 20:24:16 +00:00
ast_copy_string ( urlprefix , v - > value , sizeof ( urlprefix ) ) ;
2004-02-03 16:57:00 +00:00
if ( urlprefix [ strlen ( urlprefix ) - 1 ] ! = ' / ' )
2004-07-16 04:40:54 +00:00
strncat ( urlprefix , " / " , sizeof ( urlprefix ) - strlen ( urlprefix ) - 1 ) ;
2004-02-03 16:57:00 +00:00
} else if ( ! strcasecmp ( v - > name , " savecallsin " ) ) {
if ( v - > value [ 0 ] = = ' / ' )
2005-08-26 20:24:16 +00:00
ast_copy_string ( savecallsin , v - > value , sizeof ( savecallsin ) ) ;
2004-02-03 16:57:00 +00:00
else
snprintf ( savecallsin , sizeof ( savecallsin ) - 2 , " /%s " , v - > value ) ;
if ( savecallsin [ strlen ( savecallsin ) - 1 ] ! = ' / ' )
2004-07-16 04:40:54 +00:00
strncat ( savecallsin , " / " , sizeof ( savecallsin ) - strlen ( savecallsin ) - 1 ) ;
2004-06-28 18:40:41 +00:00
} else if ( ! strcasecmp ( v - > name , " custom_beep " ) ) {
2005-08-26 20:24:16 +00:00
ast_copy_string ( beep , v - > value , sizeof ( beep ) ) ;
2002-09-02 15:20:28 +00:00
}
v = v - > next ;
}
2008-09-12 23:30:03 +00:00
if ( ucfg ) {
2006-09-20 22:09:45 +00:00
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 ) ;
}
2006-01-25 18:12:55 +00:00
AST_LIST_TRAVERSE_SAFE_BEGIN ( & agents , p , list ) {
2002-09-02 15:20:28 +00:00
if ( p - > dead ) {
2007-11-08 05:28:47 +00:00
AST_LIST_REMOVE_CURRENT ( list ) ;
2002-09-02 15:20:28 +00:00
/* Destroy if appropriate */
if ( ! p - > owner ) {
if ( ! p - > chan ) {
2004-06-22 17:42:14 +00:00
ast_mutex_destroy ( & p - > lock ) ;
2009-01-12 20:53:04 +00:00
ast_cond_destroy ( & p - > app_complete_cond ) ;
2011-04-22 21:33:42 +00:00
ast_cond_destroy ( & p - > login_wait_cond ) ;
2007-06-06 21:20:11 +00:00
ast_free ( p ) ;
2002-09-02 15:20:28 +00:00
} else {
/* Cause them to hang up */
ast_softhangup ( p - > chan , AST_SOFTHANGUP_EXPLICIT ) ;
}
}
2006-01-25 18:12:55 +00:00
}
2002-09-02 15:20:28 +00:00
}
2007-11-08 05:28:47 +00:00
AST_LIST_TRAVERSE_SAFE_END ;
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2005-01-25 06:10:20 +00:00
ast_config_destroy ( cfg ) ;
2006-08-31 21:00:20 +00:00
return 1 ;
2002-09-02 15:20:28 +00:00
}
2003-07-01 16:16:28 +00:00
static int check_availability ( struct agent_pvt * newlyavailable , int needlock )
{
struct ast_channel * chan = NULL , * parent = NULL ;
struct agent_pvt * p ;
int res ;
2004-12-31 00:58:44 +00:00
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Checking availability of '%s' \n " , newlyavailable - > agent ) ;
2003-07-01 16:16:28 +00:00
if ( needlock )
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2003-07-01 16:16:28 +00:00
if ( p = = newlyavailable ) {
continue ;
}
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2003-07-16 02:25:53 +00:00
if ( ! p - > abouttograb & & p - > pending & & ( ( p - > group & & ( newlyavailable - > group & p - > group ) ) | | ! strcmp ( p - > agent , newlyavailable - > agent ) ) ) {
2012-01-09 22:15:50 +00:00
ast_debug ( 1 , " Call '%s' looks like a winner for agent '%s' \n " , ast_channel_name ( p - > owner ) , newlyavailable - > agent ) ;
2003-07-01 16:16:28 +00:00
/* We found a pending call, time to merge */
2012-06-26 21:45:22 +00:00
chan = agent_new ( newlyavailable , AST_STATE_DOWN , p - > owner ? ast_channel_linkedid ( p - > owner ) : NULL , NULL ) ;
2003-07-01 16:16:28 +00:00
parent = p - > owner ;
2003-07-09 22:41:51 +00:00
p - > abouttograb = 1 ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2003-07-01 16:16:28 +00:00
break ;
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2003-07-01 16:16:28 +00:00
}
if ( needlock )
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2003-07-01 16:16:28 +00:00
if ( parent & & chan ) {
2009-05-30 01:04:57 +00:00
if ( newlyavailable - > ackcall ) {
2003-08-26 00:36:03 +00:00
/* Don't do beep here */
res = 0 ;
} else {
2012-01-24 20:12:09 +00:00
ast_debug ( 3 , " Playing beep, lang '%s' \n " , ast_channel_language ( newlyavailable - > chan ) ) ;
res = ast_streamfile ( newlyavailable - > chan , beep , ast_channel_language ( newlyavailable - > chan ) ) ;
2007-06-14 19:39:12 +00:00
ast_debug ( 3 , " Played beep, result '%d' \n " , res ) ;
2003-08-26 00:36:03 +00:00
if ( ! res ) {
res = ast_waitstream ( newlyavailable - > chan , " " ) ;
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Waited for stream, result '%d' \n " , res ) ;
2003-08-26 00:36:03 +00:00
}
2003-07-01 16:16:28 +00:00
}
if ( ! res ) {
2003-07-09 22:41:51 +00:00
/* Note -- parent may have disappeared */
if ( p - > abouttograb ) {
2003-09-06 20:13:09 +00:00
newlyavailable - > acknowledged = 1 ;
2005-01-15 23:31:19 +00:00
/* Safe -- agent lock already held */
2003-07-09 22:41:51 +00:00
ast_setstate ( parent , AST_STATE_UP ) ;
ast_setstate ( chan , AST_STATE_UP ) ;
2012-02-13 17:27:06 +00:00
ast_channel_context_set ( parent , ast_channel_context ( chan ) ) ;
2003-07-09 22:41:51 +00:00
ast_channel_masquerade ( parent , chan ) ;
2011-08-31 15:25:35 +00:00
ast_hangup ( chan ) ;
2003-07-09 22:41:51 +00:00
p - > abouttograb = 0 ;
} else {
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Sneaky, parent disappeared in the mean time... \n " ) ;
2003-07-09 22:41:51 +00:00
agent_cleanup ( newlyavailable ) ;
}
2003-07-01 16:16:28 +00:00
} else {
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Ugh... Agent hung up at exactly the wrong time \n " ) ;
2003-07-09 22:41:51 +00:00
agent_cleanup ( newlyavailable ) ;
2003-07-01 16:16:28 +00:00
}
}
return 0 ;
}
2003-08-26 00:36:03 +00:00
static int check_beep ( struct agent_pvt * newlyavailable , int needlock )
{
struct agent_pvt * p ;
2003-08-26 03:17:00 +00:00
int res = 0 ;
2004-12-31 00:58:44 +00:00
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Checking beep availability of '%s' \n " , newlyavailable - > agent ) ;
2003-08-26 00:36:03 +00:00
if ( needlock )
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2003-08-26 00:36:03 +00:00
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 ) ) ) {
2012-01-09 22:15:50 +00:00
ast_debug ( 1 , " Call '%s' looks like a would-be winner for agent '%s' \n " , ast_channel_name ( p - > owner ) , newlyavailable - > agent ) ;
2003-08-26 00:36:03 +00:00
ast_mutex_unlock ( & p - > lock ) ;
break ;
}
ast_mutex_unlock ( & p - > lock ) ;
}
if ( needlock )
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2003-08-26 00:36:03 +00:00
if ( p ) {
2003-08-26 04:08:12 +00:00
ast_mutex_unlock ( & newlyavailable - > lock ) ;
2012-01-24 20:12:09 +00:00
ast_debug ( 3 , " Playing beep, lang '%s' \n " , ast_channel_language ( newlyavailable - > chan ) ) ;
res = ast_streamfile ( newlyavailable - > chan , beep , ast_channel_language ( newlyavailable - > chan ) ) ;
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Played beep, result '%d' \n " , res ) ;
2003-08-26 00:36:03 +00:00
if ( ! res ) {
res = ast_waitstream ( newlyavailable - > chan , " " ) ;
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Waited for stream, result '%d' \n " , res ) ;
2003-08-26 00:36:03 +00:00
}
2003-08-26 04:08:12 +00:00
ast_mutex_lock ( & newlyavailable - > lock ) ;
2003-08-26 00:36:03 +00:00
}
return res ;
}
2006-06-27 20:52:52 +00:00
/*! \brief Part of the Asterisk PBX interface */
2012-02-01 19:53:38 +00:00
static struct ast_channel * agent_request ( const char * type , struct ast_format_cap * cap , const struct ast_channel * requestor , const char * data , int * cause )
2002-09-02 15:20:28 +00:00
{
struct agent_pvt * p ;
struct ast_channel * chan = NULL ;
2012-02-01 19:53:38 +00:00
const char * s ;
2005-01-15 21:51:38 +00:00
ast_group_t groupmatch ;
2005-01-17 04:47:01 +00:00
int groupoff ;
2003-07-01 16:16:28 +00:00
int waitforagent = 0 ;
2003-08-19 01:01:00 +00:00
int hasagent = 0 ;
2008-08-09 12:53:57 +00:00
struct timeval now ;
2012-06-26 21:45:22 +00:00
struct ast_callid * callid = ast_read_threadstorage_callid ( ) ;
2004-12-31 00:58:44 +00:00
2003-07-01 04:08:25 +00:00
s = data ;
2009-08-10 19:20:57 +00:00
if ( ( s [ 0 ] = = ' @ ' ) & & ( sscanf ( s + 1 , " %30d " , & groupoff ) = = 1 ) ) {
2005-01-17 04:47:01 +00:00
groupmatch = ( 1 < < groupoff ) ;
2009-08-10 19:20:57 +00:00
} else if ( ( s [ 0 ] = = ' : ' ) & & ( sscanf ( s + 1 , " %30d " , & groupoff ) = = 1 ) ) {
2005-01-17 04:47:01 +00:00
groupmatch = ( 1 < < groupoff ) ;
2003-07-01 16:16:28 +00:00
waitforagent = 1 ;
2006-06-27 20:52:52 +00:00
} else
2003-07-01 04:08:25 +00:00
groupmatch = 0 ;
2003-08-06 04:00:37 +00:00
/* Check actual logged in agents first */
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2009-05-30 01:04:57 +00:00
if ( ! p - > pending & & ( ( groupmatch & & ( p - > group & groupmatch ) ) | | ! strcmp ( data , p - > agent ) ) ) {
2012-12-14 23:17:59 +00:00
if ( p - > chan ) {
2003-08-19 01:01:00 +00:00
hasagent + + ;
2012-12-14 23:17:59 +00:00
}
2008-08-09 12:53:57 +00:00
now = ast_tvnow ( ) ;
if ( ! p - > lastdisc . tv_sec | | ( now . tv_sec > = p - > lastdisc . tv_sec ) ) {
2007-07-10 19:07:25 +00:00
p - > lastdisc = ast_tv ( 0 , 0 ) ;
2003-08-19 01:01:00 +00:00
/* Agent must be registered, but not have any active call, and not be in a waiting state */
if ( ! p - > owner & & p - > chan ) {
/* Fixed agent */
2012-06-26 21:45:22 +00:00
chan = agent_new ( p , AST_STATE_DOWN , requestor ? ast_channel_linkedid ( requestor ) : NULL , callid ) ;
2003-08-19 01:01:00 +00:00
}
if ( chan ) {
ast_mutex_unlock ( & p - > lock ) ;
break ;
}
2002-09-02 15:20:28 +00:00
}
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
}
2003-08-06 04:00:37 +00:00
2003-07-01 16:16:28 +00:00
if ( ! chan & & waitforagent ) {
/* No agent available -- but we're requesting to wait for one.
Allocate a place holder */
2003-08-19 01:01:00 +00:00
if ( hasagent ) {
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Creating place holder for '%s' \n " , s ) ;
2003-08-19 01:01:00 +00:00
p = add_agent ( data , 1 ) ;
p - > group = groupmatch ;
2012-06-26 21:45:22 +00:00
chan = agent_new ( p , AST_STATE_DOWN , requestor ? ast_channel_linkedid ( requestor ) : NULL , callid ) ;
2006-06-27 20:52:52 +00:00
if ( ! chan )
2003-08-19 01:01:00 +00:00
ast_log ( LOG_WARNING , " Weird... Fix this to drop the unused pending agent \n " ) ;
2006-10-03 15:53:07 +00:00
} else {
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Not creating place holder for '%s' since nobody logged in \n " , s ) ;
2006-10-03 15:53:07 +00:00
}
2003-07-01 16:16:28 +00:00
}
2006-06-27 20:52:52 +00:00
* cause = hasagent ? AST_CAUSE_BUSY : AST_CAUSE_UNREGISTERED ;
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2011-04-22 21:33:42 +00:00
2012-06-26 21:45:22 +00:00
if ( callid ) {
callid = ast_callid_unref ( callid ) ;
}
2011-04-22 21:33:42 +00:00
if ( chan ) {
ast_mutex_lock ( & p - > lock ) ;
if ( p - > pending ) {
ast_mutex_unlock ( & p - > lock ) ;
return chan ;
}
if ( ! p - > chan ) {
ast_log ( LOG_DEBUG , " Agent disconnected while we were connecting the call \n " ) ;
* cause = AST_CAUSE_UNREGISTERED ;
ast_mutex_unlock ( & p - > lock ) ;
agent_hangup ( chan ) ;
return NULL ;
}
/* we need to take control of the channel from the login app
* thread */
p - > app_sleep_cond = 0 ;
p - > app_lock_flag = 1 ;
ast_queue_frame ( p - > chan , & ast_null_frame ) ;
ast_cond_wait ( & p - > login_wait_cond , & p - > lock ) ;
if ( ! p - > chan ) {
ast_log ( LOG_DEBUG , " Agent disconnected while we were connecting the call \n " ) ;
p - > app_sleep_cond = 1 ;
p - > app_lock_flag = 0 ;
ast_cond_signal ( & p - > app_complete_cond ) ;
ast_mutex_unlock ( & p - > lock ) ;
* cause = AST_CAUSE_UNREGISTERED ;
agent_hangup ( chan ) ;
return NULL ;
}
ast_indicate ( p - > chan , AST_CONTROL_UNHOLD ) ;
ast_mutex_unlock ( & p - > lock ) ;
}
2002-09-02 15:20:28 +00:00
return chan ;
}
2006-06-13 20:59:15 +00:00
static force_inline int powerof ( unsigned int d )
2003-07-01 16:16:28 +00:00
{
2006-06-13 20:59:15 +00:00
int x = ffs ( d ) ;
if ( x )
return x - 1 ;
2003-07-01 16:16:28 +00:00
return 0 ;
}
2006-06-14 14:46:19 +00:00
/*!
2005-09-14 02:12:37 +00:00
* Lists agents and their status to the Manager API .
* It is registered on load_module ( ) and it gets called by the manager backend .
2012-02-03 21:33:23 +00:00
* This function locks both the pvt and the channel that owns it for a while , but
* does not keep these locks .
2006-06-14 14:46:19 +00:00
* \ param s
* \ param m
2006-06-27 20:52:52 +00:00
* \ returns
2007-06-12 13:34:57 +00:00
* \ sa action_agent_logoff ( ) , load_module ( ) .
2005-09-14 02:12:37 +00:00
*/
2007-01-05 22:43:18 +00:00
static int action_agents ( struct mansession * s , const struct message * m )
2004-12-01 05:00:29 +00:00
{
2007-01-05 22:43:18 +00:00
const char * id = astman_get_header ( m , " ActionID " ) ;
2005-07-15 16:21:41 +00:00
char idText [ 256 ] = " " ;
2004-12-31 00:58:44 +00:00
struct agent_pvt * p ;
char * username = NULL ;
char * loginChan = NULL ;
2007-08-06 23:00:35 +00:00
char * talkingto = NULL ;
2004-12-31 00:58:44 +00:00
char * talkingtoChan = NULL ;
char * status = NULL ;
2011-09-15 08:40:07 +00:00
struct ast_channel * bridge ;
2004-12-31 00:58:44 +00:00
2005-10-27 02:19:37 +00:00
if ( ! ast_strlen_zero ( id ) )
2005-07-15 16:21:41 +00:00
snprintf ( idText , sizeof ( idText ) , " ActionID: %s \r \n " , id ) ;
astman_send_ack ( s , m , " Agents will follow " ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2012-02-03 21:33:23 +00:00
struct ast_channel * owner ;
ast_mutex_lock ( & p - > lock ) ;
owner = agent_lock_owner ( p ) ;
2004-12-31 00:58:44 +00:00
/* Status Values:
2005-09-14 00:28:06 +00:00
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 . */
2004-12-31 00:58:44 +00:00
2006-06-27 20:52:52 +00:00
username = S_OR ( p - > name , " None " ) ;
2004-12-31 00:58:44 +00:00
/* Set a default status. It 'should' get changed. */
status = " AGENT_UNKNOWN " ;
2009-05-30 01:04:57 +00:00
if ( p - > chan ) {
2012-01-09 22:15:50 +00:00
loginChan = ast_strdupa ( ast_channel_name ( p - > chan ) ) ;
2012-03-13 18:20:34 +00:00
if ( owner & & ast_channel_internal_bridged_channel ( owner ) ) {
2012-02-29 16:52:47 +00:00
talkingto = S_COR ( ast_channel_caller ( p - > chan ) - > id . number . valid ,
ast_channel_caller ( p - > chan ) - > id . number . str , " n/a " ) ;
2012-02-03 21:33:23 +00:00
if ( ( bridge = ast_bridged_channel ( owner ) ) ) {
2012-01-09 22:15:50 +00:00
talkingtoChan = ast_strdupa ( ast_channel_name ( bridge ) ) ;
2011-09-15 08:40:07 +00:00
} else {
2007-08-06 23:00:35 +00:00
talkingtoChan = " n/a " ;
2011-09-15 08:40:07 +00:00
}
2010-07-14 15:48:36 +00:00
status = " AGENT_ONCALL " ;
2005-10-13 21:59:25 +00:00
} else {
2007-08-06 23:00:35 +00:00
talkingto = " n/a " ;
talkingtoChan = " n/a " ;
2010-07-14 15:48:36 +00:00
status = " AGENT_IDLE " ;
2005-10-13 21:59:25 +00:00
}
2004-12-31 00:58:44 +00:00
} else {
loginChan = " n/a " ;
2007-08-06 23:00:35 +00:00
talkingto = " n/a " ;
2004-12-31 00:58:44 +00:00
talkingtoChan = " n/a " ;
status = " AGENT_LOGGEDOFF " ;
}
2012-02-03 21:33:23 +00:00
if ( owner ) {
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
}
2006-03-25 23:50:09 +00:00
astman_append ( s , " Event: Agents \r \n "
2005-09-14 00:28:06 +00:00
" Agent: %s \r \n "
" Name: %s \r \n "
" Status: %s \r \n "
" LoggedInChan: %s \r \n "
2005-12-26 18:35:28 +00:00
" LoggedInTime: %d \r \n "
2005-09-14 00:28:06 +00:00
" TalkingTo: %s \r \n "
2007-08-06 23:00:35 +00:00
" TalkingToChan: %s \r \n "
2005-09-14 00:28:06 +00:00
" %s "
" \r \n " ,
2007-08-06 23:00:35 +00:00
p - > agent , username , status , loginChan , ( int ) p - > loginstart , talkingto , talkingtoChan , idText ) ;
2004-12-31 00:58:44 +00:00
ast_mutex_unlock ( & p - > lock ) ;
}
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2006-03-25 23:50:09 +00:00
astman_append ( s , " Event: AgentsComplete \r \n "
2005-09-14 00:28:06 +00:00
" %s "
" \r \n " , idText ) ;
2004-12-31 00:58:44 +00:00
return 0 ;
2004-12-01 05:00:29 +00:00
}
2007-01-05 22:43:18 +00:00
static int agent_logoff ( const char * agent , int soft )
2005-01-30 06:55:10 +00:00
{
struct agent_pvt * p ;
2005-08-26 20:24:16 +00:00
int ret = - 1 ; /* Return -1 if no agent if found */
2005-01-30 06:55:10 +00:00
2008-01-31 19:20:52 +00:00
AST_LIST_LOCK ( & agents ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_TRAVERSE ( & agents , p , list ) {
2005-01-30 06:55:10 +00:00
if ( ! strcasecmp ( p - > agent , agent ) ) {
2007-02-20 22:49:53 +00:00
ret = 0 ;
if ( p - > owner | | p - > chan ) {
if ( ! soft ) {
2012-02-03 21:33:23 +00:00
struct ast_channel * owner ;
2008-02-25 18:38:51 +00:00
ast_mutex_lock ( & p - > lock ) ;
2012-02-03 21:33:23 +00:00
owner = agent_lock_owner ( p ) ;
2008-02-25 18:38:51 +00:00
2012-02-03 21:33:23 +00:00
if ( owner ) {
ast_softhangup ( owner , AST_SOFTHANGUP_EXPLICIT ) ;
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
2008-02-25 18:38:51 +00:00
}
while ( p - > chan & & ast_channel_trylock ( p - > chan ) ) {
2008-05-29 17:35:19 +00:00
DEADLOCK_AVOIDANCE ( & p - > lock ) ;
2008-02-25 18:38:51 +00:00
}
if ( p - > chan ) {
2007-02-20 22:49:53 +00:00
ast_softhangup ( p - > chan , AST_SOFTHANGUP_EXPLICIT ) ;
2008-02-25 18:38:51 +00:00
ast_channel_unlock ( p - > chan ) ;
}
ast_mutex_unlock ( & p - > lock ) ;
2007-07-12 23:02:33 +00:00
} else
p - > deferlogoff = 1 ;
2005-01-30 06:55:10 +00:00
}
break ;
}
}
2008-01-31 19:20:52 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2005-08-26 20:24:16 +00:00
return ret ;
}
2007-09-18 22:43:45 +00:00
static char * agent_logoff_cmd ( struct ast_cli_entry * e , int cmd , struct ast_cli_args * a )
2005-08-26 20:24:16 +00:00
{
int ret ;
2009-05-21 21:13:09 +00:00
const char * agent ;
2005-08-26 20:24:16 +00:00
2007-09-18 22:43:45 +00:00
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 ;
2005-08-26 20:24:16 +00:00
2007-09-18 22:43:45 +00:00
agent = a - > argv [ 2 ] + 6 ;
ret = agent_logoff ( agent , a - > argc = = 4 ) ;
2005-08-26 20:24:16 +00:00
if ( ret = = 0 )
2007-09-18 22:43:45 +00:00
ast_cli ( a - > fd , " Logging out %s \n " , agent ) ;
2005-08-26 20:24:16 +00:00
2007-09-18 22:43:45 +00:00
return CLI_SUCCESS ;
2005-01-30 06:55:10 +00:00
}
2006-06-14 14:46:19 +00:00
/*!
2005-09-14 02:12:37 +00:00
* 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 .
2006-06-14 14:46:19 +00:00
* \ param s
* \ param m
2006-06-27 20:52:52 +00:00
* \ returns
2007-06-12 13:34:57 +00:00
* \ sa action_agents ( ) , load_module ( ) .
2005-09-14 02:12:37 +00:00
*/
2007-01-05 22:43:18 +00:00
static int action_agent_logoff ( struct mansession * s , const struct message * m )
2005-08-26 20:24:16 +00:00
{
2007-01-05 22:43:18 +00:00
const char * agent = astman_get_header ( m , " Agent " ) ;
const char * soft_s = astman_get_header ( m , " Soft " ) ; /* "true" is don't hangup */
2005-08-26 20:24:16 +00:00
int soft ;
int ret ; /* return value of agent_logoff */
2005-10-27 02:19:37 +00:00
if ( ast_strlen_zero ( agent ) ) {
2005-08-26 20:24:16 +00:00
astman_send_error ( s , m , " No agent specified " ) ;
return 0 ;
}
2006-06-27 20:52:52 +00:00
soft = ast_true ( soft_s ) ? 1 : 0 ;
2005-08-26 20:24:16 +00:00
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 ;
}
2006-01-18 22:17:31 +00:00
static char * complete_agent_logoff_cmd ( const char * line , const char * word , int pos , int state )
2005-01-30 06:55:10 +00:00
{
2008-01-31 19:20:52 +00:00
char * ret = NULL ;
2005-01-30 06:55:10 +00:00
if ( pos = = 2 ) {
2006-03-28 13:46:04 +00:00
struct agent_pvt * p ;
char name [ AST_MAX_AGENT ] ;
int which = 0 , len = strlen ( word ) ;
2008-01-31 19:20:52 +00:00
AST_LIST_LOCK ( & agents ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_TRAVERSE ( & agents , p , list ) {
2005-01-30 06:55:10 +00:00
snprintf ( name , sizeof ( name ) , " Agent/%s " , p - > agent ) ;
2008-01-31 19:20:52 +00:00
if ( ! strncasecmp ( word , name , len ) & & p - > loginstart & & + + which > state ) {
ret = ast_strdup ( name ) ;
break ;
}
2005-01-30 06:55:10 +00:00
}
2008-01-31 19:20:52 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2006-06-27 20:52:52 +00:00
} else if ( pos = = 3 & & state = = 0 )
2006-01-11 01:20:29 +00:00
return ast_strdup ( " soft " ) ;
2006-06-27 20:52:52 +00:00
2008-01-31 19:20:52 +00:00
return ret ;
2005-01-30 06:55:10 +00:00
}
2004-12-01 05:00:29 +00:00
2006-06-14 14:46:19 +00:00
/*!
2005-09-07 20:44:57 +00:00
* Show agents in cli .
*/
2007-09-18 22:43:45 +00:00
static char * agents_show ( struct ast_cli_entry * e , int cmd , struct ast_cli_args * a )
2002-09-02 15:20:28 +00:00
{
struct agent_pvt * p ;
2004-02-03 16:57:00 +00:00
char username [ AST_MAX_BUF ] ;
2004-07-16 04:40:54 +00:00
char location [ AST_MAX_BUF ] = " " ;
char talkingto [ AST_MAX_BUF ] = " " ;
2008-08-09 12:53:57 +00:00
char music [ AST_MAX_BUF ] ;
2006-06-27 20:52:52 +00:00
int count_agents = 0 ; /*!< Number of agents configured */
int online_agents = 0 ; /*!< Number of online agents */
int offline_agents = 0 ; /*!< Number of offline agents */
2007-09-18 22:43:45 +00:00
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 ;
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2012-02-03 21:33:23 +00:00
struct ast_channel * owner ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2012-02-03 21:33:23 +00:00
owner = agent_lock_owner ( p ) ;
2003-07-01 16:16:28 +00:00
if ( p - > pending ) {
if ( p - > group )
2007-09-18 22:43:45 +00:00
ast_cli ( a - > fd , " -- Pending call to group %d \n " , powerof ( p - > group ) ) ;
2003-07-01 16:16:28 +00:00
else
2007-09-18 22:43:45 +00:00
ast_cli ( a - > fd , " -- Pending call to agent %s \n " , p - > agent ) ;
2003-07-01 16:16:28 +00:00
} else {
2004-05-09 07:51:44 +00:00
if ( ! ast_strlen_zero ( p - > name ) )
2003-07-01 16:16:28 +00:00
snprintf ( username , sizeof ( username ) , " (%s) " , p - > name ) ;
else
2004-07-16 04:40:54 +00:00
username [ 0 ] = ' \0 ' ;
2003-07-01 16:16:28 +00:00
if ( p - > chan ) {
2012-01-09 22:15:50 +00:00
snprintf ( location , sizeof ( location ) , " logged in on %s " , ast_channel_name ( p - > chan ) ) ;
2012-02-03 21:33:23 +00:00
if ( owner & & ast_bridged_channel ( owner ) ) {
2012-01-09 22:15:50 +00:00
snprintf ( talkingto , sizeof ( talkingto ) , " talking to %s " , ast_channel_name ( ast_bridged_channel ( p - > owner ) ) ) ;
2012-02-03 21:33:23 +00:00
} else {
2005-08-26 20:24:16 +00:00
strcpy ( talkingto , " is idle " ) ;
2012-02-03 21:33:23 +00:00
}
2005-05-15 02:48:16 +00:00
online_agents + + ;
2002-09-02 15:20:28 +00:00
} else {
2005-08-26 20:24:16 +00:00
strcpy ( location , " not logged in " ) ;
2004-07-16 04:40:54 +00:00
talkingto [ 0 ] = ' \0 ' ;
2005-05-15 02:48:16 +00:00
offline_agents + + ;
2002-09-02 15:20:28 +00:00
}
2004-05-09 07:51:44 +00:00
if ( ! ast_strlen_zero ( p - > moh ) )
2008-08-09 12:53:57 +00:00
snprintf ( music , sizeof ( music ) , " (musiconhold is '%s') " , p - > moh ) ;
2007-09-18 22:43:45 +00:00
ast_cli ( a - > fd , " %-12.12s %s%s%s%s \n " , p - > agent ,
2008-08-09 12:53:57 +00:00
username , location , talkingto , music ) ;
2005-05-15 02:48:16 +00:00
count_agents + + ;
2002-09-02 15:20:28 +00:00
}
2012-02-03 21:33:23 +00:00
if ( owner ) {
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
}
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2006-06-27 20:52:52 +00:00
if ( ! count_agents )
2007-09-18 22:43:45 +00:00
ast_cli ( a - > fd , " No Agents are configured in %s \n " , config ) ;
2006-06-27 20:52:52 +00:00
else
2007-09-18 22:43:45 +00:00
ast_cli ( a - > fd , " %d agents configured [%d online , %d offline] \n " , count_agents , online_agents , offline_agents ) ;
ast_cli ( a - > fd , " \n " ) ;
2005-07-25 16:53:28 +00:00
2007-09-18 22:43:45 +00:00
return CLI_SUCCESS ;
2002-09-02 15:20:28 +00:00
}
2006-05-08 11:08:38 +00:00
2007-09-18 22:43:45 +00:00
static char * agents_show_online ( struct ast_cli_entry * e , int cmd , struct ast_cli_args * a )
2006-05-08 11:08:38 +00:00
{
struct agent_pvt * p ;
char username [ AST_MAX_BUF ] ;
char location [ AST_MAX_BUF ] = " " ;
char talkingto [ AST_MAX_BUF ] = " " ;
2008-08-09 12:53:57 +00:00
char music [ AST_MAX_BUF ] ;
2006-05-08 11:08:38 +00:00
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 */
2007-09-18 22:43:45 +00:00
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 ;
2006-05-08 11:08:38 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2012-02-03 21:33:23 +00:00
struct ast_channel * owner ;
2006-05-08 11:08:38 +00:00
agent_status = 0 ; /* reset it to offline */
ast_mutex_lock ( & p - > lock ) ;
2012-02-03 21:33:23 +00:00
owner = agent_lock_owner ( p ) ;
2006-05-08 11:08:38 +00:00
if ( ! ast_strlen_zero ( p - > name ) )
snprintf ( username , sizeof ( username ) , " (%s) " , p - > name ) ;
else
username [ 0 ] = ' \0 ' ;
if ( p - > chan ) {
2012-01-09 22:15:50 +00:00
snprintf ( location , sizeof ( location ) , " logged in on %s " , ast_channel_name ( p - > chan ) ) ;
2012-02-03 21:33:23 +00:00
if ( p - > owner & & ast_bridged_channel ( p - > owner ) ) {
2012-01-09 22:15:50 +00:00
snprintf ( talkingto , sizeof ( talkingto ) , " talking to %s " , ast_channel_name ( ast_bridged_channel ( p - > owner ) ) ) ;
2012-02-03 21:33:23 +00:00
} else {
2006-05-08 11:08:38 +00:00
strcpy ( talkingto , " is idle " ) ;
2012-02-03 21:33:23 +00:00
}
2006-05-08 11:08:38 +00:00
agent_status = 1 ;
online_agents + + ;
}
2012-02-03 21:33:23 +00:00
if ( owner ) {
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
}
2006-05-08 11:08:38 +00:00
if ( ! ast_strlen_zero ( p - > moh ) )
2008-08-09 12:53:57 +00:00
snprintf ( music , sizeof ( music ) , " (musiconhold is '%s') " , p - > moh ) ;
2006-05-08 11:08:38 +00:00
if ( agent_status )
2008-08-09 12:53:57 +00:00
ast_cli ( a - > fd , " %-12.12s %s%s%s%s \n " , p - > agent , username , location , talkingto , music ) ;
2006-05-08 11:08:38 +00:00
count_agents + + ;
ast_mutex_unlock ( & p - > lock ) ;
}
AST_LIST_UNLOCK ( & agents ) ;
2006-06-27 20:52:52 +00:00
if ( ! count_agents )
2007-09-18 22:43:45 +00:00
ast_cli ( a - > fd , " No Agents are configured in %s \n " , config ) ;
2006-05-08 11:08:38 +00:00
else
2007-09-18 22:43:45 +00:00
ast_cli ( a - > fd , " %d agents online \n " , online_agents ) ;
ast_cli ( a - > fd , " \n " ) ;
return CLI_SUCCESS ;
2006-05-08 11:08:38 +00:00
}
2006-12-06 07:35:31 +00:00
static const char agent_logoff_usage [ ] =
2005-01-30 06:55:10 +00:00
" 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 " ;
2006-09-18 19:54:18 +00:00
static struct ast_cli_entry cli_agents [ ] = {
2007-10-22 20:05:18 +00:00
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 " ) ,
2006-09-18 19:54:18 +00:00
} ;
2005-01-30 06:55:10 +00:00
2005-11-06 22:17:47 +00:00
/*!
2007-06-13 19:05:25 +00:00
* Called by the AgentLogin application ( from the dial plan ) .
*
2005-11-06 22:17:47 +00:00
* \ brief Log in agent application .
2005-09-14 02:12:37 +00:00
*
2005-11-06 22:17:47 +00:00
* \ param chan
* \ param data
2007-06-13 19:05:25 +00:00
* \ returns
* \ sa agentmonitoroutgoing_exec ( ) , load_module ( ) .
2005-09-14 02:12:37 +00:00
*/
2009-05-21 21:13:09 +00:00
static int login_exec ( struct ast_channel * chan , const char * data )
2002-09-02 15:20:28 +00:00
{
int res = 0 ;
int tries = 0 ;
2004-10-24 13:24:16 +00:00
int max_login_tries = maxlogintries ;
2002-09-02 15:20:28 +00:00
struct agent_pvt * p ;
2006-08-21 02:11:39 +00:00
struct ast_module_user * u ;
2004-07-16 04:40:54 +00:00
char user [ AST_MAX_AGENT ] = " " ;
2002-09-02 15:20:28 +00:00
char pass [ AST_MAX_AGENT ] ;
2004-02-14 04:54:39 +00:00
char agent [ AST_MAX_AGENT ] = " " ;
2002-09-02 15:20:28 +00:00
char xpass [ AST_MAX_AGENT ] = " " ;
char * errmsg ;
2005-10-28 17:11:20 +00:00
char * parse ;
AST_DECLARE_APP_ARGS ( args ,
AST_APP_ARG ( agent_id ) ;
AST_APP_ARG ( options ) ;
AST_APP_ARG ( extension ) ;
) ;
2005-12-03 19:25:33 +00:00
const char * tmpoptions = NULL ;
2004-10-24 13:24:16 +00:00
int play_announcement = 1 ;
char agent_goodbye [ AST_MAX_FILENAME_LEN ] ;
int update_cdr = updatecdr ;
2003-07-14 02:31:56 +00:00
char * filename = " agent-loginok " ;
2005-10-26 16:16:05 +00:00
2006-08-21 02:11:39 +00:00
u = ast_module_user_add ( chan ) ;
2002-12-06 16:22:19 +00:00
2006-05-10 13:22:15 +00:00
parse = ast_strdupa ( data ) ;
2005-10-26 16:16:05 +00:00
2005-10-28 17:11:20 +00:00
AST_STANDARD_APP_ARGS ( args , parse ) ;
2005-10-26 16:16:05 +00:00
ast_copy_string ( agent_goodbye , agentgoodbye , sizeof ( agent_goodbye ) ) ;
2008-07-02 20:49:08 +00:00
ast_channel_lock ( chan ) ;
2004-10-24 13:24:16 +00:00
/* Set Channel Specific Login Overrides */
2007-05-22 15:08:08 +00:00
if ( ! ast_strlen_zero ( pbx_builtin_getvar_helper ( chan , " AGENTLMAXLOGINTRIES " ) ) ) {
2004-10-24 13:24:16 +00:00
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 " ) ;
2012-01-09 22:15:50 +00:00
ast_verb ( 3 , " Saw variable AGENTMAXLOGINTRIES=%s, setting max_login_tries to: %d on Channel '%s'. \n " , tmpoptions , max_login_tries , ast_channel_name ( chan ) ) ;
2004-10-24 13:24:16 +00:00
}
2007-05-22 15:08:08 +00:00
if ( ! ast_strlen_zero ( pbx_builtin_getvar_helper ( chan , " AGENTUPDATECDR " ) ) ) {
2004-10-24 13:24:16 +00:00
if ( ast_true ( pbx_builtin_getvar_helper ( chan , " AGENTUPDATECDR " ) ) )
update_cdr = 1 ;
else
update_cdr = 0 ;
tmpoptions = pbx_builtin_getvar_helper ( chan , " AGENTUPDATECDR " ) ;
2012-01-09 22:15:50 +00:00
ast_verb ( 3 , " Saw variable AGENTUPDATECDR=%s, setting update_cdr to: %d on Channel '%s'. \n " , tmpoptions , update_cdr , ast_channel_name ( chan ) ) ;
2004-10-24 13:24:16 +00:00
}
2007-05-22 15:08:08 +00:00
if ( ! ast_strlen_zero ( pbx_builtin_getvar_helper ( chan , " AGENTGOODBYE " ) ) ) {
2004-10-24 13:24:16 +00:00
strcpy ( agent_goodbye , pbx_builtin_getvar_helper ( chan , " AGENTGOODBYE " ) ) ;
tmpoptions = pbx_builtin_getvar_helper ( chan , " AGENTGOODBYE " ) ;
2012-01-09 22:15:50 +00:00
ast_verb ( 3 , " Saw variable AGENTGOODBYE=%s, setting agent_goodbye to: %s on Channel '%s'. \n " , tmpoptions , agent_goodbye , ast_channel_name ( chan ) ) ;
2004-10-24 13:24:16 +00:00
}
2008-07-02 20:49:08 +00:00
ast_channel_unlock ( chan ) ;
2004-10-24 13:24:16 +00:00
/* End Channel Specific Login Overrides */
2005-10-26 16:16:05 +00:00
2005-11-06 22:17:47 +00:00
if ( ! ast_strlen_zero ( args . options ) ) {
if ( strchr ( args . options , ' s ' ) ) {
2005-10-26 16:16:05 +00:00
play_announcement = 0 ;
2004-10-24 13:24:16 +00:00
}
2002-12-06 16:22:19 +00:00
}
2012-02-20 23:43:27 +00:00
if ( ast_channel_state ( chan ) ! = AST_STATE_UP )
2002-09-02 15:20:28 +00:00
res = ast_answer ( chan ) ;
2002-12-06 16:22:19 +00:00
if ( ! res ) {
2005-10-28 17:11:20 +00:00
if ( ! ast_strlen_zero ( args . agent_id ) )
ast_copy_string ( user , args . agent_id , AST_MAX_AGENT ) ;
2002-12-06 16:22:19 +00:00
else
res = ast_app_getdata ( chan , " agent-user " , user , sizeof ( user ) - 1 , 0 ) ;
}
2004-10-24 13:24:16 +00:00
while ( ! res & & ( max_login_tries = = 0 | | tries < max_login_tries ) ) {
tries + + ;
2002-09-02 15:20:28 +00:00
/* Check for password */
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2003-07-01 16:16:28 +00:00
if ( ! strcmp ( p - > agent , user ) & & ! p - > pending )
2005-08-26 20:24:16 +00:00
ast_copy_string ( xpass , p - > password , sizeof ( xpass ) ) ;
2002-09-02 15:20:28 +00:00
}
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2002-09-02 15:20:28 +00:00
if ( ! res ) {
2004-05-09 07:51:44 +00:00
if ( ! ast_strlen_zero ( xpass ) )
2002-09-02 15:20:28 +00:00
res = ast_app_getdata ( chan , " agent-pass " , pass , sizeof ( pass ) - 1 , 0 ) ;
else
2004-07-16 04:40:54 +00:00
pass [ 0 ] = ' \0 ' ;
2002-09-02 15:20:28 +00:00
}
errmsg = " agent-incorrect " ;
#if 0
ast_log ( LOG_NOTICE , " user: %s, pass: %s \n " , user , pass ) ;
# endif
/* Check again for accuracy */
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2008-07-02 20:49:08 +00:00
int unlock_channel = 1 ;
ast_channel_lock ( chan ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
if ( ! strcmp ( p - > agent , user ) & &
2005-09-14 00:28:06 +00:00
! strcmp ( p - > password , pass ) & & ! p - > pending ) {
2005-09-14 00:59:51 +00:00
/* Ensure we can't be gotten until we're done */
2007-07-18 19:47:20 +00:00
p - > lastdisc = ast_tvnow ( ) ;
2005-09-14 00:59:51 +00:00
p - > lastdisc . tv_sec + + ;
2006-01-13 06:11:41 +00:00
/* Set Channel Specific Agent Overrides */
2007-05-22 15:08:08 +00:00
if ( ! ast_strlen_zero ( pbx_builtin_getvar_helper ( chan , " AGENTACKCALL " ) ) ) {
2009-05-30 01:04:57 +00:00
if ( ast_true ( pbx_builtin_getvar_helper ( chan , " AGENTACKCALL " ) ) ) {
2005-09-14 00:28:06 +00:00
p - > ackcall = 1 ;
2009-05-30 01:04:57 +00:00
} else {
2005-09-14 00:28:06 +00:00
p - > ackcall = 0 ;
2009-05-30 01:04:57 +00:00
}
2005-09-14 00:28:06 +00:00
tmpoptions = pbx_builtin_getvar_helper ( chan , " AGENTACKCALL " ) ;
2008-07-02 20:43:55 +00:00
ast_verb ( 3 , " Saw variable AGENTACKCALL=%s, setting ackcall to: %d for Agent '%s'. \n " , tmpoptions , p - > ackcall , p - > agent ) ;
2008-11-26 14:58:17 +00:00
ast_set_flag ( p , AGENT_FLAG_ACKCALL ) ;
2008-08-19 23:19:40 +00:00
} else {
p - > ackcall = ackcall ;
2005-09-14 00:28:06 +00:00
}
2007-05-22 15:08:08 +00:00
if ( ! ast_strlen_zero ( pbx_builtin_getvar_helper ( chan , " AGENTAUTOLOGOFF " ) ) ) {
2005-09-14 00:28:06 +00:00
p - > autologoff = atoi ( pbx_builtin_getvar_helper ( chan , " AGENTAUTOLOGOFF " ) ) ;
if ( p - > autologoff < 0 )
p - > autologoff = 0 ;
tmpoptions = pbx_builtin_getvar_helper ( chan , " AGENTAUTOLOGOFF " ) ;
2008-07-02 20:43:55 +00:00
ast_verb ( 3 , " Saw variable AGENTAUTOLOGOFF=%s, setting autologff to: %d for Agent '%s'. \n " , tmpoptions , p - > autologoff , p - > agent ) ;
2008-11-26 14:58:17 +00:00
ast_set_flag ( p , AGENT_FLAG_AUTOLOGOFF ) ;
2008-08-19 23:19:40 +00:00
} else {
p - > autologoff = autologoff ;
2005-09-14 00:28:06 +00:00
}
2007-05-22 15:08:08 +00:00
if ( ! ast_strlen_zero ( pbx_builtin_getvar_helper ( chan , " AGENTWRAPUPTIME " ) ) ) {
2005-09-14 00:28:06 +00:00
p - > wrapuptime = atoi ( pbx_builtin_getvar_helper ( chan , " AGENTWRAPUPTIME " ) ) ;
if ( p - > wrapuptime < 0 )
p - > wrapuptime = 0 ;
tmpoptions = pbx_builtin_getvar_helper ( chan , " AGENTWRAPUPTIME " ) ;
2008-07-02 20:43:55 +00:00
ast_verb ( 3 , " Saw variable AGENTWRAPUPTIME=%s, setting wrapuptime to: %d for Agent '%s'. \n " , tmpoptions , p - > wrapuptime , p - > agent ) ;
2008-11-26 14:58:17 +00:00
ast_set_flag ( p , AGENT_FLAG_WRAPUPTIME ) ;
2008-08-19 23:19:40 +00:00
} else {
p - > wrapuptime = wrapuptime ;
2008-07-02 20:43:55 +00:00
}
2009-08-17 18:50:24 +00:00
tmpoptions = pbx_builtin_getvar_helper ( chan , " AGENTACCEPTDTMF " ) ;
2008-07-02 20:43:55 +00:00
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 ) ;
2008-11-26 14:58:17 +00:00
ast_set_flag ( p , AGENT_FLAG_ACCEPTDTMF ) ;
2008-07-02 20:43:55 +00:00
}
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 ) ;
2008-11-26 14:58:17 +00:00
ast_set_flag ( p , AGENT_FLAG_ENDDTMF ) ;
2005-09-14 00:28:06 +00:00
}
2008-07-02 20:49:08 +00:00
ast_channel_unlock ( chan ) ;
unlock_channel = 0 ;
2006-01-13 06:11:41 +00:00
/* End Channel Specific Agent Overrides */
2005-09-14 00:28:06 +00:00
if ( ! p - > chan ) {
long logintime ;
snprintf ( agent , sizeof ( agent ) , " Agent/%s " , p - > agent ) ;
2007-06-13 19:05:25 +00:00
p - > logincallerid [ 0 ] = ' \0 ' ;
p - > acknowledged = 0 ;
2005-09-14 00:28:06 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2005-09-14 00:28:06 +00:00
if ( ! res & & play_announcement = = 1 )
2012-01-24 20:12:09 +00:00
res = ast_streamfile ( chan , filename , ast_channel_language ( chan ) ) ;
2005-09-14 00:28:06 +00:00
if ( ! res )
ast_waitstream ( chan , " " ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
2005-09-14 00:28:06 +00:00
ast_mutex_lock ( & p - > lock ) ;
if ( ! res ) {
2011-02-03 16:22:10 +00:00
struct ast_format tmpfmt ;
2012-02-20 23:43:27 +00:00
res = ast_set_read_format_from_cap ( chan , ast_channel_nativeformats ( chan ) ) ;
2011-02-03 16:22:10 +00:00
if ( res ) {
ast_log ( LOG_WARNING , " Unable to set read format to %s \n " , ast_getformatname ( & tmpfmt ) ) ;
}
2005-09-14 00:28:06 +00:00
}
if ( ! res ) {
2011-02-03 16:22:10 +00:00
struct ast_format tmpfmt ;
2012-02-20 23:43:27 +00:00
res = ast_set_write_format_from_cap ( chan , ast_channel_nativeformats ( chan ) ) ;
2011-02-03 16:22:10 +00:00
if ( res ) {
ast_log ( LOG_WARNING , " Unable to set write format to %s \n " , ast_getformatname ( & tmpfmt ) ) ;
}
2005-09-14 00:28:06 +00:00
}
/* Check once more just in case */
if ( p - > chan )
res = - 1 ;
2007-06-13 19:05:25 +00:00
if ( ! res ) {
2006-07-19 20:44:39 +00:00
ast_indicate_data ( chan , AST_CONTROL_HOLD ,
S_OR ( p - > moh , NULL ) ,
! ast_strlen_zero ( p - > moh ) ? strlen ( p - > moh ) + 1 : 0 ) ;
2005-09-14 00:28:06 +00:00
if ( p - > loginstart = = 0 )
time ( & p - > loginstart ) ;
2012-07-10 22:26:27 +00:00
/*** DOCUMENTATION
< managerEventInstance >
< synopsis > Raised when an Agent has logged in . < / synopsis >
< syntax >
< parameter name = " Agent " >
< para > The name of the agent . < / para >
< / parameter >
< / syntax >
< see - also >
< ref type = " application " > AgentLogin < / ref >
< ref type = " managerEvent " > Agentlogoff < / ref >
< / see - also >
< / managerEventInstance >
* * */
2005-09-14 00:28:06 +00:00
manager_event ( EVENT_FLAG_AGENT , " Agentlogin " ,
" Agent: %s \r \n "
" Channel: %s \r \n "
" Uniqueid: %s \r \n " ,
2012-01-24 20:12:09 +00:00
p - > agent , ast_channel_name ( chan ) , ast_channel_uniqueid ( chan ) ) ;
2012-02-20 23:43:27 +00:00
if ( update_cdr & & ast_channel_cdr ( chan ) )
snprintf ( ast_channel_cdr ( chan ) - > channel , sizeof ( ast_channel_cdr ( chan ) - > channel ) , " Agent/%s " , p - > agent ) ;
2012-01-24 20:12:09 +00:00
ast_queue_log ( " NONE " , ast_channel_uniqueid ( chan ) , agent , " AGENTLOGIN " , " %s " , ast_channel_name ( chan ) ) ;
2007-07-26 15:49:18 +00:00
ast_verb ( 2 , " Agent '%s' logged in (format %s/%s) \n " , p - > agent ,
2012-02-24 00:32:20 +00:00
ast_getformatname ( ast_channel_readformat ( chan ) ) , ast_getformatname ( ast_channel_writeformat ( chan ) ) ) ;
2006-06-27 20:52:52 +00:00
/* Login this channel and wait for it to go away */
2005-09-14 00:28:06 +00:00
p - > chan = chan ;
2009-05-30 01:04:57 +00:00
if ( p - > ackcall ) {
2005-09-14 00:28:06 +00:00
check_beep ( p , 0 ) ;
2009-05-30 01:04:57 +00:00
} else {
2005-09-14 00:28:06 +00:00
check_availability ( p , 0 ) ;
2009-05-30 01:04:57 +00:00
}
2005-09-14 00:28:06 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2008-07-25 21:20:03 +00:00
ast_devstate_changed ( AST_DEVICE_NOT_INUSE , " Agent/%s " , p - > agent ) ;
2005-09-14 00:28:06 +00:00
while ( res > = 0 ) {
ast_mutex_lock ( & p - > lock ) ;
2007-07-12 23:02:33 +00:00
if ( p - > deferlogoff & & p - > chan ) {
2007-07-11 21:15:47 +00:00
ast_softhangup ( p - > chan , AST_SOFTHANGUP_EXPLICIT ) ;
2007-07-12 23:02:33 +00:00
p - > deferlogoff = 0 ;
}
2005-09-14 00:28:06 +00:00
if ( p - > chan ! = chan )
res = - 1 ;
ast_mutex_unlock ( & p - > lock ) ;
/* Yield here so other interested threads can kick in. */
sched_yield ( ) ;
2002-09-02 15:20:28 +00:00
if ( res )
2005-09-14 00:28:06 +00:00
break ;
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
2005-09-14 00:28:06 +00:00
ast_mutex_lock ( & p - > lock ) ;
if ( p - > lastdisc . tv_sec ) {
2007-07-10 19:07:25 +00:00
if ( ast_tvdiff_ms ( ast_tvnow ( ) , p - > lastdisc ) > 0 ) {
2007-06-14 19:39:12 +00:00
ast_debug ( 1 , " Wrapup time for %s expired! \n " , p - > agent ) ;
2005-09-14 00:28:06 +00:00
p - > lastdisc = ast_tv ( 0 , 0 ) ;
2008-07-25 21:20:03 +00:00
ast_devstate_changed ( AST_DEVICE_NOT_INUSE , " Agent/%s " , p - > agent ) ;
2009-05-30 01:04:57 +00:00
if ( p - > ackcall ) {
2005-09-14 00:28:06 +00:00
check_beep ( p , 0 ) ;
2009-05-30 01:04:57 +00:00
} else {
2005-09-14 00:28:06 +00:00
check_availability ( p , 0 ) ;
2009-05-30 01:04:57 +00:00
}
2005-09-14 00:28:06 +00:00
}
2004-06-03 17:33:35 +00:00
}
2005-09-14 00:28:06 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2011-04-22 21:33:42 +00:00
2005-09-14 00:28:06 +00:00
/* Synchronize channel ownership between call to agent and itself. */
2011-04-22 21:33:42 +00:00
ast_mutex_lock ( & p - > lock ) ;
2009-01-12 20:53:04 +00:00
if ( p - > app_lock_flag = = 1 ) {
2011-04-22 21:33:42 +00:00
ast_cond_signal ( & p - > login_wait_cond ) ;
ast_cond_wait ( & p - > app_complete_cond , & p - > lock ) ;
2009-01-12 20:53:04 +00:00
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2009-05-30 01:04:57 +00:00
if ( p - > ackcall ) {
2005-09-14 00:28:06 +00:00
res = agent_ack_sleep ( p ) ;
2009-05-30 01:04:57 +00:00
} else {
2006-06-27 20:52:52 +00:00
res = ast_safe_sleep_conditional ( chan , 1000 , agent_cont_sleep , p ) ;
2009-05-30 01:04:57 +00:00
}
if ( p - > ackcall & & ( res = = 1 ) ) {
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_lock ( & p - > lock ) ;
2005-09-14 00:28:06 +00:00
check_availability ( p , 0 ) ;
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2005-09-14 00:28:06 +00:00
res = 0 ;
2004-06-22 17:42:14 +00:00
}
2005-09-14 00:28:06 +00:00
sched_yield ( ) ;
2002-09-02 15:20:28 +00:00
}
2005-09-14 00:28:06 +00:00
ast_mutex_lock ( & p - > lock ) ;
/* Log us off if appropriate */
2008-07-11 17:29:24 +00:00
if ( p - > chan = = chan ) {
2005-09-14 00:28:06 +00:00
p - > chan = NULL ;
2008-07-11 17:29:24 +00:00
}
2011-04-22 21:33:42 +00:00
/* Synchronize channel ownership between call to agent and itself. */
if ( p - > app_lock_flag = = 1 ) {
ast_cond_signal ( & p - > login_wait_cond ) ;
ast_cond_wait ( & p - > app_complete_cond , & p - > lock ) ;
}
if ( res & & p - > owner )
ast_log ( LOG_WARNING , " Huh? We broke out when there was still an owner? \n " ) ;
2005-09-14 00:28:06 +00:00
p - > acknowledged = 0 ;
logintime = time ( NULL ) - p - > loginstart ;
p - > loginstart = 0 ;
ast_mutex_unlock ( & p - > lock ) ;
2012-07-10 22:26:27 +00:00
/*** DOCUMENTATION
< managerEventInstance >
< synopsis > Raised when an Agent has logged off . < / synopsis >
< syntax >
< xi : include xpointer = " xpointer(/docs/managerEvent[@name='Agentlogin']/managerEventInstance/syntax/parameter[@name='Agent']) " / >
< / syntax >
< see - also >
< ref type = " managerEvent " > Agentlogin < / ref >
< / see - also >
< / managerEventInstance >
* * */
2005-09-14 00:28:06 +00:00
manager_event ( EVENT_FLAG_AGENT , " Agentlogoff " ,
" Agent: %s \r \n "
" Logintime: %ld \r \n "
" Uniqueid: %s \r \n " ,
2012-01-24 20:12:09 +00:00
p - > agent , logintime , ast_channel_uniqueid ( chan ) ) ;
ast_queue_log ( " NONE " , ast_channel_uniqueid ( chan ) , agent , " AGENTLOGOFF " , " %s|%ld " , ast_channel_name ( chan ) , logintime ) ;
2007-07-26 15:49:18 +00:00
ast_verb ( 2 , " Agent '%s' logged out \n " , p - > agent ) ;
2005-09-14 00:28:06 +00:00
/* If there is no owner, go ahead and kill it now */
2008-07-25 21:20:03 +00:00
ast_devstate_changed ( AST_DEVICE_UNAVAILABLE , " Agent/%s " , p - > agent ) ;
2005-09-14 00:28:06 +00:00
if ( p - > dead & & ! p - > owner ) {
ast_mutex_destroy ( & p - > lock ) ;
2009-01-12 20:53:04 +00:00
ast_cond_destroy ( & p - > app_complete_cond ) ;
2011-04-22 21:33:42 +00:00
ast_cond_destroy ( & p - > login_wait_cond ) ;
2007-06-06 21:20:11 +00:00
ast_free ( p ) ;
2002-12-06 16:22:19 +00:00
}
2005-09-14 00:28:06 +00:00
}
else {
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2002-09-02 15:20:28 +00:00
p = NULL ;
}
2005-09-14 00:28:06 +00:00
res = - 1 ;
} else {
ast_mutex_unlock ( & p - > lock ) ;
errmsg = " agent-alreadyon " ;
p = NULL ;
}
break ;
2002-09-02 15:20:28 +00:00
}
2003-08-13 15:25:16 +00:00
ast_mutex_unlock ( & p - > lock ) ;
2008-07-02 20:49:08 +00:00
if ( unlock_channel ) {
ast_channel_unlock ( chan ) ;
}
2002-09-02 15:20:28 +00:00
}
if ( ! p )
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2002-09-02 15:20:28 +00:00
2004-10-24 13:24:16 +00:00
if ( ! res & & ( max_login_tries = = 0 | | tries < max_login_tries ) )
2002-09-02 15:20:28 +00:00
res = ast_app_getdata ( chan , errmsg , user , sizeof ( user ) - 1 , 0 ) ;
}
2004-10-24 13:24:16 +00:00
if ( ! res )
res = ast_safe_sleep ( chan , 500 ) ;
2006-08-21 02:11:39 +00:00
ast_module_user_remove ( u ) ;
2005-10-26 16:16:05 +00:00
2004-10-24 13:24:16 +00:00
return - 1 ;
2002-09-02 15:20:28 +00:00
}
2006-06-14 14:46:19 +00:00
/*!
* \ brief Called by the AgentMonitorOutgoing application ( from the dial plan ) .
2005-09-14 02:12:37 +00:00
*
2006-06-14 14:46:19 +00:00
* \ param chan
* \ param data
* \ returns
2007-06-13 19:05:25 +00:00
* \ sa login_exec ( ) , load_module ( ) .
2005-09-14 02:12:37 +00:00
*/
2009-05-21 21:13:09 +00:00
static int agentmonitoroutgoing_exec ( struct ast_channel * chan , const char * data )
2004-02-05 21:13:17 +00:00
{
int exitifnoagentid = 0 ;
int nowarnings = 0 ;
2004-12-10 17:37:20 +00:00
int changeoutgoing = 0 ;
2004-02-05 21:13:17 +00:00
int res = 0 ;
2005-12-03 19:25:33 +00:00
char agent [ AST_MAX_AGENT ] ;
2004-12-31 00:58:44 +00:00
2004-02-05 21:13:17 +00:00
if ( data ) {
if ( strchr ( data , ' d ' ) )
exitifnoagentid = 1 ;
if ( strchr ( data , ' n ' ) )
nowarnings = 1 ;
2004-12-10 17:37:20 +00:00
if ( strchr ( data , ' c ' ) )
changeoutgoing = 1 ;
2004-02-05 21:13:17 +00:00
}
2012-02-29 16:52:47 +00:00
if ( ast_channel_caller ( chan ) - > id . number . valid
& & ! ast_strlen_zero ( ast_channel_caller ( chan ) - > id . number . str ) ) {
2005-12-03 19:25:33 +00:00
const char * tmp ;
2004-02-05 21:13:17 +00:00
char agentvar [ AST_MAX_BUF ] ;
2010-07-14 15:48:36 +00:00
snprintf ( agentvar , sizeof ( agentvar ) , " %s_%s " , GETAGENTBYCALLERID ,
2012-02-29 16:52:47 +00:00
ast_channel_caller ( chan ) - > id . number . str ) ;
2004-02-05 21:13:17 +00:00
if ( ( tmp = pbx_builtin_getvar_helper ( NULL , agentvar ) ) ) {
2006-01-25 18:12:55 +00:00
struct agent_pvt * p ;
2005-08-26 20:24:16 +00:00
ast_copy_string ( agent , tmp , sizeof ( agent ) ) ;
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2004-02-05 21:13:17 +00:00
if ( ! strcasecmp ( p - > agent , tmp ) ) {
2012-02-20 23:43:27 +00:00
if ( changeoutgoing ) snprintf ( ast_channel_cdr ( chan ) - > channel , sizeof ( ast_channel_cdr ( chan ) - > channel ) , " Agent/%s " , p - > agent ) ;
2004-02-05 21:13:17 +00:00
__agent_start_monitoring ( chan , p , 1 ) ;
break ;
}
}
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2004-02-05 21:13:17 +00:00
} 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 ) {
2007-06-12 15:58:28 +00:00
if ( exitifnoagentid )
2004-02-05 21:13:17 +00:00
return res ;
}
return 0 ;
}
2006-06-14 14:46:19 +00:00
/*! \brief Part of PBX channel interface */
2012-02-01 19:53:38 +00:00
static int agent_devicestate ( const char * data )
2004-11-12 03:50:19 +00:00
{
struct agent_pvt * p ;
2012-02-01 19:53:38 +00:00
const char * s ;
2005-01-15 21:51:38 +00:00
ast_group_t groupmatch ;
2005-01-17 04:47:01 +00:00
int groupoff ;
2004-11-12 03:50:19 +00:00
int res = AST_DEVICE_INVALID ;
s = data ;
2009-08-10 19:20:57 +00:00
if ( ( s [ 0 ] = = ' @ ' ) & & ( sscanf ( s + 1 , " %30d " , & groupoff ) = = 1 ) )
2005-01-17 04:47:01 +00:00
groupmatch = ( 1 < < groupoff ) ;
2009-08-10 19:20:57 +00:00
else if ( ( s [ 0 ] = = ' : ' ) & & ( sscanf ( s + 1 , " %30d " , & groupoff ) = = 1 ) ) {
2005-01-17 04:47:01 +00:00
groupmatch = ( 1 < < groupoff ) ;
2006-06-27 20:52:52 +00:00
} else
2004-11-12 03:50:19 +00:00
groupmatch = 0 ;
/* Check actual logged in agents first */
2006-01-25 18:12:55 +00:00
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2004-11-12 03:50:19 +00:00
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 ;
2009-05-30 01:04:57 +00:00
if ( p - > chan ) {
2004-11-12 03:50:19 +00:00
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 ) ;
}
2006-01-25 18:12:55 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2004-11-12 03:50:19 +00:00
return res ;
}
2008-01-31 19:13:20 +00:00
/*!
* \ note This function expects the agent list to be locked
*/
2006-04-24 17:11:45 +00:00
static struct agent_pvt * find_agent ( char * agentid )
2005-12-20 19:56:52 +00:00
{
2006-01-25 18:12:55 +00:00
struct agent_pvt * cur ;
2005-12-20 19:56:52 +00:00
2006-01-25 18:12:55 +00:00
AST_LIST_TRAVERSE ( & agents , cur , list ) {
2005-12-20 19:56:52 +00:00
if ( ! strcmp ( cur - > agent , agentid ) )
break ;
}
return cur ;
}
2007-01-05 23:32:42 +00:00
static int function_agent ( struct ast_channel * chan , const char * cmd , char * data , char * buf , size_t len )
2005-12-20 19:56:52 +00:00
{
2006-01-25 19:06:37 +00:00
char * parse ;
AST_DECLARE_APP_ARGS ( args ,
AST_APP_ARG ( agentid ) ;
AST_APP_ARG ( item ) ;
) ;
2005-12-20 19:56:52 +00:00
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 " ) ;
2006-02-12 04:28:58 +00:00
return - 1 ;
2005-12-20 19:56:52 +00:00
}
2006-05-10 13:22:15 +00:00
parse = ast_strdupa ( data ) ;
2005-12-20 19:56:52 +00:00
2006-01-25 19:06:37 +00:00
AST_NONSTANDARD_APP_ARGS ( args , parse , ' : ' ) ;
if ( ! args . item )
args . item = " status " ;
2005-12-20 19:56:52 +00:00
2008-01-31 19:13:20 +00:00
AST_LIST_LOCK ( & agents ) ;
2006-01-25 19:06:37 +00:00
if ( ! ( agent = find_agent ( args . agentid ) ) ) {
2008-01-31 19:13:20 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2006-01-25 19:06:37 +00:00
ast_log ( LOG_WARNING , " Agent '%s' not found! \n " , args . agentid ) ;
2006-02-12 04:28:58 +00:00
return - 1 ;
2005-12-20 19:56:52 +00:00
}
2006-01-25 19:06:37 +00:00
if ( ! strcasecmp ( args . item , " status " ) ) {
2006-06-14 14:46:19 +00:00
char * status = " LOGGEDOUT " ;
2009-05-30 01:04:57 +00:00
if ( agent - > chan ) {
status = " LOGGEDIN " ;
}
2006-06-14 14:46:19 +00:00
ast_copy_string ( buf , status , len ) ;
2006-06-27 20:52:52 +00:00
} else if ( ! strcasecmp ( args . item , " password " ) )
2005-12-20 19:56:52 +00:00
ast_copy_string ( buf , agent - > password , len ) ;
2006-06-27 20:52:52 +00:00
else if ( ! strcasecmp ( args . item , " name " ) )
2005-12-20 19:56:52 +00:00
ast_copy_string ( buf , agent - > name , len ) ;
2006-06-27 20:52:52 +00:00
else if ( ! strcasecmp ( args . item , " mohclass " ) )
2005-12-20 19:56:52 +00:00
ast_copy_string ( buf , agent - > moh , len ) ;
2006-06-27 20:52:52 +00:00
else if ( ! strcasecmp ( args . item , " channel " ) ) {
2005-12-20 19:56:52 +00:00
if ( agent - > chan ) {
2010-06-16 21:10:48 +00:00
ast_channel_lock ( agent - > chan ) ;
2012-01-09 22:15:50 +00:00
ast_copy_string ( buf , ast_channel_name ( agent - > chan ) , len ) ;
2010-06-16 21:10:48 +00:00
ast_channel_unlock ( agent - > chan ) ;
2005-12-20 19:56:52 +00:00
tmp = strrchr ( buf , ' - ' ) ;
if ( tmp )
* tmp = ' \0 ' ;
}
2010-06-14 19:41:43 +00:00
} else if ( ! strcasecmp ( args . item , " fullchannel " ) ) {
if ( agent - > chan ) {
2010-06-16 21:12:25 +00:00
ast_channel_lock ( agent - > chan ) ;
2012-01-09 22:15:50 +00:00
ast_copy_string ( buf , ast_channel_name ( agent - > chan ) , len ) ;
2010-06-16 21:12:25 +00:00
ast_channel_unlock ( agent - > chan ) ;
2010-06-14 19:41:43 +00:00
}
2009-05-30 01:04:57 +00:00
} else if ( ! strcasecmp ( args . item , " exten " ) ) {
buf [ 0 ] = ' \0 ' ;
}
2005-12-20 19:56:52 +00:00
2008-01-31 19:13:20 +00:00
AST_LIST_UNLOCK ( & agents ) ;
2006-02-12 04:28:58 +00:00
return 0 ;
2005-12-20 19:56:52 +00:00
}
2009-06-15 17:06:34 +00:00
static struct ast_custom_function agent_function = {
2005-12-20 19:56:52 +00:00
. name = " AGENT " ,
. read = function_agent ,
} ;
2010-07-08 14:48:42 +00:00
/*!
* \ internal
* \ brief Callback used to generate the agents tree .
* \ param [ in ] search The search pattern tree .
* \ retval NULL on error .
* \ retval non - NULL The generated tree .
*/
static int agents_data_provider_get ( const struct ast_data_search * search ,
struct ast_data * data_root )
{
struct agent_pvt * p ;
struct ast_data * data_agent , * data_channel , * data_talkingto ;
AST_LIST_LOCK ( & agents ) ;
AST_LIST_TRAVERSE ( & agents , p , list ) {
2012-02-03 21:33:23 +00:00
struct ast_channel * owner ;
2010-07-08 14:48:42 +00:00
data_agent = ast_data_add_node ( data_root , " agent " ) ;
if ( ! data_agent ) {
continue ;
}
ast_mutex_lock ( & p - > lock ) ;
2012-02-03 21:33:23 +00:00
owner = agent_lock_owner ( p ) ;
2010-07-08 14:48:42 +00:00
if ( ! ( p - > pending ) ) {
ast_data_add_str ( data_agent , " id " , p - > agent ) ;
ast_data_add_structure ( agent_pvt , data_agent , p ) ;
ast_data_add_bool ( data_agent , " logged " , p - > chan ? 1 : 0 ) ;
if ( p - > chan ) {
data_channel = ast_data_add_node ( data_agent , " loggedon " ) ;
if ( ! data_channel ) {
ast_mutex_unlock ( & p - > lock ) ;
ast_data_remove_node ( data_root , data_agent ) ;
2012-02-03 21:33:23 +00:00
if ( owner ) {
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
}
2010-07-08 14:48:42 +00:00
continue ;
}
ast_channel_data_add_structure ( data_channel , p - > chan , 0 ) ;
2012-02-03 21:33:23 +00:00
if ( owner & & ast_bridged_channel ( owner ) ) {
2010-07-08 14:48:42 +00:00
data_talkingto = ast_data_add_node ( data_agent , " talkingto " ) ;
if ( ! data_talkingto ) {
ast_mutex_unlock ( & p - > lock ) ;
ast_data_remove_node ( data_root , data_agent ) ;
2012-02-03 21:33:23 +00:00
if ( owner ) {
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
}
2010-07-08 14:48:42 +00:00
continue ;
}
2012-02-03 21:33:23 +00:00
ast_channel_data_add_structure ( data_talkingto , ast_bridged_channel ( owner ) , 0 ) ;
2010-07-08 14:48:42 +00:00
}
} else {
ast_data_add_node ( data_agent , " talkingto " ) ;
ast_data_add_node ( data_agent , " loggedon " ) ;
}
ast_data_add_str ( data_agent , " musiconhold " , p - > moh ) ;
}
2012-02-03 21:33:23 +00:00
if ( owner ) {
ast_channel_unlock ( owner ) ;
owner = ast_channel_unref ( owner ) ;
}
2010-07-08 14:48:42 +00:00
ast_mutex_unlock ( & p - > lock ) ;
/* if this agent doesn't match remove the added agent. */
if ( ! ast_data_search_match ( search , data_agent ) ) {
ast_data_remove_node ( data_root , data_agent ) ;
}
}
AST_LIST_UNLOCK ( & agents ) ;
return 0 ;
}
static const struct ast_data_handler agents_data_provider = {
. version = AST_DATA_HANDLER_VERSION ,
. get = agents_data_provider_get
} ;
static const struct ast_data_entry agents_data_providers [ ] = {
AST_DATA_ENTRY ( " asterisk/channel/agent/list " , & agents_data_provider ) ,
} ;
2005-12-20 19:56:52 +00:00
2006-06-14 14:46:19 +00:00
/*!
* \ brief 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 .
2005-09-07 20:44:57 +00:00
*
2006-06-14 14:46:19 +00:00
* \ returns int Always 0.
2005-09-07 20:44:57 +00:00
*/
2006-08-21 02:11:39 +00:00
static int load_module ( void )
2002-09-02 15:20:28 +00:00
{
2011-02-03 16:22:10 +00:00
if ( ! ( agent_tech . capabilities = ast_format_cap_alloc ( ) ) ) {
ast_log ( LOG_ERROR , " ast_format_cap_alloc_nolock fail. \n " ) ;
return AST_MODULE_LOAD_FAILURE ;
}
ast_format_cap_add_all ( agent_tech . capabilities ) ;
2004-12-31 00:58:44 +00:00
/* Make sure we can register our agent channel type */
2005-03-04 06:47:24 +00:00
if ( ast_channel_register ( & agent_tech ) ) {
2012-10-02 01:47:16 +00:00
agent_tech . capabilities = ast_format_cap_destroy ( agent_tech . capabilities ) ;
2006-02-01 23:05:28 +00:00
ast_log ( LOG_ERROR , " Unable to register channel class 'Agent' \n " ) ;
2007-10-26 21:37:02 +00:00
return AST_MODULE_LOAD_FAILURE ;
2002-09-02 15:20:28 +00:00
}
2006-08-31 21:00:20 +00:00
/* Read in the config */
2012-10-02 01:47:16 +00:00
if ( ! read_agent_config ( 0 ) ) {
agent_tech . capabilities = ast_format_cap_destroy ( agent_tech . capabilities ) ;
2006-08-31 21:00:20 +00:00
return AST_MODULE_LOAD_DECLINE ;
2012-10-02 01:47:16 +00:00
}
2004-12-31 00:58:44 +00:00
/* Dialplan applications */
2008-11-05 20:17:06 +00:00
ast_register_application_xml ( app , login_exec ) ;
ast_register_application_xml ( app3 , agentmonitoroutgoing_exec ) ;
2006-06-14 14:46:19 +00:00
2010-07-08 14:48:42 +00:00
/* data tree */
ast_data_register_multiple ( agents_data_providers , ARRAY_LEN ( agents_data_providers ) ) ;
2005-08-26 20:24:16 +00:00
/* Manager commands */
2009-05-22 17:52:35 +00:00
ast_manager_register_xml ( " Agents " , EVENT_FLAG_AGENT , action_agents ) ;
ast_manager_register_xml ( " AgentLogoff " , EVENT_FLAG_AGENT , action_agent_logoff ) ;
2006-06-14 14:46:19 +00:00
2005-12-20 19:56:52 +00:00
/* CLI Commands */
2008-12-05 10:31:25 +00:00
ast_cli_register_multiple ( cli_agents , ARRAY_LEN ( cli_agents ) ) ;
2006-06-14 14:46:19 +00:00
2005-12-20 19:56:52 +00:00
/* Dialplan Functions */
ast_custom_function_register ( & agent_function ) ;
2006-06-14 14:46:19 +00:00
2007-10-26 21:37:02 +00:00
return AST_MODULE_LOAD_SUCCESS ;
2002-09-02 15:20:28 +00:00
}
2006-08-21 02:11:39 +00:00
static int reload ( void )
2002-09-02 15:20:28 +00:00
{
2009-05-30 01:04:57 +00:00
return read_agent_config ( 1 ) ;
2002-09-02 15:20:28 +00:00
}
2006-08-21 02:11:39 +00:00
static int unload_module ( void )
2002-09-02 15:20:28 +00:00
{
struct agent_pvt * p ;
/* First, take us out of the channel loop */
2006-06-16 12:56:03 +00:00
ast_channel_unregister ( & agent_tech ) ;
2005-12-20 19:56:52 +00:00
/* Unregister dialplan functions */
ast_custom_function_unregister ( & agent_function ) ;
/* Unregister CLI commands */
2008-12-05 10:31:25 +00:00
ast_cli_unregister_multiple ( cli_agents , ARRAY_LEN ( cli_agents ) ) ;
2004-12-31 00:58:44 +00:00
/* Unregister dialplan applications */
2002-09-02 15:20:28 +00:00
ast_unregister_application ( app ) ;
2004-02-05 21:13:17 +00:00
ast_unregister_application ( app3 ) ;
2004-12-31 00:58:44 +00:00
/* Unregister manager command */
2004-12-01 05:00:29 +00:00
ast_manager_unregister ( " Agents " ) ;
2005-08-26 20:24:16 +00:00
ast_manager_unregister ( " AgentLogoff " ) ;
2010-07-08 14:48:42 +00:00
/* Unregister the data tree */
ast_data_unregister ( NULL ) ;
2004-12-31 00:58:44 +00:00
/* Unregister channel */
2006-05-11 20:07:44 +00:00
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 ) ;
2007-06-06 21:20:11 +00:00
ast_free ( p ) ;
2006-05-11 20:07:44 +00:00
}
AST_LIST_UNLOCK ( & agents ) ;
2011-02-03 16:22:10 +00:00
agent_tech . capabilities = ast_format_cap_destroy ( agent_tech . capabilities ) ;
2002-09-02 15:20:28 +00:00
return 0 ;
}
2010-07-20 19:35:02 +00:00
AST_MODULE_INFO ( ASTERISK_GPL_KEY , AST_MODFLAG_LOAD_ORDER , " Agent Proxy Channel " ,
2006-08-21 02:11:39 +00:00
. load = load_module ,
. unload = unload_module ,
. reload = reload ,
2010-07-20 19:35:02 +00:00
. load_pri = AST_MODPRI_CHANNEL_DRIVER ,
2010-09-02 05:27:53 +00:00
. nonoptreq = " res_monitor,chan_local " ,
2006-08-21 02:11:39 +00:00
) ;