emo/ndhc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c8dd123a5d
ndhc/src/state.c

745 lines
27 KiB
C
Raw Normal View History

Relicense under New BSD (2-clause) license. I don't see any advantage to restricting use unnecessarily, and simple attribution is fine.
2011-07-25 12:00:57 +05:30
/* state.c - high level DHCP state machine
*
Update copyright dates to 2017.
2017-01-12 17:00:44 +05:30
* Copyright (c) 2011-2017 Nicholas J. Kain <njkain at gmail dot com>
Relicense under New BSD (2-clause) license. I don't see any advantage to restricting use unnecessarily, and simple attribution is fine.
2011-07-25 12:00:57 +05:30
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
Update to latest ncmlib changes.
2014-03-31 02:32:48 +05:30
#include "nk/log.h"
#include "nk/random.h"
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
#include "state.h"
#include "ifchange.h"
#include "arp.h"
#include "options.h"
Use a unified epoll_(add|del)(). Also, background() and setup_signals_ndhc() are moved from sys.c to ndhc.c. background() also no longer attempts to re-configure signals; signals are always set up on initial ndhc initialization.
2014-03-13 02:21:10 +05:30
#include "ndhc.h"
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
#include "sys.h"
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
#include "netlink.h"
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
#include "coroutine.h"
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
#define SEL_SUCCESS 0
#define SEL_FAIL -1
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
#define REQ_SUCCESS 0
#define REQ_TIMEOUT -1
#define REQ_FAIL -2
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
#define ANP_SUCCESS 0
#define ANP_IGNORE -1
#define ANP_REJECTED -2
#define ANP_CHECK_IP -3
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
#define BTO_WAIT 0
#define BTO_EXPIRED -1
#define BTO_HARDFAIL -2
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
#define IFUP_REVALIDATE 0
#define IFUP_NEWLEASE 1
#define IFUP_FAIL -1
cs->packetNum is not descriptive and is not used outside of state.c. Rename it to num_dhcp_requests that is a static global to state.c.
2011-07-06 01:14:11 +05:30
Indicate that client_state_t and client_config_t pointer args cannot ever be null. Could possibly improve code generation, and makes the intention clear.
2015-02-14 08:59:03 +05:30
static int delay_timeout(struct client_state_t cs[static 1], size_t numpackets)
Use an RFC2131-compliant exponential backoff delay.
2011-06-30 12:57:57 +05:30
{
int to = 64;
char tot[] = { 4, 8, 16, 32, 64 };
if (numpackets < sizeof tot)
to = tot[numpackets];
Replace the remaining calls to rand() with nk_random_u32().
2014-03-22 11:38:23 +05:30
// Distribution is a bit biased but it doesn't really matter.
Update to the new ncmlib random API.
2017-08-24 12:06:31 +05:30
return to * 1000 + (nk_random_u32(&cs->rnd_state) & 0x7fffffffu) % 1000;
Use an RFC2131-compliant exponential backoff delay.
2011-06-30 12:57:57 +05:30
}
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
static void reinit_shared_deconfig(struct client_state_t cs[static 1])
Move dhcp state handling code out of netlink.c and into state.c. netlink.c now just calls hooks exposed by state.c, just like the dhcp packet, poll timeout, and signal code. Make ifchange_deconfig() idempotent.
2011-07-05 07:40:14 +05:30
{
cs->clientAddr = 0;
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
cs->num_dhcp_requests = 0;
Convert logically boolean client_state_t variables from uint8_t to bool.
2017-01-19 15:31:23 +05:30
cs->got_router_arp = false;
cs->got_server_arp = false;
reinit_shared_deconfig() was not resetting state completely. Newer flags were not being restored properly.
2017-02-27 21:40:14 +05:30
cs->check_fingerprint = false;
cs->sent_gw_query = false;
cs->sent_first_announce = false;
cs->sent_second_announce = false;
state: Faster recovery when carrier lost during DHCP init. If carrier is lost before network fingerprinting is complete, we have a few problems; first, we don't know whether the network has changed underneath us. Second, we've not yet configured the interface properties, and it is not unlikely that doing so will fail as the underlying network device may have been destroyed and recreated during this time (eg, if ethtool has been run at start-up time). Thus, the safest reaction is to terminate and force a supervisor respawn. It is best to do this once carrier recovers, not when the carrier is lost, as it is more likely to minimize delays.
2017-04-10 19:27:52 +05:30
cs->init_fingerprint_inprogress = false;
Record the MAC address of the DHCP server and use it to identify the network when the hardware link carrier is dropped and comes back. Also, don't assume that all networks have a default gateway. Guard against spurious arp defense attempts that might be triggered by packets that are still in the socket buffer from before the BPF was changed. Split apart the AS_GW_CHECK and AS_GW_QUERY timeout handlers. Cosmetic cleanups in state.c.
2011-07-11 22:54:59 +05:30
memset(&cs->routerArp, 0, sizeof cs->routerArp);
memset(&cs->serverArp, 0, sizeof cs->serverArp);
reinit_shared_deconfig() was not fully resetting arp state.
2017-02-27 22:00:35 +05:30
arp_reset_state(cs);
Record the MAC address of the DHCP server and use it to identify the network when the hardware link carrier is dropped and comes back. Also, don't assume that all networks have a default gateway. Guard against spurious arp defense attempts that might be triggered by packets that are still in the socket buffer from before the BPF was changed. Split apart the AS_GW_CHECK and AS_GW_QUERY timeout handlers. Cosmetic cleanups in state.c.
2011-07-11 22:54:59 +05:30
}
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
static void reinit_selecting(struct client_state_t cs[static 1], int timeout)
Record the MAC address of the DHCP server and use it to identify the network when the hardware link carrier is dropped and comes back. Also, don't assume that all networks have a default gateway. Guard against spurious arp defense attempts that might be triggered by packets that are still in the socket buffer from before the BPF was changed. Split apart the AS_GW_CHECK and AS_GW_QUERY timeout handlers. Cosmetic cleanups in state.c.
2011-07-11 22:54:59 +05:30
{
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_shared_deconfig(cs);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
cs->dhcp_wake_ts = curms() + timeout;
Just use raw sockets for listening to DHCP requests. A UDP SO_BROADCAST socket was previously used only for receiving RENEWING packets, and it added needless complexity and was somewhat fragile.
2014-04-16 10:30:36 +05:30
start_dhcp_listen(cs);
Move dhcp state handling code out of netlink.c and into state.c. netlink.c now just calls hooks exposed by state.c, just like the dhcp packet, poll timeout, and signal code. Make ifchange_deconfig() idempotent.
2011-07-05 07:40:14 +05:30
}
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
// Triggered after a DHCP lease request packet has been sent and no reply has
// been received within the response wait time. If we've not exceeded the
// maximum number of request retransmits, then send another packet and wait
// again. Otherwise, return to the DHCP initialization state.
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
static int requesting_timeout(struct client_state_t cs[static 1],
state.c: cosmetic cleanups and a constification
2015-02-14 11:14:21 +05:30
long long nowts)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (cs->num_dhcp_requests >= 5) {
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 0);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return REQ_TIMEOUT;
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
}
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
if (send_selecting(cs) < 0) {
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
log_warning("%s: Failed to send a selecting request packet.",
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return REQ_FAIL;
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
cs->dhcp_wake_ts = nowts + delay_timeout(cs, cs->num_dhcp_requests);
cs->num_dhcp_requests++;
return REQ_SUCCESS;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
static bool is_renewing(struct client_state_t cs[static 1], long long nowts)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Optimize timeout calculations so that curms() is called fewer times and the timeout intervals are a bit more exact.
2011-07-11 18:29:50 +05:30
long long rnt = cs->leaseStartTime + cs->renewTime * 1000;
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return nowts >= rnt;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
static bool is_rebinding(struct client_state_t cs[static 1], long long nowts)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Make the renew and rebind timeouts more strictly rfc compliant, and also take into account the possiblity of renew times being ridiculously deferred such that the current time is within lease expiration time.
2011-06-30 12:18:58 +05:30
long long rbt = cs->leaseStartTime + cs->rebindTime * 1000;
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return nowts >= rbt;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Make the renew and rebind timeouts more strictly rfc compliant, and also take into account the possiblity of renew times being ridiculously deferred such that the current time is within lease expiration time.
2011-06-30 12:18:58 +05:30
// Triggered when a DHCP rebind request has been sent and no reply has been
// received within the response wait time. Check to see if the lease is still
// valid, and if it is, send a broadcast DHCP renew packet. If it is not, then
// change to the SELECTING state to get a new lease.
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
static int rebinding_timeout(struct client_state_t cs[static 1],
state.c: cosmetic cleanups and a constification
2015-02-14 11:14:21 +05:30
long long nowts)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Make the renew and rebind timeouts more strictly rfc compliant, and also take into account the possiblity of renew times being ridiculously deferred such that the current time is within lease expiration time.
2011-06-30 12:18:58 +05:30
long long elt = cs->leaseStartTime + cs->lease * 1000;
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
if (nowts >= elt) {
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Lease expired. Searching for a new lease...",
client_config.interface);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 0);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return BTO_EXPIRED;
Check the server identifier option when receiving a DHCP ACK or NAK to make sure that it matches that of our associated DHCP server. Normalize, prune, and beautify the appearance of log messages. Minor cosmetic cleanups/refactoring.
2011-07-12 02:03:57 +05:30
}
Fix the timeouts for rebinding and renewing. Now renew/rebind requests will be sent every 60+/-10s.
2015-02-18 21:33:58 +05:30
start_dhcp_listen(cs);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
if (send_rebind(cs) < 0) {
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
log_warning("%s: Failed to send a rebind request packet.",
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return BTO_HARDFAIL;
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
}
Update to the new ncmlib random API.
2017-08-24 12:06:31 +05:30
long long ts0 = nowts + (50 + nk_random_u32(&cs->rnd_state) % 20) * 1000;
Fix the timeouts for rebinding and renewing. Now renew/rebind requests will be sent every 60+/-10s.
2015-02-18 21:33:58 +05:30
cs->dhcp_wake_ts = ts0 < elt ? ts0 : elt;
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return BTO_WAIT;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
// Triggered when a DHCP renew request has been sent and no reply has been
// received within the response wait time. This function is also directly
// called by bound_timeout() when it is time to renew a lease before it
// expires. Check to see if the lease is still valid, and if it is, send
// a unicast DHCP renew packet. If it is not, then change to the REBINDING
// state to send broadcast queries.
static int renewing_timeout(struct client_state_t cs[static 1],
state.c: cosmetic cleanups and a constification
2015-02-14 11:14:21 +05:30
long long nowts)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
long long rbt = cs->leaseStartTime + cs->rebindTime * 1000;
if (nowts >= rbt)
return rebinding_timeout(cs, nowts);
Fix the timeouts for rebinding and renewing. Now renew/rebind requests will be sent every 60+/-10s.
2015-02-18 21:33:58 +05:30
start_dhcp_listen(cs);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
if (send_renew(cs) < 0) {
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
log_warning("%s: Failed to send a renew request packet.",
client_config.interface);
return BTO_HARDFAIL;
}
Update to the new ncmlib random API.
2017-08-24 12:06:31 +05:30
long long ts0 = nowts + (50 + nk_random_u32(&cs->rnd_state) % 20) * 1000;
Fix the timeouts for rebinding and renewing. Now renew/rebind requests will be sent every 60+/-10s.
2015-02-18 21:33:58 +05:30
cs->dhcp_wake_ts = ts0 < rbt ? ts0 : rbt;
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return BTO_WAIT;
}
// Triggered when the lease has been held for a significant fraction of its
// total time, and it is time to renew the lease so that it is not lost.
static int bound_timeout(struct client_state_t cs[static 1], long long nowts)
{
long long rnt = cs->leaseStartTime + cs->renewTime * 1000;
if (nowts < rnt) {
cs->dhcp_wake_ts = rnt;
return BTO_WAIT;
}
return renewing_timeout(cs, nowts);
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
state.c: cosmetic cleanups and a constification
2015-02-14 11:14:21 +05:30
static int validate_serverid(struct client_state_t cs[static 1],
struct dhcpmsg packet[static 1],
const char typemsg[static 1])
Check the server identifier option when receiving a DHCP ACK or NAK to make sure that it matches that of our associated DHCP server. Normalize, prune, and beautify the appearance of log messages. Minor cosmetic cleanups/refactoring.
2011-07-12 02:03:57 +05:30
{
Abstract uses of get_option_data() outside of ifchange.c and options.c. The eventual goal is to eliminate uses of get_option_data() in ifchange.c and will make it a static function in options.c.
2011-07-26 10:34:59 +05:30
int found;
uint32_t sid = get_option_serverid(packet, &found);
if (!found) {
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Received %s with no server id. Ignoring it.",
client_config.interface, typemsg);
Check the server identifier option when receiving a DHCP ACK or NAK to make sure that it matches that of our associated DHCP server. Normalize, prune, and beautify the appearance of log messages. Minor cosmetic cleanups/refactoring.
2011-07-12 02:03:57 +05:30
return 0;
}
Abstract uses of get_option_data() outside of ifchange.c and options.c. The eventual goal is to eliminate uses of get_option_data() in ifchange.c and will make it a static function in options.c.
2011-07-26 10:34:59 +05:30
if (cs->serverAddr != sid) {
Convert all uses of inet_ntoa() to inet_ntop(). inet_ntop() is POSIX, supports ipv6 (doesn't matter to ndhc), and does not use a stupid internal static buffer. This fixes some cosmetic print bugs.
2011-07-12 02:32:32 +05:30
char svrbuf[INET_ADDRSTRLEN];
Abstract uses of get_option_data() outside of ifchange.c and options.c. The eventual goal is to eliminate uses of get_option_data() in ifchange.c and will make it a static function in options.c.
2011-07-26 10:34:59 +05:30
inet_ntop(AF_INET, &(struct in_addr){.s_addr=sid},
Convert all uses of inet_ntoa() to inet_ntop(). inet_ntop() is POSIX, supports ipv6 (doesn't matter to ndhc), and does not use a stupid internal static buffer. This fixes some cosmetic print bugs.
2011-07-12 02:32:32 +05:30
svrbuf, sizeof svrbuf);
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Received %s with an unexpected server id: %s. Ignoring it.",
client_config.interface, typemsg, svrbuf);
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
return 0;
Check the server identifier option when receiving a DHCP ACK or NAK to make sure that it matches that of our associated DHCP server. Normalize, prune, and beautify the appearance of log messages. Minor cosmetic cleanups/refactoring.
2011-07-12 02:03:57 +05:30
}
return 1;
}
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
static void get_leasetime(struct client_state_t cs[static 1],
struct dhcpmsg packet[static 1])
{
cs->lease = get_option_leasetime(packet);
cs->leaseStartTime = curms();
if (!cs->lease) {
log_line("%s: No lease time received; assuming 1h.",
client_config.interface);
cs->lease = 60 * 60;
} else {
if (cs->lease < 60) {
log_warning("Server sent lease of <1m. Forcing lease to 1m.",
client_config.interface);
cs->lease = 60;
}
}
// Always use RFC2131 'default' values. It's not worth validating
// the remote server values, if they even exist, for sanity.
cs->renewTime = cs->lease >> 1;
cs->rebindTime = (cs->lease >> 3) * 0x7; // * 0.875
cs->dhcp_wake_ts = cs->leaseStartTime + cs->renewTime * 1000;
}
static int extend_packet(struct client_state_t cs[static 1],
struct dhcpmsg packet[static 1], uint8_t msgtype,
uint32_t srcaddr)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Improve fingerprinting to support DHCP relay agents. Mostly reverts the previous commit and instead teaches ndhc to properly handle the case when it is communicating with a DHCP relay agent on its local segment rather than directly with a DHCP server.
2015-02-13 09:58:54 +05:30
(void)srcaddr;
Pass around the DHCP message type as the literal data, not as a character pointer to the matching data in the options field of the DHCP packet.
2011-07-18 20:17:35 +05:30
if (msgtype == DHCPACK) {
Check the server identifier option when receiving a DHCP ACK or NAK to make sure that it matches that of our associated DHCP server. Normalize, prune, and beautify the appearance of log messages. Minor cosmetic cleanups/refactoring.
2011-07-12 02:03:57 +05:30
if (!validate_serverid(cs, packet, "a DHCP ACK"))
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return ANP_IGNORE;
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
get_leasetime(cs, packet);
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
Minor changes to log messages and comments.
2015-02-18 20:26:38 +05:30
// Did we receive a lease with a different IP than we had before?
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
if (memcmp(&packet->yiaddr, &cs->clientAddr, 4)) {
Convert all uses of inet_ntoa() to inet_ntop(). inet_ntop() is POSIX, supports ipv6 (doesn't matter to ndhc), and does not use a stupid internal static buffer. This fixes some cosmetic print bugs.
2011-07-12 02:32:32 +05:30
char clibuf[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->clientAddr},
clibuf, sizeof clibuf);
Minor changes to log messages and comments.
2015-02-18 20:26:38 +05:30
log_line("%s: Server is now offering IP %s. Validating...",
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
client_config.interface, clibuf);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return ANP_CHECK_IP;
Fix a regression: if renewing or rebinding a dhcp lease that matches our previous client ip, make sure to stop listening for dhcp packets, set the proper timeout interval, and make sure we're in AS_DEFENSE state.
2011-07-06 21:11:49 +05:30
} else {
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Lease refreshed to %u seconds.",
client_config.interface, cs->lease);
Minor changes to log messages and comments.
2015-02-18 20:26:38 +05:30
if (arp_set_defense_mode(cs) < 0)
log_warning("%s: Failed to create ARP defense socket.",
client_config.interface);
Just use raw sockets for listening to DHCP requests. A UDP SO_BROADCAST socket was previously used only for receiving RENEWING packets, and it added needless complexity and was somewhat fragile.
2014-04-16 10:30:36 +05:30
stop_dhcp_listen(cs);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return ANP_SUCCESS;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Pass around the DHCP message type as the literal data, not as a character pointer to the matching data in the options field of the DHCP packet.
2011-07-18 20:17:35 +05:30
} else if (msgtype == DHCPNAK) {
Check the server identifier option when receiving a DHCP ACK or NAK to make sure that it matches that of our associated DHCP server. Normalize, prune, and beautify the appearance of log messages. Minor cosmetic cleanups/refactoring.
2011-07-12 02:03:57 +05:30
if (!validate_serverid(cs, packet, "a DHCP NAK"))
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return ANP_IGNORE;
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Our request was rejected. Searching for a new lease...",
client_config.interface);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 3000);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return ANP_REJECTED;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return ANP_IGNORE;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
static int selecting_packet(struct client_state_t cs[static 1],
struct dhcpmsg packet[static 1], uint8_t msgtype,
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
uint32_t srcaddr, bool is_requesting)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
if (!is_requesting && msgtype == DHCPOFFER) {
Abstract uses of get_option_data() outside of ifchange.c and options.c. The eventual goal is to eliminate uses of get_option_data() in ifchange.c and will make it a static function in options.c.
2011-07-26 10:34:59 +05:30
int found;
uint32_t sid = get_option_serverid(packet, &found);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (!found) {
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Invalid offer received: it didn't have a server id.",
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return ANP_IGNORE;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
char clibuf[INET_ADDRSTRLEN];
char svrbuf[INET_ADDRSTRLEN];
char srcbuf[INET_ADDRSTRLEN];
cs->clientAddr = packet->yiaddr;
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
cs->serverAddr = sid;
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
cs->srcAddr = srcaddr;
cs->dhcp_wake_ts = curms();
cs->num_dhcp_requests = 0;
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->clientAddr},
clibuf, sizeof clibuf);
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->serverAddr},
svrbuf, sizeof svrbuf);
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->srcAddr},
srcbuf, sizeof srcbuf);
log_line("%s: Received IP offer: %s from server %s via %s.",
client_config.interface, clibuf, svrbuf, srcbuf);
return ANP_SUCCESS;
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
} else if (is_requesting && msgtype == DHCPACK) {
// Don't validate the server id. Instead validate that the
// yiaddr matches. Some networks have multiple servers
// that don't respect the serverid that was specified in
// our DHCPREQUEST.
if (!memcmp(&packet->yiaddr, &cs->clientAddr, 4)) {
char clibuf[INET_ADDRSTRLEN];
char svrbuf[INET_ADDRSTRLEN];
char srcbuf[INET_ADDRSTRLEN];
int found;
uint32_t sid = get_option_serverid(packet, &found);
if (!found) {
log_line("%s: Invalid offer received: it didn't have a server id.",
client_config.interface);
return ANP_IGNORE;
}
if (cs->serverAddr != sid) {
cs->serverAddr = sid;
cs->srcAddr = srcaddr;
}
get_leasetime(cs, packet);
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->clientAddr},
clibuf, sizeof clibuf);
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->serverAddr},
svrbuf, sizeof svrbuf);
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->srcAddr},
srcbuf, sizeof srcbuf);
log_line("%s: Received ACK: %s from server %s via %s. Validating...",
client_config.interface, clibuf, svrbuf, srcbuf);
return ANP_CHECK_IP;
}
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return ANP_IGNORE;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
// Triggered after a DHCP discover packet has been sent and no reply has
// been received within the response wait time. If we've not exceeded the
// maximum number of discover retransmits, then send another packet and wait
// again. Otherwise, background or fail.
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
static int selecting_timeout(struct client_state_t cs[static 1],
state.c: cosmetic cleanups and a constification
2015-02-14 11:14:21 +05:30
long long nowts)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Rename client_state_t init variable to program_init. Easier to grep. No functional change.
2017-01-19 15:35:35 +05:30
if (cs->program_init && cs->num_dhcp_requests >= 2) {
Use an RFC2131-compliant exponential backoff delay.
2011-06-30 12:57:57 +05:30
if (client_config.background_if_no_lease) {
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: No lease; going to background.",
client_config.interface);
Rename client_state_t init variable to program_init. Easier to grep. No functional change.
2017-01-19 15:35:35 +05:30
cs->program_init = false;
Use a unified epoll_(add|del)(). Also, background() and setup_signals_ndhc() are moved from sys.c to ndhc.c. background() also no longer attempts to re-configure signals; signals are always set up on initial ndhc initialization.
2014-03-13 02:21:10 +05:30
background();
Convert logging messages to suicide() where appropriate and clean up the logging messages a bit.
2014-03-31 02:51:27 +05:30
} else if (client_config.abort_if_no_lease)
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
suicide("%s: No lease; failing.", client_config.interface);
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (cs->num_dhcp_requests == 0)
Update to the new ncmlib random API.
2017-08-24 12:06:31 +05:30
cs->xid = nk_random_u32(&cs->rnd_state);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
if (send_discover(cs) < 0) {
state.c: Print error messages if we fail to send DHCP packets.
2014-04-16 03:29:15 +05:30
log_warning("%s: Failed to send a discover request packet.",
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return SEL_FAIL;
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
cs->dhcp_wake_ts = nowts + delay_timeout(cs, cs->num_dhcp_requests);
cs->num_dhcp_requests++;
return SEL_SUCCESS;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
// Called for a release signal during SELECTING or REQUESTING.
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
static void print_release(struct client_state_t cs[static 1])
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
{
log_line("%s: ndhc going to sleep. Wake it by sending a SIGUSR1.",
client_config.interface);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_shared_deconfig(cs);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
cs->dhcp_wake_ts = -1;
stop_dhcp_listen(cs);
}
// Called for a release signal during BOUND, RENEWING, or REBINDING.
static int xmit_release(struct client_state_t cs[static 1])
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Convert all uses of inet_ntoa() to inet_ntop(). inet_ntop() is POSIX, supports ipv6 (doesn't matter to ndhc), and does not use a stupid internal static buffer. This fixes some cosmetic print bugs.
2011-07-12 02:32:32 +05:30
char clibuf[INET_ADDRSTRLEN];
char svrbuf[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->clientAddr},
clibuf, sizeof clibuf);
inet_ntop(AF_INET, &(struct in_addr){.s_addr=cs->serverAddr},
svrbuf, sizeof svrbuf);
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Unicasting a release of %s to %s.", client_config.interface,
clibuf, svrbuf);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
if (send_release(cs) < 0) {
state.c: Print error messages if we fail to send DHCP packets.
2014-04-16 03:29:15 +05:30
log_warning("%s: Failed to send a release request packet.",
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return -1;
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
}
Define set_released() and use it for entering the DS_RELEASED state.
2011-07-06 03:59:06 +05:30
print_release(cs);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return 0;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
// Called for a renewing signal during BOUND or RELEASED
static int frenew(struct client_state_t cs[static 1], bool is_bound)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (is_bound) {
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Forcing a DHCP renew...", client_config.interface);
Just use raw sockets for listening to DHCP requests. A UDP SO_BROADCAST socket was previously used only for receiving RENEWING packets, and it added needless complexity and was somewhat fragile.
2014-04-16 10:30:36 +05:30
start_dhcp_listen(cs);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
if (send_renew(cs) < 0) {
state.c: Print error messages if we fail to send DHCP packets.
2014-04-16 03:29:15 +05:30
log_warning("%s: Failed to send a renew request packet.",
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return -1;
Add error handling for un-notified carrier downs when sending packets. If a packet send failed because the carrier went down without a netlink notification, then assume the hardware carrier was lost while the machine was suspended (eg, ethernet cable pulled during suspend). Simulate a netlink carrier down event and freeze the dhcp state machine until a netlink carrier up event is received. The ARP code is not yet handling this issue everywhere, but the window of opportunity for it to happen there is much shorter.
2015-02-14 15:50:04 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
} else { // RELEASED
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 0);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
}
return 0;
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
// If we have a lease, check to see if our gateway is still valid via ARP.
// If it fails, state -> SELECTING.
static int ifup_action(struct client_state_t cs[static 1])
Move dhcp state handling code out of netlink.c and into state.c. netlink.c now just calls hooks exposed by state.c, just like the dhcp packet, poll timeout, and signal code. Make ifchange_deconfig() idempotent.
2011-07-05 07:40:14 +05:30
{
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (cs->routerAddr && cs->serverAddr) {
state: Faster recovery when carrier lost during DHCP init. If carrier is lost before network fingerprinting is complete, we have a few problems; first, we don't know whether the network has changed underneath us. Second, we've not yet configured the interface properties, and it is not unlikely that doing so will fail as the underlying network device may have been destroyed and recreated during this time (eg, if ethtool has been run at start-up time). Thus, the safest reaction is to terminate and force a supervisor respawn. It is best to do this once carrier recovers, not when the carrier is lost, as it is more likely to minimize delays.
2017-04-10 19:27:52 +05:30
if (cs->init_fingerprint_inprogress) {
suicide("%s: Carrier lost during initial fingerprint. Forcing restart.",
client_config.interface);
}
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
if (arp_gw_check(cs) >= 0) {
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Interface is back. Revalidating lease...",
Make netlink action logging messages more consistent: prefix with 'nl: ' and always print the actual interface identifier.
2011-07-18 19:59:36 +05:30
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return IFUP_REVALIDATE;
Add error handling for un-notified carrier downs in ifup_action.
2015-02-14 16:07:06 +05:30
} else {
state.c: cosmetic cleanups and a constification
2015-02-14 11:14:21 +05:30
log_warning("%s: arp_gw_check could not make arp socket.",
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return IFUP_FAIL;
Add error handling for un-notified carrier downs in ifup_action.
2015-02-14 16:07:06 +05:30
}
Send probe requests in COLLISION_CHECK state in a way that is compliant with RFC5227. Rate-limiting is also supported. Keep ARP stats per packet send type rather than per ARP state. Use the new stats to replace last_def_ts. Multiple triggers of arp_gw_check from interface-up-events in quick succession could cause the dhcpState to become corrupt. Fix by making the ARP_GW_CHECK be level triggered rather than edge triggered. Make the timeout calculations in the ARP retransmission code much more accurate. Close the ARP fd if we give up on lease defense and go back to requesting a new lease. Do a second arp_announcement() after finding the default GW's hwaddr. Clean up frenew to sanely handle the various ARP checking events. Now renew signals will be ignored during these states. It was particularly insane before if a renew signal were received during DS_COLLISION_CHECK. If the hardware link carrier goes down, do not sleep. Just keep working. Only go to sleep if the user explicitly deconfigures the interface. This change is far more sane for non-mobile hosts, and still works fine with roaming machines: the important thing is the gw hardware address checking that is triggered when the interface comes back up.
2011-07-06 01:10:57 +05:30
}
Update more message prints to prefix with the interface name.
2014-04-16 00:54:22 +05:30
log_line("%s: Interface is back. Searching for new lease...",
Check the server identifier option when receiving a DHCP ACK or NAK to make sure that it matches that of our associated DHCP server. Normalize, prune, and beautify the appearance of log messages. Minor cosmetic cleanups/refactoring.
2011-07-12 02:03:57 +05:30
client_config.interface);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
return IFUP_NEWLEASE;
Move dhcp state handling code out of netlink.c and into state.c. netlink.c now just calls hooks exposed by state.c, just like the dhcp packet, poll timeout, and signal code. Make ifchange_deconfig() idempotent.
2011-07-05 07:40:14 +05:30
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
#define BAD_STATE() suicide("%s(%d): bad state", __func__, __LINE__)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
// XXX: Should be re-entrant so as to handle multiple servers.
int dhcp_handle(struct client_state_t cs[static 1], long long nowts,
Fix the return values of dhcp_packet_get and arp_packet_get. This corrects a bug where stale dhcp packets would get reprocessed, causing very bad behavior; an issue that was introduced in the coroutine conversion.
2015-02-18 21:32:13 +05:30
bool sev_dhcp, struct dhcpmsg dhcp_packet[static 1],
uint8_t dhcp_msgtype, uint32_t dhcp_srcaddr, bool sev_arp,
Handle the release and renew signals again.
2015-02-18 18:01:19 +05:30
bool force_fingerprint, bool dhcp_timeout, bool arp_timeout,
int sev_signal)
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
{
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
scrBegin;
reinit:
Update to the new ncmlib random API.
2017-08-24 12:06:31 +05:30
cs->xid = nk_random_u32(&cs->rnd_state);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
// We're in the SELECTING state here.
for (;;) {
int ret = COR_SUCCESS;
Handle the release and renew signals again.
2015-02-18 18:01:19 +05:30
if (sev_signal == SIGNAL_RELEASE) {
print_release(cs);
goto skip_to_released;
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (sev_dhcp) {
int r = selecting_packet(cs, dhcp_packet, dhcp_msgtype,
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
dhcp_srcaddr, false);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (r == ANP_SUCCESS) {
// Send a request packet to the answering DHCP server.
sev_dhcp = false;
goto skip_to_requesting;
}
}
if (dhcp_timeout) {
int r = selecting_timeout(cs, nowts);
if (r == SEL_SUCCESS) {
} else if (r == SEL_FAIL) {
ret = COR_ERROR;
} else BAD_STATE();
}
scrReturn(ret);
}
scrReturn(COR_SUCCESS);
// We're in the REQUESTING state here.
for (;;) {
int ret;
skip_to_requesting:
ret = COR_SUCCESS;
Handle the release and renew signals again.
2015-02-18 18:01:19 +05:30
if (sev_signal == SIGNAL_RELEASE) {
print_release(cs);
goto skip_to_released;
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (sev_dhcp) {
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
int r = selecting_packet(cs, dhcp_packet, dhcp_msgtype,
dhcp_srcaddr, true);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (r == ANP_IGNORE) {
} else if (r == ANP_CHECK_IP) {
if (arp_check(cs, dhcp_packet) < 0) {
log_warning("%s: Failed to make arp socket. Searching for new lease...",
client_config.interface);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 3000);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
sev_dhcp = false;
goto reinit;
}
break;
} else BAD_STATE();
}
if (dhcp_timeout) {
// Send a request packet to the answering DHCP server.
int r = requesting_timeout(cs, nowts);
if (r == REQ_SUCCESS) {
} else if (r == REQ_TIMEOUT) {
// We timed out. Send another packet.
sev_dhcp = false;
goto reinit;
} else if (r == REQ_FAIL) {
// Failed to send packet. Sleep and retry.
ret = COR_ERROR;
} else BAD_STATE();
}
scrReturn(ret);
}
scrReturn(COR_SUCCESS);
// We're checking to see if there's a conflict for our IP. Technically,
// this is still in REQUESTING.
for (;;) {
int ret;
ret = COR_SUCCESS;
Handle the release and renew signals again.
2015-02-18 18:01:19 +05:30
if (sev_signal == SIGNAL_RELEASE) {
print_release(cs);
goto skip_to_released;
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (sev_dhcp) {
// XXX: Maybe I can think of something to do here. Would
// be more relevant if we tracked multiple dhcp servers.
}
if (sev_arp) {
int r = arp_do_collision_check(cs);
if (r == ARPR_OK) {
} else if (r == ARPR_CONFLICT) {
// XXX: If we tracked multiple DHCP servers, then we
// could fall back on another one.
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 0);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
sev_dhcp = false;
goto reinit;
} else if (r == ARPR_FAIL) {
ret = COR_ERROR;
scrReturn(ret);
continue;
} else BAD_STATE();
}
if (arp_timeout) {
int r = arp_collision_timeout(cs, nowts);
if (r == ARPR_FREE) {
arp: Handle initial gateway query asynchronously and retry failures. The gateway/router MAC fingerprinting could perhaps be done more robustly in the face of suspend or carrier loss, but the time window in which things could get confused is very small and I would rather just rely on supervisor respawn in that case. Even this case I don't think I've ever seen.
2017-02-24 18:09:14 +05:30
arp_query_gateway(cs);
arp: Handle initial announcement asynchronously and retry failures. We need to send two ARP announcements, so these are now done via a timeout callback so that failures can be handled properly.
2017-02-24 16:57:15 +05:30
arp_announce(cs);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
break;
} else if (r == ARPR_OK) {
} else if (r == ARPR_FAIL) {
ret = COR_ERROR;
scrReturn(ret);
continue;
} else BAD_STATE();
}
if (dhcp_timeout) {
// Send a request packet to the answering DHCP server.
int r = requesting_timeout(cs, nowts);
if (r == REQ_SUCCESS) {
} else if (r == REQ_TIMEOUT) {
// We timed out. Send another packet.
sev_dhcp = false;
goto reinit;
} else if (r == REQ_FAIL) {
// Failed to send packet. Sleep and retry.
ret = COR_ERROR;
} else BAD_STATE();
}
scrReturn(ret);
}
scrReturn(COR_SUCCESS);
// We're in the BOUND, RENEWING, or REBINDING states here.
for (;;) {
int ret = COR_SUCCESS;
Handle the release and renew signals again.
2015-02-18 18:01:19 +05:30
if (sev_signal) {
if (sev_signal == SIGNAL_RELEASE) {
int r = xmit_release(cs);
if (r) {
ret = COR_ERROR;
scrReturn(ret);
continue;
}
goto skip_to_released;
}
if (sev_signal == SIGNAL_RENEW) {
int r = frenew(cs, true);
if (r) {
ret = COR_ERROR;
scrReturn(ret);
continue;
}
}
}
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (sev_dhcp && is_renewing(cs, nowts)) {
Tolerate DHCP ACKs in REQUESTING state that don't match the serverid. Some networks have multiple DHCP servers that don't respect the serverid that is specified in DHCPREQUESTs. Instead we simply check to see that the yiaddr matches. While we're at it, ignore DHCP NAK during REQUESTING state. It doesn't really make sense. Instead we should just wait for timeout.
2015-02-18 17:22:59 +05:30
int r = extend_packet(cs, dhcp_packet, dhcp_msgtype, dhcp_srcaddr);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
if (r == ANP_SUCCESS || r == ANP_IGNORE) {
} else if (r == ANP_REJECTED) {
sev_dhcp = false;
goto reinit;
} else if (r == ANP_CHECK_IP) {
if (arp_check(cs, dhcp_packet) < 0) {
log_warning("%s: Failed to make arp socket. Searching for new lease...",
client_config.interface);
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 3000);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
sev_dhcp = false;
goto reinit;
}
} else BAD_STATE();
}
if (sev_arp) {
int r;
r = arp_do_defense(cs);
if (r == ARPR_OK) {
} else if (r == ARPR_CONFLICT) {
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 0);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
sev_dhcp = false;
goto reinit;
} else if (r == ARPR_FAIL) {
ret = COR_ERROR;
scrReturn(ret);
continue;
} else BAD_STATE();
if (!cs->got_router_arp || !cs->got_server_arp) {
r = arp_do_gw_query(cs);
if (r == ARPR_OK) {
} else if (r == ARPR_FREE) {
state: Faster recovery when carrier lost during DHCP init. If carrier is lost before network fingerprinting is complete, we have a few problems; first, we don't know whether the network has changed underneath us. Second, we've not yet configured the interface properties, and it is not unlikely that doing so will fail as the underlying network device may have been destroyed and recreated during this time (eg, if ethtool has been run at start-up time). Thus, the safest reaction is to terminate and force a supervisor respawn. It is best to do this once carrier recovers, not when the carrier is lost, as it is more likely to minimize delays.
2017-04-10 19:27:52 +05:30
log_line("%s: Network fingerprinting complete.", client_config.interface);
cs->init_fingerprint_inprogress = false;
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
} else if (r == ARPR_FAIL) {
ret = COR_ERROR;
scrReturn(ret);
continue;
} else BAD_STATE();
} else if (cs->check_fingerprint) {
r = arp_do_gw_check(cs);
if (r == ARPR_OK) {
} else if (r == ARPR_FREE) {
cs->check_fingerprint = false;
} else if (r == ARPR_CONFLICT) {
cs->check_fingerprint = false;
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 0);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
sev_dhcp = false;
goto reinit;
} else if (r == ARPR_FAIL) {
ret = COR_ERROR;
scrReturn(ret);
continue;
} else BAD_STATE();
}
}
if (arp_timeout) {
Silence a spurious ARP defense message from previous commit.
2017-02-24 17:18:48 +05:30
if (cs->sent_first_announce && cs->sent_second_announce)
arp_defense_timeout(cs, nowts);
else
arp: Handle initial announcement asynchronously and retry failures. We need to send two ARP announcements, so these are now done via a timeout callback so that failures can be handled properly.
2017-02-24 16:57:15 +05:30
arp_announce_timeout(cs, nowts);
arp: Handle initial gateway query asynchronously and retry failures. The gateway/router MAC fingerprinting could perhaps be done more robustly in the face of suspend or carrier loss, but the time window in which things could get confused is very small and I would rather just rely on supervisor respawn in that case. Even this case I don't think I've ever seen.
2017-02-24 18:09:14 +05:30
if (!cs->sent_gw_query)
arp_query_gateway_timeout(cs, nowts);
else if (!cs->got_router_arp || !cs->got_server_arp) {
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
int r = arp_gw_query_timeout(cs, nowts);
if (r == ARPR_OK) {
} else if (r == ARPR_FAIL) {
ret = COR_ERROR;
scrReturn(ret);
continue;
} else BAD_STATE();
} else if (cs->check_fingerprint) {
int r = arp_gw_check_timeout(cs, nowts);
if (r == ARPR_OK) {
} else if (r == ARPR_CONFLICT) {
cs->check_fingerprint = false;
reinit_selecting() can't fail; convert it to void return.
2015-02-18 17:42:35 +05:30
reinit_selecting(cs, 0);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
sev_dhcp = false;
goto reinit;
} else if (r == ARPR_FAIL) {
ret = COR_ERROR;
scrReturn(ret);
continue;
} else BAD_STATE();
}
}
if (force_fingerprint) {
int r = ifup_action(cs);
if (r == IFUP_REVALIDATE) {
} else if (r == IFUP_NEWLEASE) {
Deconfigure the interface if we've failed a fingerprint check. We've moved to a new network, so keeping the old information is counterproductive.
2015-02-18 17:42:22 +05:30
if (ifchange_deconfig(cs) < 0) {
// Likely only to fail because of rfkill.
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
ret = COR_ERROR;
scrReturn(ret);
}
Deconfigure the interface if we've failed a fingerprint check. We've moved to a new network, so keeping the old information is counterproductive.
2015-02-18 17:42:22 +05:30
reinit_selecting(cs, 0);
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
sev_dhcp = false;
goto reinit;
} else if (r == IFUP_FAIL) {
ret = COR_ERROR;
scrReturn(ret);
continue;
} else BAD_STATE();
}
if (dhcp_timeout) {
int r;
if (is_rebinding(cs, nowts)) {
r = rebinding_timeout(cs, nowts);
} else if (is_renewing(cs, nowts)) {
r = renewing_timeout(cs, nowts);
} else {
r = bound_timeout(cs, nowts);
}
if (r == BTO_WAIT) {
} else if (r == BTO_EXPIRED) {
sev_dhcp = false;
goto reinit;
} else if (r == BTO_HARDFAIL) {
ret = COR_ERROR;
} else
BAD_STATE();
}
scrReturn(ret);
}
sev_dhcp = false;
goto reinit;
Handle the release and renew signals again.
2015-02-18 18:01:19 +05:30
// We're in the RELEASED state here.
for (;;) {
int ret;
skip_to_released:
ret = COR_SUCCESS;
if (sev_signal == SIGNAL_RENEW) {
int r = frenew(cs, false);
if (r) {
ret = COR_ERROR;
scrReturn(ret);
continue;
}
break;
}
scrReturn(ret);
}
sev_dhcp = false;
goto reinit;
Use a coroutine instead of several callback state machines. This change makes it much easier to reason about ndhc's behavior and properly handle errors. It is a very large changeset, but there is no way to make this sort of change incrementally. Lease acquisition is tested to work. It is highly likely that some bugs were both introduced and squashed here. Some obvious code cleanups will quickly follow.
2015-02-18 16:01:13 +05:30
scrFinish(COR_SUCCESS);
Centralize DHCP timeout, packet reciept, and user-demanded action handling into state.[ch]. Remove timeout.c.
2011-06-30 09:17:31 +05:30
}
Track pending events in time by using absolute times rather than relative timeouts.
2011-07-11 21:01:27 +05:30
Reference in New Issue Copy Permalink