Merged revisions 314959 via svnmerge from
authorMatthew Nicholson <mnicholson@digium.com>
Fri, 22 Apr 2011 21:33:42 +0000 (21:33 +0000)
committerMatthew Nicholson <mnicholson@digium.com>
Fri, 22 Apr 2011 21:33:42 +0000 (21:33 +0000)
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

channels/chan_agent.c

index 9e1dfed..47df7cb 100644 (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);
                                                }
                                        }