Asterisk
/
asterisk
mirror of https://github.com/asterisk/asterisk
1
0
Fork 0
Code Issues Releases Wiki Activity

Merged revisions 314959 via svnmerge from

Browse Source 
https://origsvn.digium.com/svn/asterisk/branches/1.8

................
  r314959 | mnicholson | 2011-04-22 16:20:08 -0500 (Fri, 22 Apr 2011) | 24 lines
  
  Merged revisions 314958 via svnmerge from 
  https://origsvn.digium.com/svn/asterisk/branches/1.6.2
  
  ................
    r314958 | mnicholson | 2011-04-22 15:49:45 -0500 (Fri, 22 Apr 2011) | 17 lines
    
    Merged revisions 311203,314908 via svnmerge from 
    https://origsvn.digium.com/svn/asterisk/branches/1.4
    
    ........
      r311203 | mnicholson | 2011-03-17 14:14:37 -0500 (Thu, 17 Mar 2011) | 4 lines
      
      Don't hold the pvt lock while streaming a file.
      
      ABE-2756
    ........
      r314908 | mnicholson | 2011-04-22 15:01:48 -0500 (Fri, 22 Apr 2011) | 4 lines
      
      Prevent the login thread and the app threads from using the asterisk channel at the same time.
      
      ABE-2756
    ........
  ................
................


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@314960 65c4cc65-6c06-0410-ace0-fbb531ad65f3
10-digiumphones
Matthew Nicholson 15 years ago
parent 2b56cf085c
commit fae1fd4b1d
1 changed files with 92 additions and 62 deletions
Show Stats Download Patch File Download Diff File

154
channels/chan_agent.c
Unescape View File

