multicast disaster mitigation
[l2tpns.git] / cluster.c
index 7e69f05..6f72394 100644 (file)
--- a/cluster.c
+++ b/cluster.c
@@ -1,6 +1,6 @@
 // L2TPNS Clustering Stuff
 
-char const *cvs_id_cluster = "$Id: cluster.c,v 1.27 2004/12/20 07:23:42 bodea Exp $";
+char const *cvs_id_cluster = "$Id: cluster.c,v 1.26.2.6 2005/05/21 13:05:36 bodea Exp $";
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -38,12 +38,11 @@ char const *cvs_id_cluster = "$Id: cluster.c,v 1.27 2004/12/20 07:23:42 bodea Ex
  */
 
 // Module variables.
-int cluster_sockfd = 0;                        // The filedescriptor for the cluster communications port.
+int cluster_sockfd = 0;                // The filedescriptor for the cluster communications port.
 
 in_addr_t my_address = 0;              // The network address of my ethernet port.
 static int walk_session_number = 0;    // The next session to send when doing the slow table walk.
 static int walk_tunnel_number = 0;     // The next tunnel to send when doing the slow table walk.
-int forked = 0;                                // Sanity check: CLI must not diddle with heartbeat table
 
 #define MAX_HEART_SIZE (8192)  // Maximum size of heartbeat packet. Must be less than max IP packet size :)
 #define MAX_CHANGES  (MAX_HEART_SIZE/(sizeof(sessiont) + sizeof(int) ) - 2)    // Assumes a session is the biggest type!
@@ -406,18 +405,18 @@ void master_update_counts(void)
                if ( walk_session_number > config->cluster_highest_sessionid)
                        walk_session_number = 1;
 
-               if (!sess_count[walk_session_number].cin && !sess_count[walk_session_number].cout)
+               if (!sess_local[walk_session_number].cin && !sess_local[walk_session_number].cout)
                        continue; // Unused. Skip it.
 
                b[c].sid = walk_session_number;
-               b[c].in = sess_count[walk_session_number].cin;
-               b[c].out = sess_count[walk_session_number].cout;
+               b[c].in = sess_local[walk_session_number].cin;
+               b[c].out = sess_local[walk_session_number].cout;
 
                if (++c > MAX_B_RECS)   // Send a max of 400 elements in a packet.
                        break;
 
                        // Reset counters.
-               sess_count[walk_session_number].cin = sess_count[walk_session_number].cout = 0;
+               sess_local[walk_session_number].cin = sess_local[walk_session_number].cout = 0;
        }
 
        if (!c)         // Didn't find any that changes. Get out of here!
@@ -486,14 +485,15 @@ void cluster_check_master(void)
 
        // If the master is late (missed 2 hearbeats by a second and a
        // hair) it may be that the switch has dropped us from the
-       // multicast group, try unicasting one probe to the master
+       // multicast group, try unicasting probes to the master
        // which will hopefully respond with a unicast heartbeat that
        // will allow us to limp along until the querier next runs.
