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

739 lines
26 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
*
Stop using signalfd and audit signal handling code. There's really no advantage to using signalfd in ndhc, particularly since the normal POSIX signal API is now used for handling SIGCHLD in ndhc-master. So just use the tried and true volatile sig_atomic_t set and check approach. The only intended behavior change is in the dhcp RELEASE state -- before there would be a spurious attempt at renewing a nonexistent lease when the RENEW signal was received.
2020-10-20 13:53:55 +05:30
* Copyright 2011-2020 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
Add a heuristic to detect when server ignores dhcp renews. If we get no response to three renews (unicast), switch to sending rebinds (broadcast). Servers are supposed to always reply with a DHCPACK or DHCPNAK even if the server doesn't update its internal lease duration database, so this behavior should be RFC compliant.
2020-10-19 16:33:03 +05:30
#define IGNORED_RENEWS_BEFORE_REBIND 3
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.
Compile cleanly with -Wsign-conversion. I didn't notice anything that worried me.
2018-02-09 13:09:46 +05:30
return to * 1000 + (int)(nk_random_u32(&cs->rnd_state) % 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
{
Make sure xids in packets sent conform to RFC2131 pg36 table5.
2020-10-19 15:09:08 +05:30
cs->xid = nk_random_u32(&cs->rnd_state);
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;
Add a heuristic to detect when server ignores dhcp renews. If we get no response to three renews (unicast), switch to sending rebinds (broadcast). Servers are supposed to always reply with a DHCPACK or DHCPNAK even if the server doesn't update its internal lease duration database, so this behavior should be RFC compliant.
2020-10-19 16:33:03 +05:30
cs->num_dhcp_renews = 0;
Give up on fingerprinting relay agent/server if it doesn't reply. Try to send/wait three times; then if there's no response, then assume that the relay agent is ignoring or firewalled from receiving ARP requests.
2020-10-19 12:37:23 +05:30
cs->server_arp_sent = 0;
Give up on fingerprinting router/gateway if it doesn't reply.
2020-10-19 13:55:15 +05:30
cs->router_arp_sent = 0;
Give up on fingerprinting relay agent/server if it doesn't reply. Try to send/wait three times; then if there's no response, then assume that the relay agent is ignoring or firewalled from receiving ARP requests.
2020-10-19 12:37:23 +05:30
cs->server_arp_state = ARP_QUERY;
Give up on fingerprinting router/gateway if it doesn't reply.
2020-10-19 13:55:15 +05:30
cs->router_arp_state = ARP_QUERY;
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;
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
cs->sent_renew_or_rebind = 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->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
}
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
// Called by renewing_timeout() to try to renew the lease. If all
// timeouts expire, then expire the lease and notify the caller.
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],
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +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
}
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
cs->sent_renew_or_rebind = true;
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
}
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
// Called by bound_timeout() to try to renew the 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 renewing_timeout(struct client_state_t cs[static 1],
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +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;
Add a heuristic to detect when server ignores dhcp renews. If we get no response to three renews (unicast), switch to sending rebinds (broadcast). Servers are supposed to always reply with a DHCPACK or DHCPNAK even if the server doesn't update its internal lease duration database, so this behavior should be RFC compliant.
2020-10-19 16:33:03 +05:30
if (nowts >= rbt || cs->num_dhcp_renews >= IGNORED_RENEWS_BEFORE_REBIND)
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 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;
}
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
cs->sent_renew_or_rebind = true;
Add a heuristic to detect when server ignores dhcp renews. If we get no response to three renews (unicast), switch to sending rebinds (broadcast). Servers are supposed to always reply with a DHCPACK or DHCPNAK even if the server doesn't update its internal lease duration database, so this behavior should be RFC compliant.
2020-10-19 16:33:03 +05:30
++cs->num_dhcp_renews;
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;
}
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
// Called to handle dhcp state timeouts, such as when RENEW or REBIND
// DHCPREQUESTs must be sent. Can return BTO_(WAIT|EXPIRED|HARDFAIL).
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 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
}
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;
}
serverid checks for RENEW and REBIND DHCP(ACK|NAK) were too strict. Use the same test that is already used for the DHCPACK sent by the server in the REQUESTING state.
2020-10-21 16:17:11 +05:30
static bool validate_acknak(struct client_state_t cs[static 1],
struct dhcpmsg packet[static 1],
const char typemsg[static 1],
uint32_t srcaddr)
{
// 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))
return false;
int found;
uint32_t sid = get_option_serverid(packet, &found);
if (!found) {
log_line("%s: Received %s with no server id. Ignoring it.",
client_config.interface, typemsg);
return false;
}
if (cs->serverAddr != sid) {
cs->serverAddr = sid;
cs->srcAddr = srcaddr;
}
return true;
}
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 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) {
serverid checks for RENEW and REBIND DHCP(ACK|NAK) were too strict. Use the same test that is already used for the DHCPACK sent by the server in the REQUESTING state.
2020-10-21 16:17:11 +05:30
if (!validate_acknak(cs, packet, "DHCPACK", 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
return ANP_IGNORE;
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
cs->sent_renew_or_rebind = false;
Add a heuristic to detect when server ignores dhcp renews. If we get no response to three renews (unicast), switch to sending rebinds (broadcast). Servers are supposed to always reply with a DHCPACK or DHCPNAK even if the server doesn't update its internal lease duration database, so this behavior should be RFC compliant.
2020-10-19 16:33:03 +05:30
cs->num_dhcp_renews = 0;
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) {
serverid checks for RENEW and REBIND DHCP(ACK|NAK) were too strict. Use the same test that is already used for the DHCPACK sent by the server in the REQUESTING state.
2020-10-21 16:17:11 +05:30
if (!validate_acknak(cs, packet, "DHCPNAK", 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
return ANP_IGNORE;
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
cs->sent_renew_or_rebind = false;
Add a heuristic to detect when server ignores dhcp renews. If we get no response to three renews (unicast), switch to sending rebinds (broadcast). Servers are supposed to always reply with a DHCPACK or DHCPNAK even if the server doesn't update its internal lease duration database, so this behavior should be RFC compliant.
2020-10-19 16:33:03 +05:30
cs->num_dhcp_renews = 0;
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
{
Trivial refactoring.
2020-10-19 12:41:51 +05:30
char clibuf[INET_ADDRSTRLEN];
char svrbuf[INET_ADDRSTRLEN];
char srcbuf[INET_ADDRSTRLEN];
int found;
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
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
}
Make sure xids in packets sent conform to RFC2131 pg36 table5.
2020-10-19 15:09:08 +05:30
cs->xid = packet->xid; // Use for subsequent DHCPREQUESTs
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->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) {
serverid checks for RENEW and REBIND DHCP(ACK|NAK) were too strict. Use the same test that is already used for the DHCPACK sent by the server in the REQUESTING state.
2020-10-21 16:17:11 +05:30
if (!validate_acknak(cs, packet, "DHCPACK", srcaddr))
return ANP_IGNORE;
get_leasetime(cs, packet);
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
serverid checks for RENEW and REBIND DHCP(ACK|NAK) were too strict. Use the same test that is already used for the DHCPACK sent by the server in the REQUESTING state.
2020-10-21 16:17:11 +05:30
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
Remove legacy support for forking to background.
2020-10-20 16:22:30 +05:30
// again. Otherwise 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) {
Remove legacy support for forking to background.
2020-10-20 16:22:30 +05:30
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
}
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) {
Give up on fingerprinting router/gateway if it doesn't reply.
2020-10-19 13:55:15 +05:30
const bool fp_server = cs->server_arp_state == ARP_FOUND;
const bool fp_router = (cs->routerAddr != cs->serverAddr) ? (cs->router_arp_state == ARP_FOUND) : fp_server;
if (!fp_server && !fp_router)
Give up on fingerprinting relay agent/server if it doesn't reply. Try to send/wait three times; then if there's no response, then assume that the relay agent is ignoring or firewalled from receiving ARP requests.
2020-10-19 12:37:23 +05:30
goto no_fingerprint;
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
}
Give up on fingerprinting relay agent/server if it doesn't reply. Try to send/wait three times; then if there's no response, then assume that the relay agent is ignoring or firewalled from receiving ARP requests.
2020-10-19 12:37:23 +05:30
no_fingerprint:
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
}
Stop using signalfd and audit signal handling code. There's really no advantage to using signalfd in ndhc, particularly since the normal POSIX signal API is now used for handling SIGCHLD in ndhc-master. So just use the tried and true volatile sig_atomic_t set and check approach. The only intended behavior change is in the dhcp RELEASE state -- before there would be a spurious attempt at renewing a nonexistent lease when the RENEW signal was received.
2020-10-20 13:53:55 +05:30
// If ret == 0: do nothing
// ret == 1: ret = COR_ERROR; scrReturn(ret); continue
// ret == 2: goto skip_to_released
// ret == 3: break
static int signal_check_nolease(struct client_state_t cs[static 1])
{
for (;;) {
int s = signals_flagged();
if (s == SIGNAL_NONE) break;
if (s == SIGNAL_EXIT) signal_exit(EXIT_SUCCESS);
if (s == SIGNAL_RELEASE) {
print_release(cs);
return 2;
}
}
return 0;
}
static int signal_check_havelease(struct client_state_t cs[static 1])
{
for (;;) {
int s = signals_flagged();
if (s == SIGNAL_NONE) break;
if (s == SIGNAL_EXIT) signal_exit(EXIT_SUCCESS);
if (s == SIGNAL_RELEASE) {
int r = xmit_release(cs);
if (r) return 1;
return 2;
}
if (s == SIGNAL_RENEW) {
int r = frenew(cs, true);
if (r) return 1;
}
}
return 0;
}
static int signal_check_released(struct client_state_t cs[static 1])
{
(void)cs;
for (;;) {
int s = signals_flagged();
if (s == SIGNAL_NONE) break;
if (s == SIGNAL_EXIT) signal_exit(EXIT_SUCCESS);
if (s == SIGNAL_RENEW) return 3;
}
return 0;
}
#define SIGNAL_CHECK(NAME) \
{ \
int tt = signal_check_ ## NAME(cs); \
if (tt == 1) { \
ret = COR_ERROR; \
scrReturn(ret); \
continue; \
} \
if (tt == 2) goto skip_to_released; \
if (tt == 3) break; \
}
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,
Stop using signalfd and audit signal handling code. There's really no advantage to using signalfd in ndhc, particularly since the normal POSIX signal API is now used for handling SIGCHLD in ndhc-master. So just use the tried and true volatile sig_atomic_t set and check approach. The only intended behavior change is in the dhcp RELEASE state -- before there would be a spurious attempt at renewing a nonexistent lease when the RENEW signal was received.
2020-10-20 13:53:55 +05:30
bool force_fingerprint, bool dhcp_timeout, bool arp_timeout)
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:
// We're in the SELECTING state here.
for (;;) {
int ret = COR_SUCCESS;
Stop using signalfd and audit signal handling code. There's really no advantage to using signalfd in ndhc, particularly since the normal POSIX signal API is now used for handling SIGCHLD in ndhc-master. So just use the tried and true volatile sig_atomic_t set and check approach. The only intended behavior change is in the dhcp RELEASE state -- before there would be a spurious attempt at renewing a nonexistent lease when the RENEW signal was received.
2020-10-20 13:53:55 +05:30
SIGNAL_CHECK(nolease);
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;
Stop using signalfd and audit signal handling code. There's really no advantage to using signalfd in ndhc, particularly since the normal POSIX signal API is now used for handling SIGCHLD in ndhc-master. So just use the tried and true volatile sig_atomic_t set and check approach. The only intended behavior change is in the dhcp RELEASE state -- before there would be a spurious attempt at renewing a nonexistent lease when the RENEW signal was received.
2020-10-20 13:53:55 +05:30
SIGNAL_CHECK(nolease);
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;
Stop using signalfd and audit signal handling code. There's really no advantage to using signalfd in ndhc, particularly since the normal POSIX signal API is now used for handling SIGCHLD in ndhc-master. So just use the tried and true volatile sig_atomic_t set and check approach. The only intended behavior change is in the dhcp RELEASE state -- before there would be a spurious attempt at renewing a nonexistent lease when the RENEW signal was received.
2020-10-20 13:53:55 +05:30
SIGNAL_CHECK(nolease);
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;
Stop using signalfd and audit signal handling code. There's really no advantage to using signalfd in ndhc, particularly since the normal POSIX signal API is now used for handling SIGCHLD in ndhc-master. So just use the tried and true volatile sig_atomic_t set and check approach. The only intended behavior change is in the dhcp RELEASE state -- before there would be a spurious attempt at renewing a nonexistent lease when the RENEW signal was received.
2020-10-20 13:53:55 +05:30
SIGNAL_CHECK(havelease);
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
if (sev_dhcp && cs->sent_renew_or_rebind) {
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();
Give up on fingerprinting router/gateway if it doesn't reply.
2020-10-19 13:55:15 +05:30
if (cs->router_arp_state == ARP_QUERY || cs->server_arp_state == ARP_QUERY) {
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
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);
Give up on fingerprinting router/gateway if it doesn't reply.
2020-10-19 13:55:15 +05:30
else if (cs->router_arp_state == ARP_QUERY || cs->server_arp_state == ARP_QUERY) {
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) {
Make renew and rebinding directly track whether DHCPREQUEST was sent. Before it was inferred by examining timeouts. Also, simplify the associated timeout code so that there are no longer effectively two redundant paths.
2020-10-19 15:35:47 +05:30
int r = bound_timeout(cs, nowts);
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 == 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;
Stop using signalfd and audit signal handling code. There's really no advantage to using signalfd in ndhc, particularly since the normal POSIX signal API is now used for handling SIGCHLD in ndhc-master. So just use the tried and true volatile sig_atomic_t set and check approach. The only intended behavior change is in the dhcp RELEASE state -- before there would be a spurious attempt at renewing a nonexistent lease when the RENEW signal was received.
2020-10-20 13:53:55 +05:30
SIGNAL_CHECK(released);
Handle the release and renew signals again.
2015-02-18 18:01:19 +05:30
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