#ifndef lint
static char copyright[] =
-"$Id: failover.c,v 1.45 2001/04/20 15:14:40 mellon Exp $ Copyright (c) 1999-2001 The Internet Software Consortium. All rights reserved.\n";
+"$Id: failover.c,v 1.46 2001/04/20 18:11:40 mellon Exp $ Copyright (c) 1999-2001 The Internet Software Consortium. All rights reserved.\n";
#endif /* not lint */
#include "dhcpd.h"
dhcp_failover_link_reference (&state -> link_to_peer,
link, MDL);
- dhcp_failover_send_state (state);
#if 0
- dhcp_failover_state_transition (state, "connect");
+ /* XXX This is probably the right thing to do, but
+ XXX for release three, to make the smallest possible
+ XXX change, we are doing this when the peer state
+ XXX changes instead. */
+ if (state -> me.state == startup)
+ dhcp_failover_set_state (state,
+ state -> saved_state);
+ else
#endif
+ dhcp_failover_send_state (state);
+
if (link -> imsg -> options_present & FTB_MAX_UNACKED)
state -> partner.max_flying_updates =
link -> imsg -> max_unacked;
case unknown_state:
case recover_done:
case startup:
+ case recover_wait:
return dhcp_failover_send_state (state);
}
} else if (!strcmp (name, "startup")) {
state -> nrr = " (paused)";
break;
+ case recover_wait:
+ state -> service_state = not_responding;
+ state -> nrr = " (recover wait)";
+ break;
+
case recover_done:
state -> service_state = not_responding;
state -> nrr = " (recover done)";
resend, just in case. */
if (state -> ack_queue_tail) {
struct lease *lp;
-
+
/* Zap the flags. */
for (lp = state -> ack_queue_head; lp; lp = lp -> next_pending)
lp -> flags = ((lp -> flags & ~ON_ACK_QUEUE) |
ON_UPDATE_QUEUE);
-
+
/* Now hook the ack queue to the beginning of the update
queue. */
if (state -> update_queue_head) {
- lease_reference (&state -> ack_queue_tail -> next_pending,
- state -> update_queue_head, MDL);
- lease_dereference (&state -> update_queue_head, MDL);
+ lease_reference (&state -> ack_queue_tail -> next_pending,
+ state -> update_queue_head, MDL);
+ lease_dereference (&state -> update_queue_head, MDL);
}
lease_reference (&state -> update_queue_head,
state -> ack_queue_head, MDL);
if (!state -> update_queue_tail) {
#if defined (POINTER_DEBUG)
- if (state -> ack_queue_tail -> next_pending) {
- log_error ("next pending on ack queue tail.");
- abort ();
- }
+ if (state -> ack_queue_tail -> next_pending) {
+ log_error ("next pending on ack queue tail.");
+ abort ();
+ }
#endif
- lease_reference (&state -> update_queue_tail,
- state -> ack_queue_tail, MDL);
+ lease_reference (&state -> update_queue_tail,
+ state -> ack_queue_tail, MDL);
}
lease_dereference (&state -> ack_queue_tail, MDL);
lease_dereference (&state -> ack_queue_head, MDL);
}
cancel_timeout (dhcp_failover_keepalive, state);
break;
-
+
case recover:
+ case recover_wait:
+ case recover_done:
case potential_conflict:
case partner_down:
case communications_interrupted:
/* Tentatively make the transition. */
saved_state = state -> me.state;
saved_stos = state -> me.stos;
- state -> me.stos = cur_time;
- state -> me.state = new_state;
+ /* Keep the old stos if we're going into recover_wait. */
+ if (new_state != recover_wait) {
+ state -> me.stos = cur_time;
+ state -> me.state = new_state;
+ }
if (!write_failover_state (state) || !commit_leases ()) {
/* XXX What to do? What to do? */
if (state -> link_to_peer)
dhcp_failover_send_state (state);
- switch (new_state)
- {
- case normal:
- if (state -> partner.state == normal)
- dhcp_failover_state_pool_check (state);
- break;
-
- case potential_conflict:
- if (state -> i_am == primary)
- dhcp_failover_send_update_request (state);
- break;
-
- case startup:
- if (saved_state != startup)
- state -> saved_state = saved_state;
- add_timeout (cur_time + 15,
- dhcp_failover_startup_timeout,
- state,
- (tvref_t)omapi_object_reference,
- (tvunref_t)
- omapi_object_dereference);
- break;
-
- default:
- break;
+ switch (new_state) {
+ case normal:
+ if (state -> partner.state == normal)
+ dhcp_failover_state_pool_check (state);
+ break;
+
+ case potential_conflict:
+ if (state -> i_am == primary)
+ dhcp_failover_send_update_request (state);
+ break;
+
+ case startup:
+ if (saved_state != startup)
+ state -> saved_state = saved_state;
+ add_timeout (cur_time + 15,
+ dhcp_failover_startup_timeout,
+ state,
+ (tvref_t)omapi_object_reference,
+ (tvunref_t)
+ omapi_object_dereference);
+ break;
+
+ /* If we come back in recover_wait and there's still waiting
+ to do, set a timeout. */
+ case recover_wait:
+ if (state -> me.stos + state -> mclt > cur_time)
+ add_timeout ((int)(state -> me.stos + state -> mclt),
+ dhcp_failover_recover_done,
+ state,
+ (tvref_t)omapi_object_reference,
+ (tvunref_t)
+ omapi_object_dereference);
+ break;
+
+ default:
+ break;
}
return ISC_R_SUCCESS;
new_state = msg -> server_state;
startupp = (msg -> server_flags & FTF_STARTUP) ? 1 : 0;
- if (state -> partner.state == new_state)
+ if (state -> partner.state == new_state) {
+ if (state -> me.state == startup)
+ dhcp_failover_set_state (state, state -> saved_state);
return ISC_R_SUCCESS;
+ }
state -> partner.state = new_state;
communications_interrupted);
break;
+ case recover_wait:
case recover_done:
- /* XXX what to do here? */
+ /* We probably don't need to do anything here. */
break;
case unknown_state:
/* We should have asked for an update already. */
case recover_done:
+ case recover_wait:
break;
case unknown_state:
break;
case recover_done:
+ case recover_wait:
case potential_conflict:
case partner_down:
case communications_interrupted:
break;
case recover_done:
+ case recover_wait:
dhcp_failover_set_state (state, normal);
break;
case normal:
case communications_interrupted:
case recover_done:
+ case recover_wait:
/* XXX so we don't need to do this specially in
XXX the CONNECT and CONNECTACK handlers. */
dhcp_failover_set_state (state, normal);
case communications_interrupted:
case resolution_interrupted:
case recover_done:
+ case recover_wait:
dhcp_failover_set_state (state, potential_conflict);
break;
case communications_interrupted:
case resolution_interrupted:
case paused:
+ case recover:
+ case recover_wait:
break;
- case recover:
case shut_down:
dhcp_failover_set_state (state, partner_down);
break;
case paused:
break;
+ /* We still have to wait... */
+ case recover_wait:
+ break;
+
case unknown_state:
break;
}
case recover_done:
return "recover-done";
+ case recover_wait:
+ return "recover-wait";
+
case shut_down:
return "shutdown";
isc_result_t
dhcp_failover_process_update_done (dhcp_failover_state_t *state,
- failover_message_t *msg)
+ failover_message_t *msg)
{
log_info ("failover peer %s: peer update completed.",
state -> name);
case paused:
case recover_done:
case startup:
+ case recover_wait:
break; /* shouldn't happen. */
/* We got the UPDDONE, so we can go into normal state! */
case recover:
if (state -> me.stos + state -> mclt > cur_time) {
+ dhcp_failover_set_state (state, recover_wait);
add_timeout ((int)(state -> me.stos + state -> mclt),
dhcp_failover_recover_done,
state,
projects / thirdparty / dhcp.git / commitdiff