-       if (TIME > (config->cluster_last_hb + 2 * config->cluster_hb_interval + 11))
+       if (config->cluster_master_address
+           && TIME > (config->cluster_last_hb + 2 * config->cluster_hb_interval + 11))
        {
-               if (!probed && config->cluster_master_address)
+               if (!probed || (TIME > (probed + 2 * config->cluster_hb_interval)))
                {
-                       probed = 1;
+                       probed = TIME;
                        LOG(1, 0, 0, "Heartbeat from master %.1fs late, probing...\n",
                                0.1 * (TIME - (config->cluster_last_hb + config->cluster_hb_interval)));
 
@@ -571,38 +571,42 @@ void cluster_check_master(void)
                        ++count;
                }
 
-               if (session[i].tunnel == T_FREE) { // Unused session. Add to free list.
+               if (!session[i].opened) { // Unused session. Add to free list.
+                       memset(&session[i], 0, sizeof(session[i]));
+                       session[i].tunnel = T_FREE;
                        session[last_free].next = i;
                        session[i].next = 0;
                        last_free = i;
+                       continue;
                }
 
-                       // Reset all the idle timeouts..
+                       // Reset idle timeouts..
                session[i].last_packet = time_now;
 
+                       // Reset die relative to our uptime rather than the old master's
+               if (session[i].die) session[i].die = TIME;
+
                        // Accumulate un-sent byte counters.
-               session[i].cin += sess_count[i].cin;
-               session[i].cout += sess_count[i].cout;
-               session[i].total_cin += sess_count[i].cin;
-               session[i].total_cout += sess_count[i].cout;
+               session[i].cin += sess_local[i].cin;
+               session[i].cout += sess_local[i].cout;
+               session[i].total_cin += sess_local[i].cin;
+               session[i].total_cout += sess_local[i].cout;
 
-               sess_count[i].cin = sess_count[i].cout = 0;
+               sess_local[i].cin = sess_local[i].cout = 0;
 
                session[i].radius = 0;  // Reset authentication as the radius blocks aren't up to date.
 
                if (session[i].unique_id >= high_unique_id)     // This is different to the index into the session table!!!
                        high_unique_id = session[i].unique_id+1;
 
-
                session[i].tbf_in = session[i].tbf_out = 0; // Remove stale pointers from old master.
                throttle_session(i, session[i].throttle_in, session[i].throttle_out);
 
-               if (session[i].tunnel != T_FREE && i > config->cluster_highest_sessionid)
-                       config->cluster_highest_sessionid = i;
+               config->cluster_highest_sessionid = i;
        }
 
        session[last_free].next = 0;    // End of chain.
-       last_id = high_unique_id;               // Keep track of the highest used session ID.
+       last_id = high_unique_id;       // Keep track of the highest used session ID.
 
        become_master();
 
@@ -618,6 +622,11 @@ void cluster_check_master(void)
 
        if (!num_peers) // lone master
                advertise();
+#ifdef BGP
+       else if (bgp_configured)
+               bgp_enable_routing(0);
+#endif /* BGP */
+
 
        // FIXME. We need to fix up the tunnel control message
        // queue here! There's a number of other variables we
@@ -650,12 +659,12 @@ static void cluster_check_sessions(int highsession, int freesession_ptr, int hig
        config->cluster_undefined_sessions = 0;
        for (i = 1 ; i < MAXSESSION; ++i) {
                if (i > highsession) {
-                       session[i].tunnel = 0; // Defined.
+                       if (session[i].tunnel == T_UNDEF) session[i].tunnel = T_FREE; // Defined.
                        continue;
                }
-               if (session[i].tunnel != T_UNDEF)
-                       continue;
-               ++config->cluster_undefined_sessions;
+
+               if (session[i].tunnel == T_UNDEF)
+                       ++config->cluster_undefined_sessions;
        }
 
                // Clear out defined tunnels, counting the number of
@@ -663,12 +672,12 @@ static void cluster_check_sessions(int highsession, int freesession_ptr, int hig
        config->cluster_undefined_tunnels = 0;
        for (i = 1 ; i < MAXTUNNEL; ++i) {
                if (i > hightunnel) {
-                       tunnel[i].state = TUNNELFREE; // Defined.
+                       if (tunnel[i].state == TUNNELUNDEF) tunnel[i].state = TUNNELFREE; // Defined.
                        continue;
                }
-               if (tunnel[i].state != TUNNELUNDEF)
-                       continue;
-               ++config->cluster_undefined_tunnels;
+
+               if (tunnel[i].state == TUNNELUNDEF)
+                       ++config->cluster_undefined_tunnels;
        }
 
 
@@ -867,11 +876,6 @@ int cluster_send_session(int sid)
                return -1;
        }
 
-       if (forked) {
-               LOG(0, sid, 0, "cluster_send_session called from child process!"\n");
-               return -1;
-       }
-
        return type_changed(C_CSESSION, sid);
 }
 
@@ -898,6 +902,14 @@ static int cluster_catchup_slave(int seq, in_addr_t slave)
        int diff;
 
        LOG(1, 0, 0, "Slave %s sent LASTSEEN with seq %d\n", fmtaddr(slave, 0), seq);
+       if (!config->cluster_iam_master) {
+               LOG(1, 0, 0, "Got LASTSEEN but I'm not a master! Sending a null PING.\n");
+                       // Send a ping to the stray slave saying that we're a master that's
+                       // just shutdown. This should force the slave to listen for the real
+                       // master.
+               peer_send_message(slave, C_PING, 0, NULL, 0);
+               return 0;
+       }
 
        diff = config->cluster_seq_number - seq;        // How many packet do we need to send?
        if (diff < 0)
@@ -909,9 +921,11 @@ static int cluster_catchup_slave(int seq, in_addr_t slave)
                return peer_send_message(slave, C_KILL, seq, NULL, 0);// Kill the slave. Nothing else to do.
        }
 
+       LOG(1, 0, 0, "Sending %d catchup packets to slave %s\n", diff, fmtaddr(slave, 0) );
+
                // Now resend every packet that it missed, in order.
        while (seq != config->cluster_seq_number) {
-               s = seq%HB_HISTORY_SIZE;
+               s = seq % HB_HISTORY_SIZE;
                if (seq != past_hearts[s].seq) {
                        LOG(0, 0, 0, "Tried to re-send heartbeat for %s but %d doesn't match %d! (%d,%d)\n",
                                fmtaddr(slave, 0), seq, past_hearts[s].seq, s, config->cluster_seq_number);
@@ -1033,7 +1047,9 @@ static int cluster_handle_bytes(char *data, int size)
 
                session[b->sid].cin += b->in;
                session[b->sid].cout += b->out;
-               session[b->sid].last_packet = time_now; // Reset idle timer!
+
+               if (b->in)
+                       session[b->sid].last_packet = time_now; // Reset idle timer!
 
                size -= sizeof(*b);
                ++b;
@@ -1174,9 +1190,33 @@ static int cluster_process_heartbeat(uint8_t *data, int size, int more, uint8_t
                        exit(1);
                }
 
+                       //
+                       // Send it a unicast heartbeat to see give it a chance to die.
+                       // NOTE: It's actually safe to do seq-number - 1 without checking
+                       // for wrap around.
+                       //
+               cluster_catchup_slave(config->cluster_seq_number - 1, addr);
+
                return -1; // Skip it.
        }
 
+               //
+               // Try and guard against a stray master appearing.
+               //
+               // Ignore heartbeats received from another master before the
+               // timeout (less a smidgen) for the old master has elapsed.
+               //
+               // Note that after a clean failover, the cluster_master_address
+               // is cleared, so this doesn't run. 
+               //
+       if (config->cluster_master_address && addr != config->cluster_master_address
+           && (config->cluster_last_hb + config->cluster_hb_timeout - 11) > TIME) {
+                   LOG(0, 0, 0, "Ignoring stray heartbeat from %s, current master %s has not yet timed out (last heartbeat %.1f seconds ago).\n",
+                           fmtaddr(addr, 0), fmtaddr(config->cluster_master_address, 1),
+                           0.1 * (TIME - config->cluster_last_hb));
+                   return -1; // ignore
+       }
+
        if (config->cluster_seq_number == -1)   // Don't have one. Just align to the master...
                config->cluster_seq_number = h->seq;