Merged revisions 303548 via svnmerge from

https://origsvn.digium.com/svn/asterisk/branches/1.6.2

................
  r303548 | russell | 2011-01-24 14:49:53 -0600 (Mon, 24 Jan 2011) | 38 lines

  Merged revisions 303546 via svnmerge from
  https://origsvn.digium.com/svn/asterisk/branches/1.4

  ........
    r303546 | russell | 2011-01-24 14:32:21 -0600 (Mon, 24 Jan 2011) | 31 lines

    Fix channel redirect out of MeetMe() and other issues with channel softhangup.

    Mantis issue #18585 reports that a channel redirect out of MeetMe() stopped
    working properly.  This issue includes a patch that resolves the issue by
    removing a call to ast_check_hangup() from app_meetme.c.  I left that in my
    patch, as it doesn't need to be there.  However, the rest of the patch fixes
    this problem with or without the change to app_meetme.

    The key difference between what happens before and after this patch is the
    effect of the END_OF_Q control frame.  After END_OF_Q is hit in ast_read(),
    ast_read() will return NULL.  With the ast_check_hangup() removed, app_meetme
    sees this which causes it to exit as intended.  Checking ast_check_hangup()
    caused app_meetme to exit earlier in the process, and the target of the
    redirect saw the condition where ast_read() returned NULL.

    Removing ast_check_hangup() works around the issue in app_meetme, but doesn't
    solve the issue if another application did the same thing.  There are also
    other edge cases where if an application finishes at the same time that a
    redirect happens, the target of the redirect will think that the channel hung
    up.  So, I made some changes in pbx.c to resolve it at a deeper level.  There
    are already places that unset the SOFTHANGUP_ASYNCGOTO flag in an attempt to
    abort the hangup process.  My patch extends this to remove the END_OF_Q frame
    from the channel's read queue, making the "abort hangup" more complete.  This
    same technique was used in every place where a softhangup flag was cleared.

    (closes issue #18585)
    Reported by: oej
    Tested by: oej, wedhorn, russell

    Review: https://reviewboard.asterisk.org/r/1082/
  ........
................

git-svn-id: https://origsvn.digium.com/svn/asterisk/branches/1.8@303549 65c4cc65-6c06-0410-ace0-fbb531ad65f3

diff --git a/apps/app_meetme.c b/apps/app_meetme.c
index f816667bfb7f1c3dc0118894b358a852930d30cf..cae8dfd4dab3e942e174dfb326ac5a341f4e7a04 100644 (file)
--- a/apps/app_meetme.c
+++ b/apps/app_meetme.c
@@ -3070,11 +3070,6 @@ static int conf_run(struct ast_channel *chan, struct ast_conference *conf, struc
                                break;
                        }
 
-                       /* Perform an extra hangup check just in case */
-                       if (ast_check_hangup(chan)) {
-                               break;
-                       }
-
                        c = ast_waitfor_nandfds(&chan, 1, &fd, nfds, NULL, &outfd, &ms);
 
                        if (c) {

diff --git a/include/asterisk/channel.h b/include/asterisk/channel.h
index f23fab2863cdae29ad2a13c36021df506026202f..72404574b05a3872ebb73ca743864e574199347e 100644 (file)
--- a/include/asterisk/channel.h
+++ b/include/asterisk/channel.h
@@ -1016,6 +1016,15 @@ enum {
         * instead of actually hanging up.
         */
        AST_SOFTHANGUP_UNBRIDGE =  (1 << 6),
+
+
+       /*!
+        * \brief All softhangup flags.
+        *
+        * This can be used as an argument to ast_channel_softhangup_clear
+        * to clear all softhangup flags from a channel.
+        */
+       AST_SOFTHANGUP_ALL =       (0xFFFFFFFF)
 };
 
 
@@ -1396,6 +1405,20 @@ int ast_softhangup(struct ast_channel *chan, int reason);
  */
 int ast_softhangup_nolock(struct ast_channel *chan, int reason);
 
+/*!
+ * \brief Clear a set of softhangup flags from a channel
+ *
+ * Never clear a softhangup flag from a channel directly.  Instead,
+ * use this function.  This ensures that all aspects of the softhangup
+ * process are aborted.
+ *
+ * \param chan the channel to clear the flag on
+ * \param flag the flag or flags to clear
+ *
+ * \return Nothing.
+ */
+void ast_channel_clear_softhangup(struct ast_channel *chan, int flag);
+
 /*!
  * \brief Set the source of the hangup in this channel and it's bridge
  *

diff --git a/main/channel.c b/main/channel.c
index b3582471dccca99e63bb51e013a0a896944a668f..65ef91b674cfb29b52be65fb42ec8b22c5365c48 100644 (file)
--- a/main/channel.c
+++ b/main/channel.c
@@ -2599,6 +2599,31 @@ void ast_poll_channel_del(struct ast_channel *chan0, struct ast_channel *chan1)
        return;
 }
 
+void ast_channel_clear_softhangup(struct ast_channel *chan, int flag)
+{
+       ast_channel_lock(chan);
+
+       chan->_softhangup &= ~flag;
+
+       if (!chan->_softhangup) {
+               struct ast_frame *fr;
+
+               /* If we have completely cleared the softhangup flag,
+                * then we need to fully abort the hangup process.  This requires
+                * pulling the END_OF_Q frame out of the channel frame queue if it
+                * still happens to be there. */
+
+               fr = AST_LIST_LAST(&chan->readq);
+               if (fr && fr->frametype == AST_FRAME_CONTROL &&
+                               fr->subclass.integer == AST_CONTROL_END_OF_Q) {
+                       AST_LIST_REMOVE(&chan->readq, fr, frame_list);
+                       ast_frfree(fr);
+               }
+       }
+
+       ast_channel_unlock(chan);
+}
+
 /*! \brief Softly hangup a channel, don't lock */
 int ast_softhangup_nolock(struct ast_channel *chan, int cause)
 {
@@ -6806,10 +6831,10 @@ static enum ast_bridge_result ast_generic_bridge(struct ast_channel *c0, struct
                                ast_jb_get_and_deliver(c0, c1);
                        if ((c0->_softhangup | c1->_softhangup) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */
                                if (c0->_softhangup & AST_SOFTHANGUP_UNBRIDGE) {
-                                       c0->_softhangup &= ~AST_SOFTHANGUP_UNBRIDGE;
+                                       ast_channel_clear_softhangup(c0, AST_SOFTHANGUP_UNBRIDGE);
                                }
                                if (c1->_softhangup & AST_SOFTHANGUP_UNBRIDGE) {
-                                       c1->_softhangup &= ~AST_SOFTHANGUP_UNBRIDGE;
+                                       ast_channel_clear_softhangup(c1, AST_SOFTHANGUP_UNBRIDGE);
                                }
                                c0->_bridge = c1;
                                c1->_bridge = c0;
@@ -7150,10 +7175,10 @@ enum ast_bridge_result ast_channel_bridge(struct ast_channel *c0, struct ast_cha
 
                if ((c0->_softhangup | c1->_softhangup) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */
                        if (c0->_softhangup & AST_SOFTHANGUP_UNBRIDGE) {
-                               c0->_softhangup &= ~AST_SOFTHANGUP_UNBRIDGE;
+                               ast_channel_clear_softhangup(c0, AST_SOFTHANGUP_UNBRIDGE);
                        }
                        if (c1->_softhangup & AST_SOFTHANGUP_UNBRIDGE) {
-                               c1->_softhangup &= ~AST_SOFTHANGUP_UNBRIDGE;
+                               ast_channel_clear_softhangup(c1, AST_SOFTHANGUP_UNBRIDGE);
                        }
                        c0->_bridge = c1;
                        c1->_bridge = c0;

diff --git a/main/features.c b/main/features.c
index 4f1301451d55d9d117238c1789239f48d7dcc3b0..efa438d3fe2a0f3210c53f1355571008fe1aa720 100644 (file)
--- a/main/features.c
+++ b/main/features.c
@@ -731,7 +731,7 @@ static void check_goto_on_transfer(struct ast_channel *chan)
        ast_parseable_goto(xferchan, goto_on_transfer);
        xferchan->_state = AST_STATE_UP;
        ast_clear_flag(xferchan, AST_FLAGS_ALL);        
-       xferchan->_softhangup = 0;
+       ast_channel_clear_softhangup(xferchan, AST_SOFTHANGUP_ALL);
        if ((f = ast_read(xferchan))) {
                ast_frfree(f);
                f = NULL;

diff --git a/main/pbx.c b/main/pbx.c
index 92f99fcab8ea83291e094554e32dee1b0ac5f593..6b51bffddd95de63a7db075e046cf2f9e76e069c 100644 (file)
--- a/main/pbx.c
+++ b/main/pbx.c
@@ -4635,7 +4635,7 @@ static int collect_digits(struct ast_channel *c, int waittime, char *buf, int bu
                   keep reading digits until we can't possibly get a right answer anymore.  */
                digit = ast_waitfordigit(c, waittime);
                if (c->_softhangup & AST_SOFTHANGUP_ASYNCGOTO) {
-                       c->_softhangup &= ~AST_SOFTHANGUP_ASYNCGOTO;
+                       ast_channel_clear_softhangup(c, AST_SOFTHANGUP_ASYNCGOTO);
                } else {
                        if (!digit)     /* No entry */
                                break;
@@ -4712,16 +4712,16 @@ static enum ast_pbx_result __ast_pbx_run(struct ast_channel *c,
                                set_ext_pri(c, "T", 0); /* 0 will become 1 with the c->priority++; at the end */
                                /* If the AbsoluteTimeout is not reset to 0, we'll get an infinite loop */
                                memset(&c->whentohangup, 0, sizeof(c->whentohangup));
-                               c->_softhangup &= ~AST_SOFTHANGUP_TIMEOUT;
+                               ast_channel_clear_softhangup(c, AST_SOFTHANGUP_TIMEOUT);
                        } else if ((c->_softhangup & AST_SOFTHANGUP_TIMEOUT)
                                && ast_exists_extension(c, c->context, "e", 1,
                                        S_COR(c->caller.id.number.valid, c->caller.id.number.str, NULL))) {
                                pbx_builtin_raise_exception(c, "ABSOLUTETIMEOUT");
                                /* If the AbsoluteTimeout is not reset to 0, we'll get an infinite loop */
                                memset(&c->whentohangup, 0, sizeof(c->whentohangup));
-                               c->_softhangup &= ~AST_SOFTHANGUP_TIMEOUT;
+                               ast_channel_clear_softhangup(c, AST_SOFTHANGUP_TIMEOUT);
                        } else if (c->_softhangup & AST_SOFTHANGUP_ASYNCGOTO) {
-                               c->_softhangup &= ~AST_SOFTHANGUP_ASYNCGOTO;
+                               ast_channel_clear_softhangup(c, AST_SOFTHANGUP_ASYNCGOTO);
                                continue;
                        } else if (ast_check_hangup(c)) {
                                ast_debug(1, "Extension %s, priority %d returned normally even though call was hung up\n",
@@ -4769,7 +4769,7 @@ static enum ast_pbx_result __ast_pbx_run(struct ast_channel *c,
                                }
 
                                if (c->_softhangup & AST_SOFTHANGUP_ASYNCGOTO) {
-                                       c->_softhangup &= ~AST_SOFTHANGUP_ASYNCGOTO;
+                                       ast_channel_clear_softhangup(c, AST_SOFTHANGUP_ASYNCGOTO);
                                        continue;
                                } else if ((c->_softhangup & AST_SOFTHANGUP_TIMEOUT)
                                        && ast_exists_extension(c, c->context, "T", 1,
@@ -4777,7 +4777,7 @@ static enum ast_pbx_result __ast_pbx_run(struct ast_channel *c,
                                        set_ext_pri(c, "T", 1);
                                        /* If the AbsoluteTimeout is not reset to 0, we'll get an infinite loop */
                                        memset(&c->whentohangup, 0, sizeof(c->whentohangup));
-                                       c->_softhangup &= ~AST_SOFTHANGUP_TIMEOUT;
+                                       ast_channel_clear_softhangup(c, AST_SOFTHANGUP_TIMEOUT);
                                        continue;
                                } else {
                                        if (c->cdr)
@@ -4819,7 +4819,7 @@ static enum ast_pbx_result __ast_pbx_run(struct ast_channel *c,
                        }
                } else if (c->_softhangup & AST_SOFTHANGUP_TIMEOUT) {
                        /* If we get this far with AST_SOFTHANGUP_TIMEOUT, then we know that the "T" extension is next. */
-                       c->_softhangup &= ~AST_SOFTHANGUP_TIMEOUT;
+                       ast_channel_clear_softhangup(c, AST_SOFTHANGUP_TIMEOUT);
                } else {        /* keypress received, get more digits for a full extension */
                        int waittime = 0;
                        if (digit)