Added test for sEstablished before processing incoming updates.

Before disabling a session the Peering Engine now revokes its inbound
queue for the session.  This clears out anything that may have been
queued up to that moment for the session.

After disabling a session, some updates may still arrive, because
it may be a while before the BGP Engine actions the disable, and
stops queueing stuff.  So, Peering Engine must check that the session
is established before processing stuff in the queue.

  modified:   bgpd/bgp_engine.h
  modified:   bgpd/bgp_session.c

2 files changed, 54 insertions, 4 deletions

diff --git a/bgpd/bgp_engine.h b/bgpd/bgp_engine.h
index 7673328c..8d344b22 100644
--- a/bgpd/bgp_engine.h
+++ b/bgpd/bgp_engine.h
@@ -26,6 +26,7 @@
 
 #include "lib/mqueue.h"
 #include "lib/qpnexus.h"
+#include "lib/log.h"
 
 #ifndef Inline
 #define Inline static inline
@@ -37,12 +38,50 @@
  *
  */
 
+static unsigned bgp_engine_queue_thresh_up   = 0 ;
+static unsigned bgp_engine_queue_thresh_down = 0 ;
+static unsigned peering_engine_queue_thresh_up   = 0 ;
+static unsigned peering_engine_queue_thresh_down = 0 ;
+
+Inline void
+bgp_queue_logging(const char* name, unsigned count, unsigned* up,
+                                                    unsigned* down)
+{
+  if (count > *up)
+    {
+      if (*up != 0)
+        {
+          zlog_debug("%s queue up to %u entries", name, count) ;
+
+          *up  *= 2 ;
+          *down = *up / 4 ;
+        }
+      else
+        *up   = 32 ;
+    } ;
+
+  if (count < *down)
+    {
+      zlog_debug("%s queue down to %u entries", name, count) ;
+
+      if (*up == 32)
+        *down = 0 ;
+      else
+        {
+          *up  /= 2 ;
+          *down = *up / 2 ;
+        } ;
+    } ;  ;
+} ;
+
 /* Send given message to the BGP Engine -- ordinary
  */
 Inline void
 bgp_to_bgp_engine(mqueue_block mqb)
 {
   mqueue_enqueue(bgp_nexus->queue, mqb, 0) ;
+  bgp_queue_logging("BGP Engine", bgp_nexus->queue->count,
+                   &bgp_engine_queue_thresh_up, &bgp_engine_queue_thresh_down) ;
 } ;
 
 /* Send given message to the BGP Engine -- priority
@@ -51,6 +90,8 @@ Inline void
 bgp_to_bgp_engine_priority(mqueue_block mqb)
 {
   mqueue_enqueue(bgp_nexus->queue, mqb, 1) ;
+  bgp_queue_logging("BGP Engine", bgp_nexus->queue->count,
+                   &bgp_engine_queue_thresh_up, &bgp_engine_queue_thresh_down) ;
 } ;
 
 /*==============================================================================
@@ -63,6 +104,8 @@ Inline void
 bgp_to_peering_engine(mqueue_block mqb)
 {
   mqueue_enqueue(routing_nexus->queue, mqb, 0) ;
+  bgp_queue_logging("Peering Engine", routing_nexus->queue->count,
+           &peering_engine_queue_thresh_up, &peering_engine_queue_thresh_down) ;
 } ;
 
 /* Send given message to the Peering Engine -- priority
@@ -71,6 +114,8 @@ Inline void
 bgp_to_peering_engine_priority(mqueue_block mqb)
 {
   mqueue_enqueue(routing_nexus->queue, mqb, 1) ;
+  bgp_queue_logging("Peering Engine", routing_nexus->queue->count,
+           &peering_engine_queue_thresh_up, &peering_engine_queue_thresh_down) ;
 } ;
 
 #endif /* QUAGGA_BGP_ENGINE_H */
diff --git a/bgpd/bgp_session.c b/bgpd/bgp_session.c
index 3c89b3f4..2b6a36b4 100644
--- a/bgpd/bgp_session.c
+++ b/bgpd/bgp_session.c
@@ -382,6 +382,11 @@ bgp_session_disable(bgp_peer peer, bgp_notify notification)
       return ;
     } ;
 
+  /* Can revoke whatever may be queued already.  Will revoke again when the
+   * disable is acknowledged to finally clear the session out of the queue.
+   */
+  mqueue_revoke(routing_nexus->queue, session) ;
+
   /* Now change to limping state                                        */
   session->state = bgp_session_sLimping;
   session->defer_enable = 0;
@@ -775,7 +780,7 @@ bgp_session_do_update_recv(mqueue_block mqb, mqb_flag_t flag)
   bgp_session session = mqb_get_arg0(mqb) ;
   struct bgp_session_update_args* args = mqb_get_args(mqb) ;
 
-  if (flag == mqb_action)
+  if ((flag == mqb_action) && (session->state == bgp_session_sEstablished))
     {
       bgp_peer peer = session->peer;
 
@@ -820,7 +825,7 @@ bgp_session_do_route_refresh_recv(mqueue_block mqb, mqb_flag_t flag)
   struct bgp_session_route_refresh_args* args = mqb_get_args(mqb) ;
   bgp_session session = mqb_get_arg0(mqb) ;
 
-  if (flag == mqb_action)
+  if ((flag == mqb_action) && (session->state == bgp_session_sEstablished))
     bgp_route_refresh_recv(session->peer, args->rr);
 
   bgp_route_refresh_free(args->rr);
@@ -850,10 +855,10 @@ bgp_session_XON(bgp_session session)
 static void
 bgp_session_do_XON(mqueue_block mqb, mqb_flag_t flag)
 {
+  bgp_session session = mqb_get_arg0(mqb) ;
 
-  if (flag == mqb_action)
+  if ((flag == mqb_action) && (session->state == bgp_session_sEstablished))
     {
-      bgp_session session = mqb_get_arg0(mqb) ;
       bgp_peer peer = session->peer;
 
       bgp_write (peer);