@ -269,9 +269,9 @@ struct agent_pvt {
char agent[AST_MAX_AGENT]; /*!< Agent ID */
char password[AST_MAX_AGENT]; /*!< Password for Agent login */
char name[AST_MAX_AGENT];
ast_mutex_t app_lock; /**< Synchronization between owning applications */
int app_lock_flag;
ast_cond_t app_complete_cond;
ast_cond_t login_wait_cond;
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 */
@ -429,8 +429,8 @@ static struct agent_pvt *add_agent(const char *agent, int pending)
return NULL;
ast_copy_string(p->agent, agt, sizeof(p->agent));
ast_mutex_init(&p->lock);
ast_mutex_init(&p->app_lock);
ast_cond_init(&p->app_complete_cond, NULL);
ast_cond_init(&p->login_wait_cond, NULL);
p->app_lock_flag = 0;
p->app_sleep_cond = 1;
p->group = group;
@ -483,20 +483,23 @@ static struct agent_pvt *add_agent(const char *agent, int pending)
*/
static int agent_cleanup(struct agent_pvt *p)
{
struct ast_channel *chan = p->owner;
struct ast_channel *chan = NULL;
ast_mutex_lock(&p->lock);
chan = p->owner;
p->owner = NULL;
chan->tech_pvt = NULL;
p->app_sleep_cond = 1;
/* Release ownership of the agent to other threads (presumably running the login app). */
p->app_sleep_cond = 1;
p->app_lock_flag = 0;
ast_cond_signal(&p->app_complete_cond);
if (chan) {
chan = ast_channel_release(chan);
}
if (p->dead) {
ast_mutex_unlock(&p->lock);
ast_mutex_destroy(&p->lock);
ast_mutex_destroy(&p->app_lock);
ast_cond_destroy(&p->app_complete_cond);
ast_cond_destroy(&p->login_wait_cond);
ast_free(p);
}
return 0;
@ -773,30 +776,42 @@ static int agent_call(struct ast_channel *ast, char *dest, int timeout)
struct agent_pvt *p = ast->tech_pvt;
int res = -1;
int newstate=0;
struct ast_channel *chan;
ast_mutex_lock(&p->lock);
p->acknowledged = 0;
if (p->pending) {
ast_log(LOG_DEBUG, "Pretending to dial on pending agent\n");
ast_mutex_unlock(&p->lock);
ast_setstate(ast, AST_STATE_DIALING);
return 0;
}
if (!p->chan) {
if (p->pending) {
ast_debug(1, "Pretending to dial on pending agent\n");
newstate = AST_STATE_DIALING;
res = 0;
} else {
ast_log(LOG_NOTICE, "Whoa, they hung up between alloc and call... what are the odds of that?\n");
res = -1;
}
ast_log(LOG_DEBUG, "Agent disconnected while we were connecting the call\n");
ast_mutex_unlock(&p->lock);
if (newstate)
ast_setstate(ast, newstate);
return res;
}
ast_verb(3, "agent_call, call to agent '%s' call on '%s'\n", p->agent, p->chan->name);
ast_debug(3, "Playing beep, lang '%s'\n", p->chan->language);
res = ast_streamfile(p->chan, beep, p->chan->language);
chan = p->chan;
ast_mutex_unlock(&p->lock);
res = ast_streamfile(chan, beep, chan->language);
ast_debug(3, "Played beep, result '%d'\n", res);
if (!res) {
res = ast_waitstream(p->chan, "");
res = ast_waitstream(chan, "");
ast_debug(3, "Waited for stream, result '%d'\n", res);
}
ast_mutex_lock(&p->lock);
if (!p->chan) {
/* chan went away while we were streaming, this shouldn't be possible */
res = -1;
}
if (!res) {
struct ast_format tmpfmt;
res = ast_set_read_format_from_cap(p->chan, p->chan->nativeformats);
@ -880,6 +895,10 @@ static int agent_hangup(struct ast_channel *ast)
p->app_sleep_cond = 1;
p->acknowledged = 0;
/* Release ownership of the agent to other threads (presumably running the login app). */
p->app_lock_flag = 0;
ast_cond_signal(&p->app_complete_cond);
/* if they really are hung up then set start to 0 so the test
* later if we're called on an already downed channel
* doesn't cause an agent to be logged out like when
@ -930,8 +949,8 @@ static int agent_hangup(struct ast_channel *ast)
p->abouttograb = 0;
} else if (p->dead) {
ast_mutex_destroy(&p->lock);
ast_mutex_destroy(&p->app_lock);
ast_cond_destroy(&p->app_complete_cond);
ast_cond_destroy(&p->login_wait_cond);
ast_free(p);
} else {
if (p->chan) {
@ -941,9 +960,6 @@ static int agent_hangup(struct ast_channel *ast)
p->lastdisc = ast_tvadd(ast_tvnow(), ast_samp2tv(p->wrapuptime, 1000));
ast_mutex_unlock(&p->lock);
}
/* Release ownership of the agent to other threads (presumably running the login app). */
p->app_lock_flag = 0;
ast_cond_signal(&p->app_complete_cond);
}
return 0;
}
@ -1030,7 +1046,6 @@ static struct ast_channel *agent_bridgedchannel(struct ast_channel *chan, struct
static struct ast_channel *agent_new(struct agent_pvt *p, int state, const char *linkedid)
{
struct ast_channel *tmp;
int alreadylocked;
#if 0
if (!p->chan) {
ast_log(LOG_WARNING, "No channel? :(\n");
@ -1068,38 +1083,6 @@ static struct ast_channel *agent_new(struct agent_pvt *p, int state, const char
tmp->tech_pvt = p;
p->owner = tmp;
tmp->priority = 1;
/* Wake up and wait for other applications (by definition the login app)
* to release this channel). Takes ownership of the agent channel
* to this thread only.
* For signalling the other thread, ast_queue_frame is used until we
* can safely use signals for this purpose. The pselect() needs to be
* implemented in the kernel for this.
*/
p->app_sleep_cond = 0;
alreadylocked = p->app_lock_flag;
p->app_lock_flag = 1;
if (alreadylocked) {
if (p->chan) {
ast_queue_frame(p->chan, &ast_null_frame);
ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */
p->app_lock_flag = 1;
ast_mutex_lock(&p->lock);
} else {
ast_log(LOG_WARNING, "Agent disconnected while we were connecting the call\n");
p->owner = NULL;
tmp->tech_pvt = NULL;
p->app_sleep_cond = 1;
tmp = ast_channel_release(tmp);
ast_mutex_unlock(&p->lock); /* For other thread to read the condition. */
p->app_lock_flag = 0;
ast_cond_signal(&p->app_complete_cond);
return NULL;
}
}
if (p->chan)
ast_indicate(p->chan, AST_CONTROL_UNHOLD);
return tmp;
}
@ -1257,8 +1240,8 @@ static int read_agent_config(int reload)
if (!p->owner) {
if (!p->chan) {
ast_mutex_destroy(&p->lock);
ast_mutex_destroy(&p->app_lock);
ast_cond_destroy(&p->app_complete_cond);
ast_cond_destroy(&p->login_wait_cond);
ast_free(p);
} else {
/* Cause them to hang up */
@ -1459,6 +1442,45 @@ static struct ast_channel *agent_request(const char *type, struct ast_format_cap
}
*cause = hasagent ? AST_CAUSE_BUSY : AST_CAUSE_UNREGISTERED;
AST_LIST_UNLOCK(&agents);
if (chan) {
ast_mutex_lock(&p->lock);
if (p->pending) {
ast_mutex_unlock(&p->lock);
return chan;
}
if (!p->chan) {
ast_log(LOG_DEBUG, "Agent disconnected while we were connecting the call\n");
*cause = AST_CAUSE_UNREGISTERED;
ast_mutex_unlock(&p->lock);
agent_hangup(chan);
return NULL;
}
/* we need to take control of the channel from the login app
* thread */
p->app_sleep_cond = 0;
p->app_lock_flag = 1;
ast_queue_frame(p->chan, &ast_null_frame);
ast_cond_wait(&p->login_wait_cond, &p->lock);
if (!p->chan) {
ast_log(LOG_DEBUG, "Agent disconnected while we were connecting the call\n");
p->app_sleep_cond = 1;
p->app_lock_flag = 0;
ast_cond_signal(&p->app_complete_cond);
ast_mutex_unlock(&p->lock);
*cause = AST_CAUSE_UNREGISTERED;
agent_hangup(chan);
return NULL;
}
ast_indicate(p->chan, AST_CONTROL_UNHOLD);
ast_mutex_unlock(&p->lock);
}
return chan;
}
@ -2070,13 +2092,13 @@ static int login_exec(struct ast_channel *chan, const char *data)
}
ast_mutex_unlock(&p->lock);
AST_LIST_UNLOCK(&agents);
/* Synchronize channel ownership between call to agent and itself. */
ast_mutex_lock(&p->app_lock);
ast_mutex_lock(&p->lock);
if (p->app_lock_flag == 1) {
ast_cond_wait(&p->app_complete_cond, &p->app_lock);
ast_cond_signal(&p->login_wait_cond);
ast_cond_wait(&p->app_complete_cond, &p->lock);
}
ast_mutex_unlock(&p->app_lock);
ast_mutex_lock(&p->lock);
ast_mutex_unlock(&p->lock);
if (p->ackcall) {
res = agent_ack_sleep(p);
@ -2094,12 +2116,20 @@ static int login_exec(struct ast_channel *chan, const char *data)
sched_yield();
}
ast_mutex_lock(&p->lock);
if (res && p->owner)
ast_log(LOG_WARNING, "Huh? We broke out when there was still an owner?\n");
/* Log us off if appropriate */
if (p->chan == chan) {
p->chan = NULL;
}
/* Synchronize channel ownership between call to agent and itself. */
if (p->app_lock_flag == 1) {
ast_cond_signal(&p->login_wait_cond);
ast_cond_wait(&p->app_complete_cond, &p->lock);
}
if (res && p->owner)
ast_log(LOG_WARNING, "Huh? We broke out when there was still an owner?\n");
p->acknowledged = 0;
logintime = time(NULL) - p->loginstart;
p->loginstart = 0;
@ -2115,8 +2145,8 @@ static int login_exec(struct ast_channel *chan, const char *data)
ast_devstate_changed(AST_DEVICE_UNAVAILABLE, "Agent/%s", p->agent);
if (p->dead && !p->owner) {
ast_mutex_destroy(&p->lock);
ast_mutex_destroy(&p->app_lock);
ast_cond_destroy(&p->app_complete_cond);
ast_cond_destroy(&p->login_wait_cond);
ast_free(p);
}
}

Write Preview
Loading…
Cancel
Save