diff options
Diffstat (limited to 'libdhcp/dhcp_client.c')
| -rw-r--r-- | libdhcp/dhcp_client.c | 934 |
1 files changed, 934 insertions, 0 deletions
diff --git a/libdhcp/dhcp_client.c b/libdhcp/dhcp_client.c new file mode 100644 index 0000000..8ec3647 --- /dev/null +++ b/libdhcp/dhcp_client.c @@ -0,0 +1,934 @@ +/* libdhcp/dhcp_client.c - A DHCP client + * + * Copyright (C) 2024-2025 Luke T. Shumaker <lukeshu@lukeshu.com> + * SPDX-License-Identifier: AGPL-3.0-or-later + * + * ----------------------------------------------------------------------------- + * https://github.com/Wiznet/ioLibrary_Driver/blob/b981401e7f3d07015619adf44c13998e13e777f9/Internet/DHCP/dhcp.c + * + * Copyright (c) 2013, WIZnet Co., LTD. + * 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. + * * Neither the name of the <ORGANIZATION> nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 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 OWNER 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. + * + * SPDX-License-Identifier: BSD-3-Clause + * + * ----------------------------------------------------------------------------- + * https://github.com/Wiznet/ioLibrary_Driver/blob/b981401e7f3d07015619adf44c13998e13e777f9/license.txt + * + * Copyright (c) 2014 WIZnet Co.,Ltd. + * Copyright (c) WIZnet ioLibrary Project. + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * SPDX-License-Identifier: MIT + */ + +/* Implemented: + * - DHCPv4: https://datatracker.ietf.org/doc/html/rfc2131 + * - DHCPv4 long options: https://datatracker.ietf.org/doc/html/rfc3396 + * - DHCPv4 client identifiers in replies: https://datatracker.ietf.org/doc/html/rfc6842 + * + * TODO: + * - AutoIPv4: https://datatracker.ietf.org/doc/html/rfc3927 + * - mDNS responder: https://datatracker.ietf.org/doc/html/rfc6762 + * + * Not implemented: + * - DHCPv4 node-specific client identifiers: https://datatracker.ietf.org/doc/html/rfc4361 + * - DNAv4: https://datatracker.ietf.org/doc/html/rfc4436 + * - LLMNR responder: https://datatracker.ietf.org/doc/html/rfc4795 + * + * Not implemented, because the W5500 doesn't support IPv6: + * - SLAAC: https://datatracker.ietf.org/doc/html/rfc2462 + * - DNAv6: https://datatracker.ietf.org/doc/html/rfc6059 + * - DHCPv6: https://datatracker.ietf.org/doc/html/rfc8415 + */ + +#include <string.h> /* for strlen(), memcpy(), memset() */ + +#include <libmisc/rand.h> +#include <libhw/generic/alarmclock.h> + +#define LOG_NAME DHCP +#include <libmisc/log.h> + +#include <libdhcp/client.h> + +#include "dhcp_common.h" + +/* Config *********************************************************************/ + +#include "config.h" + +#ifndef CONFIG_DHCP_DEBUG + #error config.h must define CONFIG_DHCP_DEBUG +#endif +#ifndef CONFIG_DHCP_SELECTING_NS + #error config.h must define CONFIG_DHCP_SELECTING_NS +#endif +#ifndef CONFIG_DHCP_CAN_RECV_UNICAST_IP_WITHOUT_IP + #error config.h must define CONFIG_DHCP_CAN_RECV_UNICAST_IP_WITHOUT_IP +#endif + +/* Implementation *************************************************************/ + +enum requirement { + MUST, + MUST_NOT, + SHOULD, + SHOULD_NOT, + MAY, + + _SHOULD_NOT_HAPPEN, +}; + +struct dhcp_client { + /* Static. */ + lo_interface net_iface iface; + lo_interface net_packet_conn sock; + struct net_eth_addr self_eth_addr; + char *self_hostname; + size_t self_id_len; + void *self_id_dat; + + /* Mutable. */ + enum { + STATE_INIT, + STATE_SELECTING, + STATE_REQUESTING, + STATE_BOUND, + STATE_RENEWING, + STATE_REBINDING, + + STATE_INIT_REBOOT, + STATE_REBOOTING, + } state; + uint8_t last_sent_msgtyp; + uint16_t last_discover_secs; + /* Lifetime of xid: + * 1. initial : [INIT]->DHCPDISCOVER->DHCPOFFER->DHCPREQUEST-+->DHCPNAK-------------->[INIT] + * |->DHCPACK->DHCPDECLINE->[INIT] + * `->DHCPACK-------------->[BOUND] + * 2. renew/rebind : [RENEWING/REBINDING]->DHCPREQUEST-+->DHCPNAK->[INIT] + * `->DHCPACK->[BOUND] + */ + uint32_t xid; + uint64_t time_ns_init; + struct net_ip4_addr lease_client_addr; /* .yiaddr */ + struct net_ip4_addr lease_server_id; /* .options[DHCP_OPT_DHCP_SERVER_ID] */ + uint64_t lease_time_ns_t1; /* .options[DHCP_OPT_RENEWAL_TIME] + time_ns_init */ + uint64_t lease_time_ns_t2; /* .options[DHCP_OPT_REBINDING_TIME] + time_ns_init */ + uint64_t lease_time_ns_end; /* .options[DHCP_OPT_ADDRESS_TIME] + time_ns_init */ + struct { + struct net_ip4_addr subnet_mask; /* .options[DHCP_OPT_SUBNET_MASK] */ + struct net_ip4_addr gateway_addr; /* .options[DHCP_OPT_ROUTER] */ + } lease_auxdata; + +}; + +static const char *state_strs[] = { + [STATE_INIT] = "INIT", + [STATE_SELECTING] = "SELECTING", + [STATE_REQUESTING] = "REQUESTING", + [STATE_BOUND] = "BOUND", + [STATE_RENEWING] = "RENEWING", + [STATE_REBINDING] = "REBINDING", + + [STATE_INIT_REBOOT] = "INIT_REBOOT", + [STATE_REBOOTING] = "REBOOTING", +}; + +/** + * For convenience in switch blocks, a list of the states that, when + * msgtyp==DHCP_MSGTYP_REQUEST, dhcp_client_send() has assert()ed the state is + * not. + */ +#define IMPOSSIBLE_REQUEST_STATES \ + STATE_INIT: \ + case STATE_REQUESTING: \ + case STATE_REBINDING: \ + case STATE_REBOOTING + +static inline enum requirement dhcp_table5(typeof((struct dhcp_client){}.state) state, + uint8_t msgtyp, + uint8_t opt) { + /* Encode "Table 5: Fields and options used by DHCP clients" + * from + * https://datatracker.ietf.org/doc/html/rfc2131#page-38. */ +#define INC_ADDR ({ \ + enum requirement req; \ + switch (state) { \ + case STATE_SELECTING: case STATE_INIT_REBOOT: req = MUST; break; \ + case STATE_BOUND: case STATE_RENEWING: req = MUST_NOT; break; \ + case IMPOSSIBLE_REQUEST_STATES: default: req = _SHOULD_NOT_HAPPEN; \ + } \ + req; \ + }) +#define INC_SERVER ({ \ + enum requirement req; \ + switch (state) { \ + case STATE_SELECTING: req = MUST; break; \ + case STATE_INIT_REBOOT: case STATE_BOUND: case STATE_RENEWING: req = MUST_NOT; break; \ + case IMPOSSIBLE_REQUEST_STATES: default: req = _SHOULD_NOT_HAPPEN; \ + } \ + req; \ + }) + struct { enum requirement cols[5]; } row; +#define ROW(...) row = (typeof(row)){{ __VA_ARGS__ }} + switch (opt) { + /* Option DISCOVER INFORM REQUEST DECLINE RELEASE */ + /* ------ ---------- ---------- ---------- -------- -------- */ + case DHCP_OPT_ADDRESS_REQUEST: ROW(MAY, MUST_NOT, INC_ADDR, MUST, MUST_NOT); break; + case DHCP_OPT_ADDRESS_TIME: ROW(MAY, MUST_NOT, MAY, MUST_NOT, MUST_NOT); break; + case DHCP_OPT_OVERLOAD: ROW(MAY, MAY, MAY, MAY, MAY ); break; + case DHCP_OPT_DHCP_MSG_TYPE: ROW(MUST, MUST, MUST, MUST, MUST ); break; + case DHCP_OPT_CLIENT_ID: ROW(MAY, MAY, MAY, MAY, MAY ); break; + case DHCP_OPT_CLASS_ID: ROW(MAY, MAY, MAY, MUST_NOT, MUST_NOT); break; + case DHCP_OPT_DHCP_SERVER_ID: ROW(MUST_NOT, MUST_NOT, INC_SERVER, MUST, MUST ); break; + case DHCP_OPT_PARAMETER_LIST: ROW(MAY, MAY, MAY, MUST_NOT, MUST_NOT); break; + case DHCP_OPT_DHCP_MAX_MSG_SIZE: ROW(MAY, MAY, MAY, MUST_NOT, MUST_NOT); break; + case DHCP_OPT_DHCP_MESSAGE: ROW(SHOULD_NOT, SHOULD_NOT, SHOULD_NOT, SHOULD, SHOULD ); break; + default: ROW(MAY, MAY, MAY, MUST_NOT, MUST_NOT); + } +#undef ROW +#undef INC_SERVER +#undef INC_ADDR + switch (msgtyp) { + case DHCP_MSGTYP_DISCOVER: return row.cols[0]; + case DHCP_MSGTYP_INFORM: return row.cols[1]; + case DHCP_MSGTYP_REQUEST: return row.cols[2]; + case DHCP_MSGTYP_DECLINE: return row.cols[3]; + case DHCP_MSGTYP_RELEASE: return row.cols[4]; + default: return _SHOULD_NOT_HAPPEN; + } +} + +/** + * @param client->state + * @param client->self_eth_addr + * @param client->xid + * @param client->time_ns_init + * @param client->lease_client_addr (sometimes) + * @param client->lease_server_id (sometimes) + * @param client->sock + * + * @return client->last_sent_msgtyp + * @return whether there was an error + */ +static bool dhcp_client_send(struct dhcp_client *client, uint8_t msgtyp, const char *errstr, struct dhcp_msg *scratch_msg) { + /**********************************************************************\ + * Preconditions * + \**********************************************************************/ + + assert(client); + assert(msgtyp == DHCP_MSGTYP_DISCOVER || + msgtyp == DHCP_MSGTYP_INFORM || + msgtyp == DHCP_MSGTYP_REQUEST || + msgtyp == DHCP_MSGTYP_DECLINE || + msgtyp == DHCP_MSGTYP_RELEASE ); + if (msgtyp == DHCP_MSGTYP_REQUEST) + assert(client->state == STATE_SELECTING || /* initial selection */ + client->state == STATE_INIT_REBOOT || /* variant initial selection */ + client->state == STATE_BOUND || /* T1 expired, start renew */ + client->state == STATE_RENEWING ); /* T2 expired, start rebind */ + + /**********************************************************************\ + * Setup * + \**********************************************************************/ + + bool server_broadcasts, client_broadcasts; + + server_broadcasts = !CONFIG_DHCP_CAN_RECV_UNICAST_IP_WITHOUT_IP; + if (msgtyp == DHCP_MSGTYP_REQUEST && + (client->state == STATE_BOUND || client->state == STATE_RENEWING)) + server_broadcasts = false; + + /* https://datatracker.ietf.org/doc/html/rfc2131#section-4.4.4 */ + switch (msgtyp) { + case DHCP_MSGTYP_DISCOVER: client_broadcasts = true; break; + case DHCP_MSGTYP_INFORM: client_broadcasts = true; break; /* may unicast if it knows the server */ + case DHCP_MSGTYP_REQUEST: client_broadcasts = client->state != STATE_BOUND; break; + case DHCP_MSGTYP_DECLINE: client_broadcasts = true; break; + case DHCP_MSGTYP_RELEASE: client_broadcasts = false; break; + default: assert_notreached("invalid message type for client to send"); + } + + /**********************************************************************\ + * Build the message * + \**********************************************************************/ + + *scratch_msg = (struct dhcp_msg){0}; + size_t optlen = 0; + + /* Base structure. + * https://datatracker.ietf.org/doc/html/rfc2131#page-37 */ + scratch_msg->op = DHCP_OP_BOOTREQUEST; + scratch_msg->htype = DHCP_HTYPE_ETHERNET; + scratch_msg->hlen = sizeof(client->self_eth_addr); + scratch_msg->hops = 0; /* relays increment this when they forward it along */ + scratch_msg->xid = uint32be_marshal(client->xid); + scratch_msg->secs = uint16be_marshal( ({ + uint16_t secs; + switch (msgtyp) { + case DHCP_MSGTYP_DISCOVER: case DHCP_MSGTYP_INFORM: + case DHCP_MSGTYP_REQUEST: + secs = (LO_CALL(bootclock, get_time_ns) - client->time_ns_init)/NS_PER_S; + if (!secs) + /* systemd's sd-dhcp-client.c asserts that some + * servers are broken and require .secs to be + * non-zero, even though RFC 2131 explicitly + * says that zero is valid. */ + secs = 1; + if (msgtyp == DHCP_MSGTYP_REQUEST && + client->state == STATE_SELECTING) + /* "The DHCPREQUEST message MUST use the same + * value in the DHCP message header's 'secs' + * field ... as the original DHCPDISCOVER + * message" -- RFC 2131 + */ + secs = client->last_discover_secs; + if (msgtyp == DHCP_MSGTYP_DISCOVER) + /* Record the value to make the above + * possible. */ + client->last_discover_secs = secs; + break; + case DHCP_MSGTYP_DECLINE: case DHCP_MSGTYP_RELEASE: + secs = 0; + break; + default: + assert_notreached("invalid message type for client to send"); + } + secs; + }) ); + switch (msgtyp) { + case DHCP_MSGTYP_DISCOVER: case DHCP_MSGTYP_INFORM: case DHCP_MSGTYP_REQUEST: + scratch_msg->flags = uint16be_marshal(server_broadcasts ? DHCP_FLAG_BROADCAST : 0); + break; + case DHCP_MSGTYP_DECLINE: case DHCP_MSGTYP_RELEASE: + scratch_msg->flags = uint16be_marshal(0); + break; + } + switch (msgtyp) { + case DHCP_MSGTYP_DISCOVER: scratch_msg->ciaddr = net_ip4_addr_zero; break; + case DHCP_MSGTYP_INFORM: scratch_msg->ciaddr = client->lease_client_addr; break; + case DHCP_MSGTYP_REQUEST: switch (client->state) { + case STATE_SELECTING: case STATE_INIT_REBOOT: + scratch_msg->ciaddr = net_ip4_addr_zero; break; + case STATE_BOUND: case STATE_RENEWING: /* case STATE_REBINDING: */ + /* RFC 2131 includes "REBINDING" here, but a + * DHCPREQUEST is never sent in the REBINDING + * state. */ + scratch_msg->ciaddr = client->lease_client_addr; break; + case IMPOSSIBLE_REQUEST_STATES: + assert_notreached("invalid client state for sending DHCPREQUEST"); + } break; + case DHCP_MSGTYP_DECLINE: scratch_msg->ciaddr = net_ip4_addr_zero; break; + case DHCP_MSGTYP_RELEASE: scratch_msg->ciaddr = client->lease_client_addr; break; + } + scratch_msg->yiaddr = net_ip4_addr_zero; /* only set by servers */ + scratch_msg->siaddr = net_ip4_addr_zero; /* only set by servers */ + scratch_msg->giaddr = net_ip4_addr_zero; /* only set by relays */ + memcpy(scratch_msg->chaddr, client->self_eth_addr.octets, sizeof(client->self_eth_addr)); + /* scratch_msg->sname = "options, if indicated in 'sname/file' option'; otherwise unused"; */ + /* scratch_msg->file = "options, if indicated in 'sname/file' option'; otherwise unused"; */ + + /* Magic cookie. + * https://datatracker.ietf.org/doc/html/rfc2131#section-4.1 */ + scratch_msg->options[optlen++] = dhcp_magic_cookie[0]; + scratch_msg->options[optlen++] = dhcp_magic_cookie[1]; + scratch_msg->options[optlen++] = dhcp_magic_cookie[2]; + scratch_msg->options[optlen++] = dhcp_magic_cookie[3]; + + /* Options. */ + for (uint8_t opt = 1; opt < 255; opt++) { + enum requirement req = dhcp_table5(client->state, msgtyp, opt); + switch (req) { + case MUST_NOT: + /* Do nothing. */ + break; + case MUST: + case SHOULD: + case SHOULD_NOT: + case MAY: + struct { size_t len; const void *ptr; } val; + uint8_t _val_prl[] = { + DHCP_OPT_SUBNET_MASK, + DHCP_OPT_ROUTER, + DHCP_OPT_RENEWAL_TIME, + DHCP_OPT_REBINDING_TIME, + }; + uint16be_t _val16 ; +#define V_RAW(len, ptr) val = (typeof(val)){ len, ptr } +#define V_OBJ(x) V_RAW(sizeof(x), &x) +#define V_STR(x) V_RAW(x ? strlen(x) : 0, x) +#define V_NONE() V_RAW(0, NULL) + switch (opt) { + /* For clarity, list all options mentioned in "Table 5: + * Fields and options used by DHCP clients" from + * https://datatracker.ietf.org/doc/html/rfc2131#page-38, + * even if we don't have a value for them. */ + case DHCP_OPT_ADDRESS_REQUEST: V_OBJ(client->lease_client_addr); break; + case DHCP_OPT_ADDRESS_TIME: V_NONE(); break; + case DHCP_OPT_OVERLOAD: V_NONE(); break; + case DHCP_OPT_DHCP_MSG_TYPE: V_OBJ(msgtyp); break; + case DHCP_OPT_CLIENT_ID: V_RAW(client->self_id_len, client->self_id_dat); break; + case DHCP_OPT_CLASS_ID: V_NONE(); break; + case DHCP_OPT_DHCP_SERVER_ID: V_OBJ(client->lease_server_id); break; + case DHCP_OPT_PARAMETER_LIST: V_OBJ(_val_prl); break; + case DHCP_OPT_DHCP_MAX_MSG_SIZE: + if (CONFIG_DHCP_OPT_SIZE <= DHCP_MSG_MIN_MAX_OPT_SIZE) + V_NONE(); + else { + _val16 = uint16be_marshal(20 /* IP header */ + + 8 /* UDP header */ + + sizeof(*scratch_msg)); + V_OBJ(_val16); + } + break; + case DHCP_OPT_DHCP_MESSAGE: V_STR(errstr); break; + /* "Site-specific" and "All others". */ + case DHCP_OPT_HOSTNAME: V_STR(client->self_hostname); break; + default: V_NONE(); + }; +#undef V_NONE +#undef V_STR +#undef V_OBJ +#undef V_RAW + if (req == MUST) + assert(val.len); + if (val.len) { + assert(val.len <= UINT16_MAX); + for (size_t done = 0; done < val.len;) { + uint8_t len = val.len - done > UINT8_MAX + ? UINT8_MAX + : val.len - done; + scratch_msg->options[optlen++] = opt; + scratch_msg->options[optlen++] = len; + memcpy(&scratch_msg->options[optlen], &((char*)val.ptr)[done], len); + optlen += len; + done += len; + } + } + break; + case _SHOULD_NOT_HAPPEN: + assert_notreached("bad table"); + } + } + scratch_msg->options[optlen++] = DHCP_OPT_END; + assert(optlen <= CONFIG_DHCP_OPT_SIZE); + + /**********************************************************************\ + * Send * + \**********************************************************************/ + debugf("state %s: sending DHCP %s", state_strs[client->state], dhcp_msgtyp_str(msgtyp)); + ssize_t r = LO_CALL(client->sock, sendto, scratch_msg, DHCP_MSG_BASE_SIZE + optlen, + client_broadcasts ? net_ip4_addr_broadcast : client->lease_server_id, DHCP_PORT_SERVER); + if (r < 0) { + debugf("error: sendto: %zd", r); + return true; + } + client->last_sent_msgtyp = msgtyp; + return false; +} + +struct dhcp_recv_msg { + struct dhcp_msg raw; + struct { + uint16_t off; + uint16_t len; + } options[0xff]; + uint8_t option_dat[sizeof((struct dhcp_msg){}.options)+ + sizeof((struct dhcp_msg){}.file)+ + sizeof((struct dhcp_msg){}.sname)]; +}; + +/** @return whether there is an error */ +static inline bool _dhcp_client_recv_measure_opts(struct dhcp_recv_msg *ret, uint8_t *optoverload, uint8_t *dat, size_t len, bool require_pad) { + for (size_t pos = 0, opt_len; pos < len; pos += opt_len) { + uint8_t opt_typ = dat[pos++]; + switch (opt_typ) { + case DHCP_OPT_END: + if (require_pad) + while (pos < len) + if (dat[pos++] != DHCP_OPT_PAD) + return true; + return false; + case DHCP_OPT_PAD: + opt_len = 0; + break; + default: + if (pos == len) + return true; + opt_len = dat[pos++]; + if (pos+opt_len > len) + return true; + ret->options[opt_typ].len += opt_len; + if (opt_typ == DHCP_OPT_OVERLOAD && opt_len == 1) + *optoverload = *optoverload | dat[pos]; + } + } + return true; +} + +static inline void _dhcp_client_recv_consolidate_opts(struct dhcp_recv_msg *ret, uint8_t *dat, size_t len) { + for (size_t pos = 0, opt_len; pos < len; pos += opt_len) { + uint8_t opt_typ = dat[pos++]; + switch (opt_typ) { + case DHCP_OPT_END: + return; + case DHCP_OPT_PAD: + opt_len = 0; + break; + default: + opt_len = dat[pos++]; + memcpy(&ret->option_dat[ret->options[opt_typ].off+ret->options[opt_typ].len], &dat[pos], opt_len); + ret->options[opt_typ].len += opt_len; + } + } +} + +static inline enum requirement dhcp_table3(uint8_t req_msgtyp, uint8_t resp_msgtyp, uint8_t resp_opt) { + /* Encode "Table 3: Fields and options used by DHCP servers" + * from https://datatracker.ietf.org/doc/html/rfc2131#page-29, + * with modifications from + * https://datatracker.ietf.org/doc/html/rfc6842#page-4. */ + struct { enum requirement cols[3]; } row; +#define ROW(...) row = (typeof(row)){{ __VA_ARGS__ }} + switch (resp_opt) { + /* Option DHCPOFFER DHCPACK DHCPNAK */ + /* -------------------------- -------- ---------- -------- */ + case DHCP_OPT_ADDRESS_REQUEST: ROW(MUST_NOT, MUST_NOT, MUST_NOT); break; + case DHCP_OPT_ADDRESS_TIME: ROW(MUST, req_msgtyp == DHCP_MSGTYP_REQUEST ? MUST : MUST_NOT, + MUST_NOT); break; + case DHCP_OPT_OVERLOAD: ROW(MAY, MAY, MUST_NOT); break; + case DHCP_OPT_DHCP_MSG_TYPE: ROW(MUST, MUST, MUST ); break; + case DHCP_OPT_PARAMETER_LIST: ROW(MUST_NOT, MUST_NOT, MUST_NOT); break; + case DHCP_OPT_DHCP_MESSAGE: ROW(SHOULD, SHOULD, SHOULD ); break; + case DHCP_OPT_CLIENT_ID: ROW(MAY, MAY, MAY ); /* MUST_NOTs changed to MAY, per RFC 6842 */ break; + case DHCP_OPT_CLASS_ID: ROW(MAY, MAY, MAY ); break; + case DHCP_OPT_DHCP_SERVER_ID: ROW(MUST, MUST, MUST ); break; + case DHCP_OPT_DHCP_MAX_MSG_SIZE: ROW(MUST_NOT, MUST_NOT, MUST_NOT); break; + default: ROW(MAY, MAY, MUST_NOT); + } +#undef ROW + switch (resp_msgtyp) { + case DHCP_MSGTYP_OFFER: return row.cols[0]; + case DHCP_MSGTYP_ACK: return row.cols[1]; + case DHCP_MSGTYP_NAK: return row.cols[2]; + default: return _SHOULD_NOT_HAPPEN; + } +} + +/** + * @param client->sock + * @param client->self_eth_addr + * @param client->xid + * @param client->lease_server_id + * + * @return + * - <0: -errno + * - 0: success + * - >0: should not happen + */ +static ssize_t dhcp_client_recv(struct dhcp_client *client, struct dhcp_recv_msg *ret) { + struct net_ip4_addr srv_addr; + uint16_t srv_port; + ssize_t msg_len; + + assert(client); + + ignore: + msg_len = LO_CALL(client->sock, recvfrom, &ret->raw, sizeof(ret->raw), &srv_addr, &srv_port); + if (msg_len < 0) + /* msg_len is -errno */ + return msg_len; + + /* Validate L3: IP */ + /* Don't validate that srv_addr matches client->server_id + * because there may be a relay between us and the server, and + * don't bother to track the relay IP either, because it may + * change. */ + + /* Validate L4: UDP. */ + if (srv_port != DHCP_PORT_SERVER) + goto ignore; + + /* Validate L5: DHCP. */ + if ((size_t)msg_len < DHCP_MSG_BASE_SIZE + sizeof(dhcp_magic_cookie)) + /* ignore impossibly short message */ + goto ignore; + if ((size_t)msg_len > sizeof(ret->raw)) + /* ignore message that is larger than the specified + * DHCP_OPT_DHCP_MAX_MSG_SIZE */ + goto ignore; + if (ret->raw.op != DHCP_OP_BOOTREPLY) + /* ignore non-replies */ + goto ignore; + if (memcmp(ret->raw.chaddr, client->self_eth_addr.octets, sizeof(client->self_eth_addr))) + /* ignore messages that aren't to us */ + goto ignore; + if (uint32be_unmarshal(ret->raw.xid) != client->xid) + /* ignore messages that aren't in response to what we've said */ + goto ignore; + if (memcmp(client->lease_server_id.octets, net_ip4_addr_zero.octets, 4)) + if (memcmp(srv_addr.octets, client->lease_server_id.octets, 4)) + /* ignore messages from the wrong server */ + goto ignore; + if (memcmp(ret->raw.options, dhcp_magic_cookie, sizeof(dhcp_magic_cookie))) + /* ignore messages without options */ + goto ignore; + + /* Consolidate split options into contiguous buffers. + * + * RFC 2131 and RFC 2132 specify this behavior, but are a bit + * ambiguous about it; RFC 3396 provides clarification. + * + * "The aggregate option buffer is made up of the optional + * parameters field, the file field, and the sname field, in + * that order." -- RFC 3396 + */ + uint8_t optoverload = 0; + memset(&ret->options, 0, sizeof(ret->options)); + /* Size the buffers. */ + if (_dhcp_client_recv_measure_opts(ret, &optoverload, + &ret->raw.options[sizeof(dhcp_magic_cookie)], + msg_len - (DHCP_MSG_BASE_SIZE + sizeof(dhcp_magic_cookie)), + false)) + goto ignore; + if (optoverload & 1u) + if (_dhcp_client_recv_measure_opts(ret, &optoverload, + ret->raw.file, sizeof(ret->raw.file), + true)) + goto ignore; + if (optoverload & 2u) + if (_dhcp_client_recv_measure_opts(ret, &optoverload, + ret->raw.sname, sizeof(ret->raw.sname), + true)) + goto ignore; + /* Validate sizes, allocate buffers. */ + for (uint8_t opt = 1, allocated = 0; opt < 255; opt++) { + if (!ret->options[opt].len) + continue; + if (!dhcp_opt_length_is_valid(opt, ret->options[opt].len)) + goto ignore; + ret->options[opt].off = allocated; + allocated += ret->options[opt].len; + ret->options[opt].len = 0; + } + /* Fill the buffers. */ + _dhcp_client_recv_consolidate_opts(ret, + &ret->raw.options[sizeof(dhcp_magic_cookie)], + msg_len - (DHCP_MSG_BASE_SIZE + sizeof(dhcp_magic_cookie))); + if (optoverload & 1u) + _dhcp_client_recv_consolidate_opts(ret, ret->raw.file, sizeof(ret->raw.file)); + if (optoverload & 2u) + _dhcp_client_recv_consolidate_opts(ret, ret->raw.sname, sizeof(ret->raw.sname)); + /* Validate presence of options. */ + if (!ret->options[DHCP_OPT_DHCP_MSG_TYPE].len) + goto ignore; + for (uint8_t opt = 1; opt < 255; opt++) { + enum requirement req = dhcp_table3(client->last_sent_msgtyp, + ret->option_dat[ret->options[DHCP_OPT_DHCP_MSG_TYPE].off], + opt); + switch (req) { + case MUST: + if (!ret->options[opt].len) + goto ignore; + break; + case MUST_NOT: + if (ret->options[opt].len) + goto ignore; + break; + case SHOULD: + case SHOULD_NOT: + case MAY: + /* Do nothing. */ + break; + case _SHOULD_NOT_HAPPEN: + goto ignore; + } + } + /* Validate values of options. */ + if (ret->options[DHCP_OPT_CLASS_ID].len) { + /* https://datatracker.ietf.org/doc/html/rfc6842#page-4 */ + if (ret->options[DHCP_OPT_CLASS_ID].len != client->self_id_len || + memcmp(&ret->option_dat[ret->options[DHCP_OPT_CLASS_ID].off], client->self_id_dat, client->self_id_len)) + /* ignore messages that aren't to us */ + goto ignore; + } + + return 0; +} + +/** @return true if there's a conflict, false if the addr appears to be unused */ +static bool dhcp_check_conflict(lo_interface net_packet_conn sock, struct net_ip4_addr addr) { + assert(!LO_IS_NULL(sock)); + ssize_t v = LO_CALL(sock, sendto, "CHECK_IP_CONFLICT", 17, addr, 5000); + debugf("check_ip_conflict => %zd", v); + return v != -NET_EARP_TIMEOUT; +} + +static void dhcp_client_take_lease(struct dhcp_client *client, struct dhcp_recv_msg *msg, bool ifup) { + assert(client); + assert(msg); + + client->lease_client_addr = msg->raw.yiaddr; + client->lease_auxdata.subnet_mask = msg->options[DHCP_OPT_SUBNET_MASK].len + ? *((struct net_ip4_addr *)&msg->option_dat[msg->options[DHCP_OPT_SUBNET_MASK].off]) + : net_ip4_addr_zero; + client->lease_auxdata.gateway_addr = msg->options[DHCP_OPT_ROUTER].len + ? *((struct net_ip4_addr *)&msg->option_dat[msg->options[DHCP_OPT_SUBNET_MASK].off]) + : net_ip4_addr_zero; + client->lease_server_id = + *((struct net_ip4_addr *)&msg->option_dat[msg->options[DHCP_OPT_DHCP_SERVER_ID].off]); + + uint64_t dur_ns_end = + ((uint64_t)uint32be_decode(&msg->option_dat[msg->options[DHCP_OPT_ADDRESS_TIME].off]))*NS_PER_S; + uint64_t dur_ns_t1 = msg->options[DHCP_OPT_RENEWAL_TIME].len + ? ((uint64_t)uint32be_decode(&msg->option_dat[msg->options[DHCP_OPT_RENEWAL_TIME].off]))*NS_PER_S + : (dur_ns_end == DHCP_INFINITY * NS_PER_S) + ? DHCP_INFINITY * NS_PER_S + : dur_ns_end/2; + uint64_t dur_ns_t2 = msg->options[DHCP_OPT_REBINDING_TIME].len + ? ((uint64_t)uint32be_decode(&msg->option_dat[msg->options[DHCP_OPT_RENEWAL_TIME].off]))*NS_PER_S + : (dur_ns_end == DHCP_INFINITY * NS_PER_S) + ? DHCP_INFINITY * NS_PER_S + : (dur_ns_end*7)/8; /* 0.875 = 7/8 */ + + client->lease_time_ns_t1 = (dur_ns_t1 == DHCP_INFINITY * NS_PER_S) ? 0 : client->time_ns_init + dur_ns_t1; + client->lease_time_ns_t2 = (dur_ns_t2 == DHCP_INFINITY * NS_PER_S) ? 0 : client->time_ns_init + dur_ns_t2; + client->lease_time_ns_end = (dur_ns_end == DHCP_INFINITY * NS_PER_S) ? 0 : client->time_ns_init + dur_ns_end; + + if (ifup) { + infof("applying configuration to "PRI_net_eth_addr, ARG_net_eth_addr(client->self_eth_addr)); + infof(":: addr = "PRI_net_ip4_addr, ARG_net_ip4_addr(client->lease_client_addr)); + infof(":: gateway_addr = "PRI_net_ip4_addr, ARG_net_ip4_addr(client->lease_auxdata.gateway_addr)); + infof(":: subnet_mask = "PRI_net_ip4_addr, ARG_net_ip4_addr(client->lease_auxdata.subnet_mask)); + LO_CALL(client->iface, ifup, (struct net_iface_config){ + .addr = client->lease_client_addr, + .gateway_addr = client->lease_auxdata.gateway_addr, + .subnet_mask = client->lease_auxdata.subnet_mask, + }); + } +} + +static void dhcp_client_setstate(struct dhcp_client *client, + typeof((struct dhcp_client){}.state) newstate, + uint8_t send_msgtyp, const char *errstr, struct dhcp_recv_msg *scratch_msg) { + if (send_msgtyp) + (void)dhcp_client_send(client, send_msgtyp, errstr, &scratch_msg->raw); + client->state = newstate; +} + +[[noreturn]] static void dhcp_client_run(struct dhcp_client *client, struct dhcp_recv_msg *scratch_msg) { + assert(client); + + ssize_t r; + + /* State transition diagram: https://datatracker.ietf.org/doc/html/rfc2131#page-35 */ + for (;;) { + debugf("loop: state=%s", state_strs[client->state]); + switch (client->state) { + case STATE_INIT: + client->xid = rand_uint63n(UINT32_MAX); + client->time_ns_init = LO_CALL(bootclock, get_time_ns); + dhcp_client_setstate(client, STATE_SELECTING, DHCP_MSGTYP_DISCOVER, NULL, scratch_msg); + break; + case STATE_SELECTING: + LO_CALL(client->sock, set_recv_deadline, client->time_ns_init+CONFIG_DHCP_SELECTING_NS); + switch ((r = dhcp_client_recv(client, scratch_msg))) { + case 0: + switch (scratch_msg->option_dat[scratch_msg->options[DHCP_OPT_DHCP_MSG_TYPE].off]) { + case DHCP_MSGTYP_OFFER: + /* Accept the first offer. */ + dhcp_client_take_lease(client, scratch_msg, false); + dhcp_client_setstate(client, STATE_REQUESTING, DHCP_MSGTYP_REQUEST, NULL, scratch_msg); + break; + default: + /* ignore */ + } + break; + case -NET_ERECV_TIMEOUT: + dhcp_client_setstate(client, STATE_INIT, 0, NULL, scratch_msg); + break; + default: + assert(r < 0); + debugf("error: recvfrom: %d", r); + } + break; + case STATE_REQUESTING: + LO_CALL(client->sock, set_recv_deadline, 0); + switch ((r = dhcp_client_recv(client, scratch_msg))) { + case 0: + switch (scratch_msg->option_dat[scratch_msg->options[DHCP_OPT_DHCP_MSG_TYPE].off]) { + case DHCP_MSGTYP_NAK: + dhcp_client_setstate(client, STATE_INIT, 0, NULL, scratch_msg); + break; + case DHCP_MSGTYP_ACK: + if (dhcp_check_conflict(client->sock, client->lease_client_addr)) { + debugf("IP "PRI_net_ip4_addr" is already in use", + ARG_net_ip4_addr(client->lease_client_addr)); + dhcp_client_setstate(client, STATE_INIT, DHCP_MSGTYP_DECLINE, "IP is already in use", scratch_msg); + } else { + dhcp_client_take_lease(client, scratch_msg, true); + dhcp_client_setstate(client, STATE_BOUND, 0, NULL, scratch_msg); + } + break; + default: + /* ignore */ + } + break; + default: + assert(r < 0); + debugf("error: recvfrom: %d", r); + } + break; + case STATE_BOUND: + LO_CALL(client->sock, set_recv_deadline, client->lease_time_ns_t1); + switch ((r = dhcp_client_recv(client, scratch_msg))) { + case 0: + /* discard */ + break; + case -NET_ERECV_TIMEOUT: + dhcp_client_setstate(client, STATE_RENEWING, DHCP_MSGTYP_REQUEST, NULL, scratch_msg); + break; + default: + assert(r < 0); + debugf("error: recvfrom: %d", r); + } + break; + case STATE_RENEWING: + client->xid = rand_uint63n(UINT32_MAX); + client->time_ns_init = LO_CALL(bootclock, get_time_ns); + + LO_CALL(client->sock, set_recv_deadline, client->lease_time_ns_t2); + switch ((r = dhcp_client_recv(client, scratch_msg))) { + case 0: + switch (scratch_msg->option_dat[scratch_msg->options[DHCP_OPT_DHCP_MSG_TYPE].off]) { + case DHCP_MSGTYP_NAK: + LO_CALL(client->iface, ifdown); + dhcp_client_setstate(client, STATE_INIT, 0, NULL, scratch_msg); + break; + case DHCP_MSGTYP_ACK: + dhcp_client_take_lease(client, scratch_msg, true); + dhcp_client_setstate(client, STATE_BOUND, 0, NULL, scratch_msg); + break; + default: + /* ignore */ + } + break; + case -NET_ERECV_TIMEOUT: + client->lease_server_id = net_ip4_addr_zero; + dhcp_client_setstate(client, STATE_REBINDING, DHCP_MSGTYP_REQUEST, NULL, scratch_msg); + break; + default: + assert(r < 0); + debugf("error: recvfrom: %d", r); + } + break; + case STATE_REBINDING: + LO_CALL(client->sock, set_recv_deadline, client->lease_time_ns_end); + switch ((r = dhcp_client_recv(client, scratch_msg))) { + case 0: + switch (scratch_msg->option_dat[scratch_msg->options[DHCP_OPT_DHCP_MSG_TYPE].off]) { + case DHCP_MSGTYP_NAK: + LO_CALL(client->iface, ifdown); + dhcp_client_setstate(client, STATE_BOUND, 0, NULL, scratch_msg); + break; + case DHCP_MSGTYP_ACK: + dhcp_client_take_lease(client, scratch_msg, true); + dhcp_client_setstate(client, STATE_BOUND, 0, NULL, scratch_msg); + break; + default: + /* ignore */ + } + break; + case -NET_ERECV_TIMEOUT: + LO_CALL(client->iface, ifdown); + dhcp_client_setstate(client, STATE_BOUND, 0, NULL, scratch_msg); + break; + default: + assert(r < 0); + debugf("error: recvfrom: %d", r); + } + break; + case STATE_INIT_REBOOT: + case STATE_REBOOTING: + assert_notreached("initialization with known network address is not supported"); + default: + assert_notreached("invalid client state"); + } + } +} + +[[noreturn]] void dhcp_client_main(lo_interface net_iface iface, + char *self_hostname) { + assert(!LO_IS_NULL(iface)); + + /* Even though a client ID is optional and not meaningful for + * us (the best we can do is to duplicate .chaddr), systemd's + * sd-dhcp-client.c asserts that some servers are broken and + * require it to be set. */ + struct {uint8_t typ; struct net_eth_addr dat;} client_id = { + DHCP_HTYPE_ETHERNET, + LO_CALL(iface, hwaddr), + }; + + struct dhcp_client client = { + /* Static. */ + .iface = iface, + .sock = LO_CALL(iface, udp_conn, DHCP_PORT_CLIENT), + .self_eth_addr = LO_CALL(iface, hwaddr), + .self_hostname = self_hostname, + .self_id_len = sizeof(client_id), + .self_id_dat = &client_id, + + /* Mutable. */ + .state = STATE_INIT, + }; + assert(!LO_IS_NULL(client.sock)); + + struct dhcp_recv_msg scratch; + + dhcp_client_run(&client, &scratch); +} |