+ if (p > (buff + sizeof(buff))) { // Did we somehow manage to overun the buffer?
+ LOG(0, 0, 0, "FATAL: Overran the heartbeat buffer! This is fatal. Exiting. (size %d)\n", (int) (p - buff));
+ kill(0, SIGTERM);
+ exit(1);
+ }
+
+ //
+ // Fill out the packet with sessions from the session table...
+ // (not forgetting to leave space so we can get some tunnels in too )
+ while ( (p + sizeof(uint32_t) * 2 + sizeof(sessiont) * 2 ) < (buff + MAX_HEART_SIZE) ) {
+
+ if (!walk_session_number) // session #0 isn't valid.
+ ++walk_session_number;
+
+ if (count >= config->cluster_highest_sessionid) // If we're a small cluster, don't go wild.
+ break;
+
+ hb_add_type(&p, C_CSESSION, walk_session_number);
+ walk_session_number = (1+walk_session_number)%(config->cluster_highest_sessionid+1); // +1 avoids divide by zero.
+
+ ++count; // Count the number of extra sessions we're sending.
+ }
+
+ //
+ // Fill out the packet with tunnels from the tunnel table...
+ // This effectively means we walk the tunnel table more quickly
+ // than the session table. This is good because stuffing up a
+ // tunnel is a much bigger deal than stuffing up a session.
+ //
+ while ( (p + sizeof(uint32_t) * 2 + sizeof(tunnelt) ) < (buff + MAX_HEART_SIZE) ) {
+
+ if (!walk_tunnel_number) // tunnel #0 isn't valid.
+ ++walk_tunnel_number;
+
+ if (tcount >= config->cluster_highest_tunnelid)
+ break;
+
+ hb_add_type(&p, C_CTUNNEL, walk_tunnel_number);
+ walk_tunnel_number = (1+walk_tunnel_number)%(config->cluster_highest_tunnelid+1); // +1 avoids divide by zero.
+
+ ++tcount;
+ }
+
+ //
+ // Did we do something wrong?
+ if (p > (buff + sizeof(buff))) { // Did we somehow manage to overun the buffer?
+ LOG(0, 0, 0, "Overran the heartbeat buffer now! This is fatal. Exiting. (size %d)\n", (int) (p - buff));
+ kill(0, SIGTERM);
+ exit(1);
+ }
+
+ LOG(3, 0, 0, "Sending v%d heartbeat #%d, change #%" PRIu64 " with %d changes "
+ "(%d x-sess, %d x-tunnels, %d highsess, %d hightun, size %d)\n",
+ HB_VERSION, h.seq, h.table_version, config->cluster_num_changes,
+ count, tcount, config->cluster_highest_sessionid,
+ config->cluster_highest_tunnelid, (int) (p - buff));
+
+ config->cluster_num_changes = 0;
+
+ send_heartbeat(h.seq, buff, (p-buff) ); // Send out the heartbeat to the cluster, keeping a copy of it.
+
+ config->cluster_seq_number = (config->cluster_seq_number+1)%HB_MAX_SEQ; // Next seq number to use.
+}
+
+//
+// A structure of type 'type' has changed; Add it to the queue to send.
+//
+static int type_changed(int type, int id)
+{
+ int i;
+
+ for (i = 0 ; i < config->cluster_num_changes ; ++i)
+ if ( cluster_changes[i].id == id &&
+ cluster_changes[i].type == type)
+ return 0; // Already marked for change.
+
+ cluster_changes[i].type = type;
+ cluster_changes[i].id = id;
+ ++config->cluster_num_changes;
+
+ if (config->cluster_num_changes > MAX_CHANGES)
+ cluster_heartbeat(); // flush now
+
+ return 1;
+}
+
+
+// A particular session has been changed!
+int cluster_send_session(int sid)
+{
+ if (!config->cluster_iam_master) {
+ LOG(0, sid, 0, "I'm not a master, but I just tried to change a session!\n");
+ return -1;
+ }
+
+ return type_changed(C_CSESSION, sid);
+}
+
+// A particular tunnel has been changed!
+int cluster_send_tunnel(int tid)
+{
+ if (!config->cluster_iam_master) {
+ LOG(0, 0, tid, "I'm not a master, but I just tried to change a tunnel!\n");
+ return -1;
+ }
+
+ return type_changed(C_CTUNNEL, tid);
+}
+
+
+//
+// We're a master, and a slave has just told us that it's
+// missed a packet. We'll resend it every packet since
+// the last one it's seen.
+//
+static int cluster_catchup_slave(int seq, in_addr_t slave)
+{
+ int s;
+ int diff;
+
+ LOG(1, 0, 0, "Slave %s sent LASTSEEN with seq %d\n", fmtaddr(slave, 0), seq);
+
+ diff = config->cluster_seq_number - seq; // How many packet do we need to send?
+ if (diff < 0)
+ diff += HB_MAX_SEQ;
+
+ if (diff >= HB_HISTORY_SIZE) { // Ouch. We don't have the packet to send it!
+ LOG(0, 0, 0, "A slave asked for message %d when our seq number is %d. Killing it.\n",
+ seq, config->cluster_seq_number);
+ return peer_send_message(slave, C_KILL, seq, NULL, 0);// Kill the slave. Nothing else to do.
+ }
+
+ // Now resend every packet that it missed, in order.
+ while (seq != config->cluster_seq_number) {
+ 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);
+ return -1; // What to do here!?
+ }
+ peer_send_data(slave, past_hearts[s].data, past_hearts[s].size);
+ seq = (seq+1)%HB_MAX_SEQ; // Increment to next seq number.
+ }
+ return 0; // All good!
+}
+
+//
+// We've heard from another peer! Add it to the list
+// that we select from at election time.
+//
+static int cluster_add_peer(in_addr_t peer, time_t basetime, pingt *pp, int size)
+{
+ int i;
+ in_addr_t clusterid;
+ pingt p;
+
+ // Allow for backward compatability.
+ // Just the ping packet into a new structure to allow
+ // for the possibility that we might have received
+ // more or fewer elements than we were expecting.
+ if (size > sizeof(p))
+ size = sizeof(p);
+
+ memset( (void *) &p, 0, sizeof(p) );
+ memcpy( (void *) &p, (void *) pp, size);
+
+ clusterid = p.addr;
+ if (clusterid != config->bind_address)
+ {
+ // Is this for us?
+ LOG(4, 0, 0, "Skipping ping from %s (different cluster)\n", fmtaddr(peer, 0));
+ return 0;
+ }
+
+ for (i = 0; i < num_peers ; ++i)
+ {
+ if (peers[i].peer != peer)
+ continue;
+
+ // This peer already exists. Just update the timestamp.
+ peers[i].basetime = basetime;
+ peers[i].timestamp = TIME;
+ peers[i].uptodate = !p.undef;
+ break;
+ }
+
+ // Is this the master shutting down??
+ if (peer == config->cluster_master_address && !basetime) {
+ LOG(3, 0, 0, "Master %s shutting down...\n", fmtaddr(config->cluster_master_address, 0));
+ config->cluster_master_address = 0;
+ config->cluster_last_hb = 0; // Force an election.
+ cluster_check_master();
+ return 0;
+ }
+
+ if (i >= num_peers)
+ {
+ LOG(4, 0, 0, "Adding %s as a peer\n", fmtaddr(peer, 0));
+
+ // Not found. Is there a stale slot to re-use?
+ for (i = 0; i < num_peers ; ++i)
+ {
+ if (!peers[i].basetime) // Shutdown
+ break;
+
+ if ((peers[i].timestamp + config->cluster_hb_timeout * 10) < TIME) // Stale.
+ break;
+ }
+
+ if (i >= CLUSTER_MAX_SIZE)
+ {
+ // Too many peers!!
+ LOG(0, 0, 0, "Tried to add %s as a peer, but I already have %d of them!\n", fmtaddr(peer, 0), i);
+ return -1;
+ }
+
+ peers[i].peer = peer;
+ peers[i].basetime = basetime;
+ peers[i].timestamp = TIME;
+ peers[i].uptodate = !p.undef;
+ if (i == num_peers)
+ ++num_peers;
+
+ LOG(1, 0, 0, "Added %s as a new peer. Now %d peers\n", fmtaddr(peer, 0), num_peers);
+ }
+
+ return 1;
+}
+
+/* Handle the slave updating the byte counters for the master. */
+//
+// Note that we don't mark the session as dirty; We rely on
+// the slow table walk to propogate this back out to the slaves.
+//
+static int cluster_handle_bytes(char *data, int size)
+{
+ bytest *b;
+
+ b = (bytest *) data;
+
+ LOG(3, 0, 0, "Got byte counter update (size %d)\n", size);
+
+ /* Loop around, adding the byte
+ counts to each of the sessions. */
+
+ while (size >= sizeof(*b) ) {
+ if (b->sid > MAXSESSION) {
+ LOG(0, 0, 0, "Got C_BYTES with session #%d!\n", b->sid);
+ return -1; /* Abort processing */
+ }
+
+ session[b->sid].total_cin += b->in;
+ session[b->sid].total_cout += b->out;
+
+ session[b->sid].cin += b->in;
+ session[b->sid].cout += b->out;
+ session[b->sid].last_packet = time_now; // Reset idle timer!
+
+ size -= sizeof(*b);
+ ++b;
+ }
+
+ if (size != 0)
+ LOG(0, 0, 0, "Got C_BYTES with %d bytes of trailing junk!\n", size);
+
+ return size;
+}
+
+//
+// Handle receiving a session structure in a heartbeat packet.
+//
+static int cluster_recv_session(int more, uint8_t *p)
+{
+ if (more >= MAXSESSION) {
+ LOG(0, 0, 0, "DANGER: Received a heartbeat session id > MAXSESSION!\n");
+ return -1;
+ }
+
+ if (session[more].tunnel == T_UNDEF) {
+ if (config->cluster_iam_uptodate) { // Sanity.
+ LOG(0, 0, 0, "I thought I was uptodate but I just found an undefined session!\n");
+ } else {
+ --config->cluster_undefined_sessions;
+ }
+ }
+
+ load_session(more, (sessiont *) p); // Copy session into session table..
+
+ LOG(5, more, 0, "Received session update (%d undef)\n", config->cluster_undefined_sessions);
+
+ if (!config->cluster_iam_uptodate)
+ cluster_uptodate(); // Check to see if we're up to date.
+
+ return 0;
+}
+
+static int cluster_recv_tunnel(int more, uint8_t *p)
+{
+ if (more >= MAXTUNNEL) {
+ LOG(0, 0, 0, "DANGER: Received a tunnel session id > MAXTUNNEL!\n");
+ return -1;
+ }
+
+ if (tunnel[more].state == TUNNELUNDEF) {
+ if (config->cluster_iam_uptodate) { // Sanity.
+ LOG(0, 0, 0, "I thought I was uptodate but I just found an undefined tunnel!\n");
+ } else {
+ --config->cluster_undefined_tunnels;
+ }
+ }
+
+ memcpy(&tunnel[more], p, sizeof(tunnel[more]) );
+
+ //
+ // Clear tunnel control messages. These are dynamically allocated.
+ // If we get unlucky, this may cause the tunnel to drop!
+ //
+ tunnel[more].controls = tunnel[more].controle = NULL;
+ tunnel[more].controlc = 0;
+
+ LOG(5, 0, more, "Received tunnel update\n");
+
+ if (!config->cluster_iam_uptodate)
+ cluster_uptodate(); // Check to see if we're up to date.
+
+ return 0;
+}
+
+
+//
+// Process a heartbeat..
+//
+// v3: added interval, timeout
+// v4: added table_version
+static int cluster_process_heartbeat(uint8_t *data, int size, int more, uint8_t *p, in_addr_t addr)
+{
+ heartt *h;
+ int s = size - (p-data);
+ int i, type;
+
+#if HB_VERSION != 4
+# error "need to update cluster_process_heartbeat()"
+#endif
+
+ // we handle versions 3 through 4
+ if (more < 3 || more > HB_VERSION) {
+ LOG(0, 0, 0, "Received a heartbeat version that I don't support (%d)!\n", more);
+ return -1; // Ignore it??
+ }
+
+ // Ok. It's a heartbeat packet from a cluster master!
+ if (s < sizeof(*h))
+ goto shortpacket;
+
+ h = (heartt *) p;
+ p += sizeof(*h);
+ s -= sizeof(*h);
+
+ if (h->clusterid != config->bind_address)
+ return -1; // It's not part of our cluster.
+
+ if (config->cluster_iam_master) { // Sanity...
+ // Note that this MUST match the election process above!
+
+ LOG(0, 0, 0, "I just got a heartbeat from master %s, but _I_ am the master!\n", fmtaddr(addr, 0));
+ if (!h->basetime) {
+ LOG(0, 0, 0, "Heartbeat with zero basetime! Ignoring\n");
+ return -1; // Skip it.
+ }
+
+ if (more >= 4) {
+ if (h->table_version > config->cluster_table_version) {
+ LOG(0, 0, 0, "They've seen more state changes (%" PRIu64 " vs my %" PRIu64 ") so I'm gone!\n",
+ h->table_version, config->cluster_table_version);
+
+ kill(0, SIGTERM);
+ exit(1);
+ }
+ if (h->table_version < config->cluster_table_version)
+ return -1;
+ }
+
+ if (basetime > h->basetime) {
+ LOG(0, 0, 0, "They're an older master than me so I'm gone!\n");
+ kill(0, SIGTERM);
+ exit(1);
+ }
+
+ if (basetime < h->basetime)
+ return -1;
+
+ if (my_address < addr) { // Tie breaker.
+ LOG(0, 0, 0, "They're a higher IP address than me, so I'm gone!\n");
+ kill(0, SIGTERM);
+ exit(1);
+ }
+
+ return -1; // Skip it.
+ }
+
+ if (config->cluster_seq_number == -1) // Don't have one. Just align to the master...
+ config->cluster_seq_number = h->seq;
+
+ config->cluster_last_hb = TIME; // Reset to ensure that we don't become master!!
+
+ if (config->cluster_seq_number != h->seq) { // Out of sequence heartbeat!
+ static int lastseen_seq = 0;
+ static time_t lastseen_time = 0;
+
+ // limit to once per second for a particular seq#
+ int ask = (config->cluster_seq_number != lastseen_seq || time_now != lastseen_time);
+
+ LOG(1, 0, 0, "HB: Got seq# %d but was expecting %d. %s.\n",
+ h->seq, config->cluster_seq_number,
+ ask ? "Asking for resend" : "Ignoring");
+
+ if (ask)
+ {
+ lastseen_seq = config->cluster_seq_number;
+ lastseen_time = time_now;
+ peer_send_message(addr, C_LASTSEEN, config->cluster_seq_number, NULL, 0);
+ }
+
+ config->cluster_last_hb = TIME; // Reset to ensure that we don't become master!!
+
+ // Just drop the packet. The master will resend it as part of the catchup.
+
+ return 0;
+ }
+ // Save the packet in our buffer.
+ // This is needed in case we become the master.
+ config->cluster_seq_number = (h->seq+1)%HB_MAX_SEQ;
+ i = h->seq % HB_HISTORY_SIZE;
+ past_hearts[i].seq = h->seq;
+ past_hearts[i].size = size;
+ memcpy(&past_hearts[i].data, data, size); // Save it.
+
+
+ // Check that we don't have too many undefined sessions, and
+ // that the free session pointer is correct.
+ cluster_check_sessions(h->highsession, h->freesession, h->hightunnel);
+
+ if (h->interval != config->cluster_hb_interval)
+ {
+ LOG(2, 0, 0, "Master set ping/heartbeat interval to %u (was %u)\n",
+ h->interval, config->cluster_hb_interval);
+
+ config->cluster_hb_interval = h->interval;
+ }
+
+ if (h->timeout != config->cluster_hb_timeout)
+ {
+ LOG(2, 0, 0, "Master set heartbeat timeout to %u (was %u)\n",
+ h->timeout, config->cluster_hb_timeout);
+
+ config->cluster_hb_timeout = h->timeout;
+ }
+
+ // Ok. process the packet...
+ while ( s > 0) {
+
+ type = *((uint32_t *) p);
+ p += sizeof(uint32_t);
+ s -= sizeof(uint32_t);
+
+ more = *((uint32_t *) p);
+ p += sizeof(uint32_t);
+ s -= sizeof(uint32_t);
+
+ switch (type) {
+ case C_CSESSION: { // Compressed session structure.
+ uint8_t c[ sizeof(sessiont) + 2];
+ int size;
+ uint8_t *orig_p = p;
+
+ size = rle_decompress((uint8_t **) &p, s, c, sizeof(c) );
+ s -= (p - orig_p);
+
+ if (size != sizeof(sessiont) ) { // Ouch! Very very bad!
+ LOG(0, 0, 0, "DANGER: Received a CSESSION that didn't decompress correctly!\n");
+ // Now what? Should exit! No-longer up to date!
+ break;
+ }
+
+ cluster_recv_session(more, c);
+ break;
+ }
+ case C_SESSION:
+ if ( s < sizeof(session[more]))
+ goto shortpacket;
+
+ cluster_recv_session(more, p);
+
+ p += sizeof(session[more]);
+ s -= sizeof(session[more]);
+ break;
+
+ case C_CTUNNEL: { // Compressed tunnel structure.
+ uint8_t c[ sizeof(tunnelt) + 2];
+ int size;
+ uint8_t *orig_p = p;
+
+ size = rle_decompress((uint8_t **) &p, s, c, sizeof(c));
+ s -= (p - orig_p);
+
+ if (size != sizeof(tunnelt) ) { // Ouch! Very very bad!
+ LOG(0, 0, 0, "DANGER: Received a CSESSION that didn't decompress correctly!\n");
+ // Now what? Should exit! No-longer up to date!
+ break;
+ }
+
+ cluster_recv_tunnel(more, c);
+ break;
+
+ }
+ case C_TUNNEL:
+ if ( s < sizeof(tunnel[more]))
+ goto shortpacket;
+
+ cluster_recv_tunnel(more, p);
+
+ p += sizeof(tunnel[more]);
+ s -= sizeof(tunnel[more]);
+ break;
+ default:
+ LOG(0, 0, 0, "DANGER: I received a heartbeat element where I didn't understand the type! (%d)\n", type);
+ return -1; // can't process any more of the packet!!
+ }
+ }
+
+ if (config->cluster_master_address != addr)
+ {
+ LOG(0, 0, 0, "My master just changed from %s to %s!\n",
+ fmtaddr(config->cluster_master_address, 0), fmtaddr(addr, 1));
+
+ config->cluster_master_address = addr;
+ }
+
+ config->cluster_last_hb = TIME; // Successfully received a heartbeat!
+ config->cluster_table_version = h->table_version;
+ return 0;
+
+shortpacket:
+ LOG(0, 0, 0, "I got an incomplete heartbeat packet! This means I'm probably out of sync!!\n");
projects / l2tpns.git / blobdiff