From fce03832fa55083cb7b121a04e33f69258aefc82 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sat, 21 Mar 2026 02:11:28 +0900 Subject: [PATCH 1/9] test-dhcp-client: fix packet length and checksum in IP header --- src/libsystemd-network/test-dhcp-client.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libsystemd-network/test-dhcp-client.c b/src/libsystemd-network/test-dhcp-client.c index 7a8b149e20..95a7d06592 100644 --- a/src/libsystemd-network/test-dhcp-client.c +++ b/src/libsystemd-network/test-dhcp-client.c @@ -540,8 +540,8 @@ static void test_addr_acq(sd_event *e) { } static uint8_t test_addr_bootp_reply[] = { - 0x45, 0x00, 0x01, 0x48, 0x00, 0x00, 0x40, 0x00, - 0xff, 0x11, 0x70, 0xa3, 0x0a, 0x00, 0x00, 0x02, + 0x45, 0x00, 0x01, 0x40, 0x00, 0x00, 0x40, 0x00, + 0xff, 0x11, 0x70, 0xab, 0x0a, 0x00, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0x00, 0x43, 0x00, 0x44, 0x01, 0x2c, 0x2b, 0x91, 0x02, 0x01, 0x06, 0x00, 0x69, 0xd3, 0x79, 0x11, 0x17, 0x00, 0x80, 0x00, From f0387aa666559827fa10959b832d217d78e0a533 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Fri, 13 Mar 2026 07:11:06 +0900 Subject: [PATCH 2/9] test-dhcp-client: modernize test code --- src/libsystemd-network/test-dhcp-client.c | 478 ++++++++-------------- 1 file changed, 173 insertions(+), 305 deletions(-) diff --git a/src/libsystemd-network/test-dhcp-client.c b/src/libsystemd-network/test-dhcp-client.c index 95a7d06592..97802e2c16 100644 --- a/src/libsystemd-network/test-dhcp-client.c +++ b/src/libsystemd-network/test-dhcp-client.c @@ -8,9 +8,6 @@ #include #include #include -#if HAVE_VALGRIND_VALGRIND_H -# include -#endif #include "sd-dhcp-client.h" #include "sd-dhcp-lease.h" @@ -33,7 +30,7 @@ static struct hw_addr_data hw_addr = { .length = ETH_ALEN, .ether = {{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }}, }; -typedef int (*test_callback_recv_t)(size_t size, DHCPMessage *dhcp); +typedef void (*test_callback_recv_t)(size_t size, DHCPMessage *dhcp); struct bootp_addr_data { uint8_t *offer_buf; @@ -43,129 +40,97 @@ struct bootp_addr_data { }; static struct bootp_addr_data *bootp_test_context; -static bool verbose = true; static int test_fd[2]; static test_callback_recv_t callback_recv; static be32_t xid; -static void test_request_basic(sd_event *e) { - int r; - - sd_dhcp_client *client; - - if (verbose) - log_info("* %s", __func__); - +TEST(dhcp_client_setters) { /* Initialize client without Anonymize settings. */ - r = sd_dhcp_client_new(&client, false); - - assert_se(r >= 0); - assert_se(client); - - r = sd_dhcp_client_attach_event(client, e, 0); - assert_se(r >= 0); + _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL; + ASSERT_OK(sd_dhcp_client_new(&client, /* anonymize= */ false)); + ASSERT_NOT_NULL(client); ASSERT_RETURN_EXPECTED_SE(sd_dhcp_client_set_request_option(NULL, 0) == -EINVAL); ASSERT_RETURN_EXPECTED_SE(sd_dhcp_client_set_request_address(NULL, NULL) == -EINVAL); ASSERT_RETURN_EXPECTED_SE(sd_dhcp_client_set_ifindex(NULL, 0) == -EINVAL); - assert_se(sd_dhcp_client_set_ifindex(client, 15) == 0); + ASSERT_OK(sd_dhcp_client_set_ifindex(client, 15)); ASSERT_RETURN_EXPECTED_SE(sd_dhcp_client_set_ifindex(client, -42) == -EINVAL); ASSERT_RETURN_EXPECTED_SE(sd_dhcp_client_set_ifindex(client, -1) == -EINVAL); ASSERT_RETURN_EXPECTED_SE(sd_dhcp_client_set_ifindex(client, 0) == -EINVAL); - assert_se(sd_dhcp_client_set_ifindex(client, 1) == 0); + ASSERT_OK(sd_dhcp_client_set_ifindex(client, 1)); - assert_se(sd_dhcp_client_set_hostname(client, "host") == 1); - assert_se(sd_dhcp_client_set_hostname(client, "host.domain") == 1); - assert_se(sd_dhcp_client_set_hostname(client, NULL) == 1); - assert_se(sd_dhcp_client_set_hostname(client, "~host") == -EINVAL); - assert_se(sd_dhcp_client_set_hostname(client, "~host.domain") == -EINVAL); + ASSERT_OK_POSITIVE(sd_dhcp_client_set_hostname(client, "host")); + ASSERT_OK_ZERO(sd_dhcp_client_set_hostname(client, "host")); + ASSERT_OK_POSITIVE(sd_dhcp_client_set_hostname(client, "host.domain")); + ASSERT_OK_POSITIVE(sd_dhcp_client_set_hostname(client, NULL)); + ASSERT_ERROR(sd_dhcp_client_set_hostname(client, "~host"), EINVAL); + ASSERT_ERROR(sd_dhcp_client_set_hostname(client, "~host.domain"), EINVAL); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_SUBNET_MASK) == 0); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_ROUTER) == 0); - /* This PRL option is not set when using Anonymize, but in this test - * Anonymize settings are not being used. */ - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_HOST_NAME) == 0); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_DOMAIN_NAME) == 0); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_DOMAIN_NAME_SERVER) == 0); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_SUBNET_MASK)); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_ROUTER)); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_HOST_NAME)); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_DOMAIN_NAME)); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_DOMAIN_NAME_SERVER)); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PAD) == -EINVAL); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_END) == -EINVAL); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_MESSAGE_TYPE) == -EINVAL); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_OVERLOAD) == -EINVAL); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST) == -EINVAL); + ASSERT_ERROR(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PAD), EINVAL); + ASSERT_ERROR(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_END), EINVAL); + ASSERT_ERROR(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_MESSAGE_TYPE), EINVAL); + ASSERT_ERROR(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_OVERLOAD), EINVAL); + ASSERT_ERROR(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST), EINVAL); /* RFC7844: option 33 (SD_DHCP_OPTION_STATIC_ROUTE) is set in the * default PRL when using Anonymize, so it is changed to other option * that is not set by default, to check that it was set successfully. * Options not set by default (using or not anonymize) are option 17 * (SD_DHCP_OPTION_ROOT_PATH) and 42 (SD_DHCP_OPTION_NTP_SERVER) */ - assert_se(sd_dhcp_client_set_request_option(client, 17) == 1); - assert_se(sd_dhcp_client_set_request_option(client, 17) == 0); - assert_se(sd_dhcp_client_set_request_option(client, 42) == 1); - assert_se(sd_dhcp_client_set_request_option(client, 17) == 0); - - sd_dhcp_client_unref(client); + ASSERT_OK_POSITIVE(sd_dhcp_client_set_request_option(client, 17)); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, 17)); + ASSERT_OK_POSITIVE(sd_dhcp_client_set_request_option(client, 42)); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, 17)); } -static void test_request_anonymize(sd_event *e) { - int r; - - sd_dhcp_client *client; - - if (verbose) - log_info("* %s", __func__); - +TEST(dhcp_client_anonymize) { /* Initialize client with Anonymize settings. */ - r = sd_dhcp_client_new(&client, true); + _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL; + ASSERT_OK(sd_dhcp_client_new(&client, /* anonymize= */ true)); + ASSERT_NOT_NULL(client); - assert_se(r >= 0); - assert_se(client); - - r = sd_dhcp_client_attach_event(client, e, 0); - assert_se(r >= 0); - - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_NETBIOS_NAME_SERVER) == 0); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_NETBIOS_NAME_SERVER)); /* This PRL option is not set when using Anonymize */ - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_HOST_NAME) == 1); - assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST) == -EINVAL); + ASSERT_OK_POSITIVE(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_HOST_NAME)); + ASSERT_ERROR(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST), EINVAL); /* RFC7844: option 101 (SD_DHCP_OPTION_NEW_TZDB_TIMEZONE) is not set in the * default PRL when using Anonymize, */ - assert_se(sd_dhcp_client_set_request_option(client, 101) == 1); - assert_se(sd_dhcp_client_set_request_option(client, 101) == 0); - - sd_dhcp_client_unref(client); + ASSERT_OK_POSITIVE(sd_dhcp_client_set_request_option(client, 101)); + ASSERT_OK_ZERO(sd_dhcp_client_set_request_option(client, 101)); } -static void test_checksum(void) { +TEST(dhcp_packet_checksum) { uint8_t buf[20] = { 0x45, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff }; - if (verbose) - log_info("* %s", __func__); - - assert_se(dhcp_packet_checksum((uint8_t*)&buf, 20) == be16toh(0x78ae)); + ASSERT_EQ(dhcp_packet_checksum(buf, 20), be16toh(0x78ae)); } -static void test_dhcp_identifier_set_iaid(void) { +TEST(dhcp_identifier_set_iaid) { uint32_t iaid_legacy; be32_t iaid; - assert_se(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy_unstable_byteorder= */ true, &iaid_legacy) >= 0); - assert_se(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy_unstable_byteorder= */ false, &iaid) >= 0); + ASSERT_OK(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy_unstable_byteorder= */ true, &iaid_legacy)); + ASSERT_OK(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy_unstable_byteorder= */ false, &iaid)); - /* we expect, that the MAC address was hashed. The legacy value is in native - * endianness. */ - assert_se(iaid_legacy == 0x8dde4ba8u); - assert_se(iaid == htole32(0x8dde4ba8u)); + /* we expect, that the MAC address was hashed. The legacy value is in native endianness. */ + ASSERT_EQ(iaid_legacy, 0x8dde4ba8u); + ASSERT_EQ(iaid, htole32(0x8dde4ba8u)); #if __BYTE_ORDER == __LITTLE_ENDIAN - assert_se(iaid == iaid_legacy); + ASSERT_EQ(iaid, iaid_legacy); #else - assert_se(iaid == bswap_32(iaid_legacy)); + ASSERT_EQ(iaid, bswap_32(iaid_legacy)); #endif } @@ -175,15 +140,15 @@ static int check_options(uint8_t code, uint8_t len, const void *option, void *us sd_dhcp_duid duid; uint32_t iaid; - assert_se(sd_dhcp_duid_set_en(&duid) >= 0); - assert_se(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy_unstable_byteorder= */ true, &iaid) >= 0); + ASSERT_OK(sd_dhcp_duid_set_en(&duid)); + ASSERT_OK(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy_unstable_byteorder= */ true, &iaid)); - assert_se(len == sizeof(uint8_t) + sizeof(uint32_t) + duid.size); - assert_se(len == 19); - assert_se(((uint8_t*) option)[0] == 0xff); + ASSERT_EQ(len, 19u); + ASSERT_EQ(len, sizeof(uint8_t) + sizeof(uint32_t) + duid.size); + ASSERT_EQ(((uint8_t*) option)[0], 0xff); - assert_se(memcmp((uint8_t*) option + 1, &iaid, sizeof(iaid)) == 0); - assert_se(memcmp((uint8_t*) option + 5, &duid.duid, duid.size) == 0); + ASSERT_EQ(memcmp((uint8_t*) option + 1, &iaid, sizeof(iaid)), 0); + ASSERT_EQ(memcmp((uint8_t*) option + 5, &duid.duid, duid.size), 0); break; } @@ -195,24 +160,21 @@ static int check_options(uint8_t code, uint8_t len, const void *option, void *us } int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link, const void *packet, size_t len) { - size_t size; - _cleanup_free_ DHCPPacket *discover = NULL; uint16_t ip_check, udp_check; - assert_se(s >= 0); - assert_se(packet); + ASSERT_OK(s); + ASSERT_NOT_NULL(packet); - size = sizeof(DHCPPacket); - assert_se(len > size); + ASSERT_GT(len, sizeof(DHCPPacket)); - discover = memdup(packet, len); + _cleanup_free_ DHCPPacket *discover = ASSERT_NOT_NULL(memdup(packet, len)); - assert_se(discover->ip.ttl == IPDEFTTL); - assert_se(discover->ip.protocol == IPPROTO_UDP); - assert_se(discover->ip.saddr == INADDR_ANY); - assert_se(discover->ip.daddr == INADDR_BROADCAST); - assert_se(discover->udp.source == be16toh(DHCP_PORT_CLIENT)); - assert_se(discover->udp.dest == be16toh(DHCP_PORT_SERVER)); + ASSERT_EQ(discover->ip.ttl, IPDEFTTL); + ASSERT_EQ(discover->ip.protocol, IPPROTO_UDP); + ASSERT_EQ(discover->ip.saddr, INADDR_ANY); + ASSERT_EQ(discover->ip.daddr, INADDR_BROADCAST); + ASSERT_EQ(discover->udp.source, be16toh(DHCP_PORT_CLIENT)); + ASSERT_EQ(discover->udp.dest, be16toh(DHCP_PORT_SERVER)); ip_check = discover->ip.check; @@ -220,23 +182,21 @@ int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link, const discover->ip.check = discover->udp.len; udp_check = ~dhcp_packet_checksum(&discover->ip.ttl, len - 8); - assert_se(udp_check == 0xffff); + ASSERT_EQ(udp_check, 0xffff); discover->ip.ttl = IPDEFTTL; discover->ip.check = ip_check; - ip_check = ~dhcp_packet_checksum((uint8_t*)&discover->ip, sizeof(discover->ip)); - assert_se(ip_check == 0xffff); + ip_check = ~dhcp_packet_checksum((uint8_t*) &discover->ip, sizeof(discover->ip)); + ASSERT_EQ(ip_check, 0xffff); - assert_se(discover->dhcp.xid); - assert_se(memcmp(discover->dhcp.chaddr, hw_addr.bytes, hw_addr.length) == 0); + ASSERT_NE(discover->dhcp.xid, 0u); + ASSERT_EQ(memcmp(discover->dhcp.chaddr, hw_addr.bytes, hw_addr.length), 0); - size = len - sizeof(struct iphdr) - sizeof(struct udphdr); + ASSERT_NOT_NULL(callback_recv); + callback_recv(len - sizeof(struct iphdr) - sizeof(struct udphdr), &discover->dhcp); - assert_se(callback_recv); - callback_recv(size, &discover->dhcp); - - return 575; + return 0; } int dhcp_network_bind_raw_socket( @@ -250,70 +210,47 @@ int dhcp_network_bind_raw_socket( bool so_priority_set, int so_priority) { - if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0) - return -errno; - + ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd)); return test_fd[0]; } int dhcp_network_bind_udp_socket(int ifindex, be32_t address, uint16_t port, int ip_service_type) { - int fd; - - fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0); - if (fd < 0) - return -errno; - - return fd; + return ASSERT_OK_ERRNO(socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0)); } int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port, const void *packet, size_t len) { return 0; } -static int test_discover_message_verify(size_t size, struct DHCPMessage *dhcp) { - int res; - - res = dhcp_option_parse(dhcp, size, check_options, NULL, NULL); - assert_se(res == DHCP_DISCOVER); - - if (verbose) - log_info(" recv DHCP Discover 0x%08x", be32toh(dhcp->xid)); - - return 0; +static void test_discover_message_verify(size_t size, struct DHCPMessage *dhcp) { + ASSERT_OK_EQ(dhcp_option_parse(dhcp, size, check_options, NULL, NULL), DHCP_DISCOVER); + log_debug(" recv DHCP Discover 0x%08x", be32toh(dhcp->xid)); } -static void test_discover_message(sd_event *e) { - sd_dhcp_client *client; - int res, r; +TEST(discover_message) { + _cleanup_(sd_event_unrefp) sd_event *e = NULL; + ASSERT_OK(sd_event_new(&e)); + ASSERT_NOT_NULL(e); - if (verbose) - log_info("* %s", __func__); + _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL; + ASSERT_OK(sd_dhcp_client_new(&client, /* anonymize= */ false)); + ASSERT_NOT_NULL(client); - r = sd_dhcp_client_new(&client, false); - assert_se(r >= 0); - assert_se(client); + ASSERT_OK(sd_dhcp_client_attach_event(client, e, /* priority= */ 0)); - r = sd_dhcp_client_attach_event(client, e, 0); - assert_se(r >= 0); + ASSERT_OK(sd_dhcp_client_set_ifindex(client, 42)); + ASSERT_OK(sd_dhcp_client_set_mac(client, hw_addr.bytes, bcast_addr.bytes, hw_addr.length, ARPHRD_ETHER)); - assert_se(sd_dhcp_client_set_ifindex(client, 42) >= 0); - assert_se(sd_dhcp_client_set_mac(client, hw_addr.bytes, bcast_addr.bytes, hw_addr.length, ARPHRD_ETHER) >= 0); - - assert_se(sd_dhcp_client_set_request_option(client, 248) >= 0); + ASSERT_OK(sd_dhcp_client_set_request_option(client, 248)); callback_recv = test_discover_message_verify; - res = sd_dhcp_client_start(client); - - assert_se(IN_SET(res, 0, -EINPROGRESS)); - - sd_event_run(e, UINT64_MAX); - - sd_dhcp_client_stop(client); - sd_dhcp_client_unref(client); + ASSERT_OK(sd_dhcp_client_start(client)); + ASSERT_OK(sd_event_run(e, /* timeout= */ UINT64_MAX)); + ASSERT_OK(sd_dhcp_client_stop(client)); + ASSERT_NULL(client = sd_dhcp_client_unref(client)); test_fd[1] = safe_close(test_fd[1]); - callback_recv = NULL; } @@ -405,52 +342,41 @@ static uint8_t test_addr_acq_ack[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; -static int test_addr_acq_acquired(sd_dhcp_client *client, int event, - void *userdata) { - sd_event *e = userdata; +static int test_addr_acq_acquired(sd_dhcp_client *client, int event, void *userdata) { + ASSERT_NOT_NULL(client); + ASSERT_TRUE(IN_SET(event, SD_DHCP_CLIENT_EVENT_IP_ACQUIRE, SD_DHCP_CLIENT_EVENT_SELECTING)); + sd_dhcp_lease *lease; + ASSERT_OK(sd_dhcp_client_get_lease(client, &lease)); + ASSERT_NOT_NULL(lease); + struct in_addr addr; + ASSERT_OK(sd_dhcp_lease_get_address(lease, &addr)); + ASSERT_EQ(memcmp(&addr.s_addr, &test_addr_acq_ack[44], sizeof(addr.s_addr)), 0); + + ASSERT_OK(sd_dhcp_lease_get_netmask(lease, &addr)); + ASSERT_EQ(memcmp(&addr.s_addr, &test_addr_acq_ack[285], sizeof(addr.s_addr)), 0); + const struct in_addr *addrs; + ASSERT_OK_EQ(sd_dhcp_lease_get_router(lease, &addrs), 1); + ASSERT_EQ(memcmp(&addrs[0].s_addr, &test_addr_acq_ack[308], sizeof(addrs[0].s_addr)), 0); - assert_se(client); - assert_se(IN_SET(event, SD_DHCP_CLIENT_EVENT_IP_ACQUIRE, SD_DHCP_CLIENT_EVENT_SELECTING)); + log_info(" DHCP address acquired"); - assert_se(sd_dhcp_client_get_lease(client, &lease) >= 0); - assert_se(lease); - - assert_se(sd_dhcp_lease_get_address(lease, &addr) >= 0); - assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[44], - sizeof(addr.s_addr)) == 0); - - assert_se(sd_dhcp_lease_get_netmask(lease, &addr) >= 0); - assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[285], - sizeof(addr.s_addr)) == 0); - - assert_se(sd_dhcp_lease_get_router(lease, &addrs) == 1); - assert_se(memcmp(&addrs[0].s_addr, &test_addr_acq_ack[308], - sizeof(addrs[0].s_addr)) == 0); - - if (verbose) - log_info(" DHCP address acquired"); - - sd_event_exit(e, 0); - - return 0; + sd_event *e = ASSERT_NOT_NULL(sd_dhcp_client_get_event(client)); + return ASSERT_OK(sd_event_exit(e, 0)); } -static int test_addr_acq_recv_request(size_t size, DHCPMessage *request) { +static void test_addr_acq_recv_request(size_t size, DHCPMessage *request) { uint16_t udp_check = 0; uint8_t *msg_bytes = (uint8_t *)request; - int res; - res = dhcp_option_parse(request, size, check_options, NULL, NULL); - assert_se(res == DHCP_REQUEST); - assert_se(xid == request->xid); + ASSERT_OK_EQ(dhcp_option_parse(request, size, check_options, NULL, NULL), DHCP_REQUEST); + ASSERT_EQ(request->xid, xid); - assert_se(msg_bytes[size - 1] == SD_DHCP_OPTION_END); + ASSERT_EQ(msg_bytes[size - 1], SD_DHCP_OPTION_END); - if (verbose) - log_info(" recv DHCP Request 0x%08x", be32toh(xid)); + log_info(" recv DHCP Request 0x%08x", be32toh(xid)); memcpy(&test_addr_acq_ack[26], &udp_check, sizeof(udp_check)); memcpy(&test_addr_acq_ack[32], &xid, sizeof(xid)); @@ -458,30 +384,23 @@ static int test_addr_acq_recv_request(size_t size, DHCPMessage *request) { callback_recv = NULL; - res = write(test_fd[1], test_addr_acq_ack, - sizeof(test_addr_acq_ack)); - assert_se(res == sizeof(test_addr_acq_ack)); + ASSERT_OK_EQ_ERRNO(write(test_fd[1], test_addr_acq_ack, sizeof(test_addr_acq_ack)), + (ssize_t) sizeof(test_addr_acq_ack)); - if (verbose) - log_info(" send DHCP Ack"); - - return 0; + log_info(" send DHCP Ack"); }; -static int test_addr_acq_recv_discover(size_t size, DHCPMessage *discover) { +static void test_addr_acq_recv_discover(size_t size, DHCPMessage *discover) { uint16_t udp_check = 0; uint8_t *msg_bytes = (uint8_t *)discover; - int res; - res = dhcp_option_parse(discover, size, check_options, NULL, NULL); - assert_se(res == DHCP_DISCOVER); + ASSERT_OK_EQ(dhcp_option_parse(discover, size, check_options, NULL, NULL), DHCP_DISCOVER); - assert_se(msg_bytes[size - 1] == SD_DHCP_OPTION_END); + ASSERT_EQ(msg_bytes[size - 1], SD_DHCP_OPTION_END); xid = discover->xid; - if (verbose) - log_info(" recv DHCP Discover 0x%08x", be32toh(xid)); + log_info(" recv DHCP Discover 0x%08x", be32toh(xid)); memcpy(&test_addr_acq_offer[26], &udp_check, sizeof(udp_check)); memcpy(&test_addr_acq_offer[32], &xid, sizeof(xid)); @@ -489,52 +408,41 @@ static int test_addr_acq_recv_discover(size_t size, DHCPMessage *discover) { callback_recv = test_addr_acq_recv_request; - res = write(test_fd[1], test_addr_acq_offer, - sizeof(test_addr_acq_offer)); - assert_se(res == sizeof(test_addr_acq_offer)); + ASSERT_OK_EQ_ERRNO(write(test_fd[1], test_addr_acq_offer, sizeof(test_addr_acq_offer)), + (ssize_t) sizeof(test_addr_acq_offer)); - if (verbose) - log_info(" sent DHCP Offer"); - - return 0; + log_info(" sent DHCP Offer"); } -static void test_addr_acq(sd_event *e) { - sd_dhcp_client *client; - int res, r; +TEST(addr_acq) { + _cleanup_(sd_event_unrefp) sd_event *e = NULL; + ASSERT_OK(sd_event_new(&e)); + ASSERT_NOT_NULL(e); - if (verbose) - log_info("* %s", __func__); + _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL; + ASSERT_OK(sd_dhcp_client_new(&client, /* anonymize= */ false)); + ASSERT_NOT_NULL(client); - r = sd_dhcp_client_new(&client, false); - assert_se(r >= 0); - assert_se(client); + ASSERT_OK(sd_dhcp_client_attach_event(client, e, /* priority= */ 0)); - r = sd_dhcp_client_attach_event(client, e, 0); - assert_se(r >= 0); + ASSERT_OK(sd_dhcp_client_set_ifindex(client, 42)); + ASSERT_OK(sd_dhcp_client_set_mac(client, hw_addr.bytes, bcast_addr.bytes, hw_addr.length, ARPHRD_ETHER)); - assert_se(sd_dhcp_client_set_ifindex(client, 42) >= 0); - assert_se(sd_dhcp_client_set_mac(client, hw_addr.bytes, bcast_addr.bytes, hw_addr.length, ARPHRD_ETHER) >= 0); - - assert_se(sd_dhcp_client_set_callback(client, test_addr_acq_acquired, e) >= 0); + ASSERT_OK(sd_dhcp_client_set_callback(client, test_addr_acq_acquired, NULL)); callback_recv = test_addr_acq_recv_discover; - assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME, + ASSERT_OK(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME, 30 * USEC_PER_SEC, 0, - NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0); + NULL, INT_TO_PTR(-ETIMEDOUT))); - res = sd_dhcp_client_start(client); - assert_se(IN_SET(res, 0, -EINPROGRESS)); - - assert_se(sd_event_loop(e) >= 0); - - assert_se(sd_dhcp_client_set_callback(client, NULL, NULL) >= 0); - assert_se(sd_dhcp_client_stop(client) >= 0); - sd_dhcp_client_unref(client); + ASSERT_OK(sd_dhcp_client_start(client)); + ASSERT_OK(sd_event_loop(e)); + ASSERT_OK(sd_dhcp_client_set_callback(client, NULL, NULL)); + ASSERT_OK(sd_dhcp_client_stop(client)); + ASSERT_NULL(client = sd_dhcp_client_unref(client)); test_fd[1] = safe_close(test_fd[1]); - callback_recv = NULL; xid = 0; } @@ -641,42 +549,33 @@ static struct bootp_addr_data bootp_addr_data[] = { }, }; -static int test_bootp_acquired(sd_dhcp_client *client, int event, - void *userdata) { - sd_dhcp_lease *lease = NULL; - sd_event *e = userdata; - struct in_addr addr; - +static int test_bootp_acquired(sd_dhcp_client *client, int event, void *userdata) { ASSERT_NOT_NULL(client); - assert_se(IN_SET(event, SD_DHCP_CLIENT_EVENT_IP_ACQUIRE, SD_DHCP_CLIENT_EVENT_SELECTING)); + ASSERT_TRUE(IN_SET(event, SD_DHCP_CLIENT_EVENT_IP_ACQUIRE, SD_DHCP_CLIENT_EVENT_SELECTING)); + sd_dhcp_lease *lease; ASSERT_OK(sd_dhcp_client_get_lease(client, &lease)); ASSERT_NOT_NULL(lease); + struct in_addr addr; ASSERT_OK(sd_dhcp_lease_get_address(lease, &addr)); - ASSERT_EQ(memcmp(&addr.s_addr, &bootp_test_context->offer_buf[bootp_test_context->ip_offset], - sizeof(addr.s_addr)), 0); + ASSERT_EQ(memcmp(&addr.s_addr, &bootp_test_context->offer_buf[bootp_test_context->ip_offset], sizeof(addr.s_addr)), 0); ASSERT_OK(sd_dhcp_lease_get_netmask(lease, &addr)); - ASSERT_EQ(memcmp(&addr.s_addr, &bootp_test_context->offer_buf[bootp_test_context->netmask_offset], - sizeof(addr.s_addr)), 0); + ASSERT_EQ(memcmp(&addr.s_addr, &bootp_test_context->offer_buf[bootp_test_context->netmask_offset], sizeof(addr.s_addr)), 0); - if (verbose) - log_info(" BOOTP address acquired"); + log_info(" BOOTP address acquired"); - sd_event_exit(e, 0); - - return 0; + sd_event *e = ASSERT_NOT_NULL(sd_dhcp_client_get_event(client)); + return ASSERT_OK(sd_event_exit(e, 0)); } -static int test_bootp_recv_request(size_t size, DHCPMessage *request) { +static void test_bootp_recv_request(size_t size, DHCPMessage *request) { uint16_t udp_check = 0; - size_t res; xid = request->xid; - if (verbose) - log_info(" recv BOOTP Request 0x%08x", be32toh(xid)); + log_info(" recv BOOTP Request 0x%08x", be32toh(xid)); callback_recv = NULL; @@ -684,34 +583,29 @@ static int test_bootp_recv_request(size_t size, DHCPMessage *request) { memcpy(&bootp_test_context->offer_buf[32], &xid, sizeof(xid)); memcpy(&bootp_test_context->offer_buf[56], hw_addr.bytes, hw_addr.length); - res = write(test_fd[1], bootp_test_context->offer_buf, - bootp_test_context->offer_len); - ASSERT_EQ(res, bootp_test_context->offer_len); + ASSERT_OK_EQ_ERRNO(write(test_fd[1], bootp_test_context->offer_buf, bootp_test_context->offer_len), + (ssize_t) bootp_test_context->offer_len); - if (verbose) - log_info(" sent BOOTP Reply"); - - return 0; + log_info(" sent BOOTP Reply"); }; -static void test_acquire_bootp(sd_event *e) { - sd_dhcp_client *client = NULL; - int res; +static void test_bootp_one(void) { + _cleanup_(sd_event_unrefp) sd_event *e = NULL; + ASSERT_OK(sd_event_new(&e)); + ASSERT_NOT_NULL(e); - if (verbose) - log_info("* %s", __func__); - - ASSERT_OK(sd_dhcp_client_new(&client, false)); + _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL; + ASSERT_OK(sd_dhcp_client_new(&client, /* anonymize= */ false)); ASSERT_NOT_NULL(client); - ASSERT_OK(sd_dhcp_client_attach_event(client, e, 0)); + ASSERT_OK(sd_dhcp_client_attach_event(client, e, /* priority= */ 0)); ASSERT_OK(sd_dhcp_client_set_bootp(client, true)); ASSERT_OK(sd_dhcp_client_set_ifindex(client, 42)); ASSERT_OK(sd_dhcp_client_set_mac(client, hw_addr.bytes, bcast_addr.bytes, hw_addr.length, ARPHRD_ETHER)); - ASSERT_OK(sd_dhcp_client_set_callback(client, test_bootp_acquired, e)); + ASSERT_OK(sd_dhcp_client_set_callback(client, test_bootp_acquired, NULL)); callback_recv = test_bootp_recv_request; @@ -719,53 +613,27 @@ static void test_acquire_bootp(sd_event *e) { 30 * USEC_PER_SEC, 0, NULL, INT_TO_PTR(-ETIMEDOUT))); - res = sd_dhcp_client_start(client); - assert_se(IN_SET(res, 0, -EINPROGRESS)); - + ASSERT_OK(sd_dhcp_client_start(client)); ASSERT_OK(sd_event_loop(e)); - ASSERT_OK(sd_dhcp_client_set_callback(client, NULL, NULL)); ASSERT_OK(sd_dhcp_client_stop(client)); - client = sd_dhcp_client_unref(client); - ASSERT_NULL(client); + ASSERT_NULL(client = sd_dhcp_client_unref(client)); test_fd[1] = safe_close(test_fd[1]); - callback_recv = NULL; xid = 0; } -int main(int argc, char *argv[]) { - _cleanup_(sd_event_unrefp) sd_event *e; - - assert_se(setenv("SYSTEMD_NETWORK_TEST_MODE", "1", 1) >= 0); - - test_setup_logging(LOG_DEBUG); - - assert_se(sd_event_new(&e) >= 0); - - test_request_basic(e); - test_request_anonymize(e); - test_checksum(); - test_dhcp_identifier_set_iaid(); - - test_discover_message(e); - test_addr_acq(e); - +TEST(bootp) { FOREACH_ELEMENT(i, bootp_addr_data) { - sd_event_unref(e); - ASSERT_OK(sd_event_new(&e)); bootp_test_context = i; - test_acquire_bootp(e); + test_bootp_one(); } +} -#if HAVE_VALGRIND_VALGRIND_H - /* Make sure the async_close thread has finished. - * valgrind would report some of the phread_* structures - * as not cleaned up properly. */ - if (RUNNING_ON_VALGRIND) - sleep(1); -#endif - +static int intro(void) { + ASSERT_OK_ERRNO(setenv("SYSTEMD_NETWORK_TEST_MODE", "1", /* overwrite= */ true)); return 0; } + +DEFINE_TEST_MAIN_WITH_INTRO(LOG_DEBUG, intro); From bd1d1e61eb680b05e5aa75202a17f96b9367afe5 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Fri, 13 Mar 2026 08:11:18 +0900 Subject: [PATCH 3/9] fuzz-dhcp-client: modernize test code --- src/libsystemd-network/fuzz-dhcp-client.c | 72 ++++++++--------------- 1 file changed, 26 insertions(+), 46 deletions(-) diff --git a/src/libsystemd-network/fuzz-dhcp-client.c b/src/libsystemd-network/fuzz-dhcp-client.c index 23471f89fc..7a59faff63 100644 --- a/src/libsystemd-network/fuzz-dhcp-client.c +++ b/src/libsystemd-network/fuzz-dhcp-client.c @@ -6,6 +6,7 @@ #include "fuzz.h" #include "network-internal.h" #include "sd-dhcp-client.c" +#include "tests.h" #include "tmpfile-util.h" int dhcp_network_bind_raw_socket( @@ -19,77 +20,56 @@ int dhcp_network_bind_raw_socket( bool so_priority_set, int so_priority) { - int fd; - fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0); - if (fd < 0) - return -errno; - - return fd; + return ASSERT_OK_ERRNO(socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0)); } int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link, const void *packet, size_t len) { - return len; + return 0; } int dhcp_network_bind_udp_socket(int ifindex, be32_t address, uint16_t port, int ip_service_type) { - int fd; - - fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0); - if (fd < 0) - return -errno; - - return fd; + return ASSERT_OK_ERRNO(socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0)); } int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port, const void *packet, size_t len) { - return len; + return 0; } int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - uint8_t mac_addr[] = {'A', 'B', 'C', '1', '2', '3'}; - uint8_t bcast_addr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; - _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL; - _cleanup_(sd_event_unrefp) sd_event *e = NULL; - _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL; - _cleanup_(unlink_tempfilep) char lease_file[] = "/tmp/fuzz-dhcp-client.XXXXXX"; - _cleanup_close_ int fd = -1; - int res, r; + static const uint8_t mac_addr[] = {'A', 'B', 'C', '1', '2', '3'}; + static const uint8_t bcast_addr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; - assert_se(setenv("SYSTEMD_NETWORK_TEST_MODE", "1", 1) >= 0); + ASSERT_OK_ERRNO(setenv("SYSTEMD_NETWORK_TEST_MODE", "1", /* overwrite= */ true)); fuzz_setup_logging(); - r = sd_dhcp_client_new(&client, false); - assert_se(r >= 0); - assert_se(client); + _cleanup_(sd_event_unrefp) sd_event *e = NULL; + ASSERT_OK(sd_event_new(&e)); + ASSERT_NOT_NULL(e); - assert_se(sd_event_new(&e) >= 0); + _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL; + ASSERT_OK(sd_dhcp_client_new(&client, /* anonymize= */ false)); + ASSERT_NOT_NULL(client); - r = sd_dhcp_client_attach_event(client, e, 0); - assert_se(r >= 0); + ASSERT_OK(sd_dhcp_client_attach_event(client, e, /* priority= */ 0)); - assert_se(sd_dhcp_client_set_ifindex(client, 42) >= 0); - assert_se(sd_dhcp_client_set_mac(client, mac_addr, bcast_addr, ETH_ALEN, ARPHRD_ETHER) >= 0); + ASSERT_OK(sd_dhcp_client_set_ifindex(client, 42)); + ASSERT_OK(sd_dhcp_client_set_mac(client, mac_addr, bcast_addr, ETH_ALEN, ARPHRD_ETHER)); - res = sd_dhcp_client_start(client); - assert_se(IN_SET(res, 0, -EINPROGRESS)); + ASSERT_OK(sd_dhcp_client_start(client)); client->xid = 2; client->state = DHCP_STATE_SELECTING; - if (client_handle_offer_or_rapid_ack(client, (DHCPMessage*) data, size, NULL) < 0) - goto end; + if (client_handle_offer_or_rapid_ack(client, (DHCPMessage*) data, size, NULL) >= 0) { + _cleanup_(unlink_tempfilep) char lease_file[] = "/tmp/fuzz-dhcp-client.XXXXXX"; + _unused_ _cleanup_close_ int fd = ASSERT_OK(mkostemp_safe(lease_file)); - fd = mkostemp_safe(lease_file); - assert_se(fd >= 0); + ASSERT_OK(dhcp_lease_save(client->lease, lease_file)); - r = dhcp_lease_save(client->lease, lease_file); - assert_se(r >= 0); - - r = dhcp_lease_load(&lease, lease_file); - assert_se(r >= 0); - -end: - assert_se(sd_dhcp_client_stop(client) >= 0); + _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL; + ASSERT_OK(dhcp_lease_load(&lease, lease_file)); + } + ASSERT_OK(sd_dhcp_client_stop(client)); return 0; } From ced607506d3ef365f3eadb9fad0125e66a5fdd22 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Fri, 13 Mar 2026 05:31:45 +0900 Subject: [PATCH 4/9] sd-dhcp-client: coding style fix --- src/libsystemd-network/sd-dhcp-client.c | 4 ++-- src/systemd/sd-dhcp-client.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index 4b1cdd0b86..bb9ea35943 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -2524,7 +2524,7 @@ int sd_dhcp_client_detach_event(sd_dhcp_client *client) { return 0; } -sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client) { +sd_event* sd_dhcp_client_get_event(sd_dhcp_client *client) { assert_return(client, NULL); return client->event; @@ -2536,7 +2536,7 @@ int sd_dhcp_client_attach_device(sd_dhcp_client *client, sd_device *dev) { return device_unref_and_replace(client->dev, dev); } -static sd_dhcp_client *dhcp_client_free(sd_dhcp_client *client) { +static sd_dhcp_client* dhcp_client_free(sd_dhcp_client *client) { if (!client) return NULL; diff --git a/src/systemd/sd-dhcp-client.h b/src/systemd/sd-dhcp-client.h index b2995a961f..033d5ad894 100644 --- a/src/systemd/sd-dhcp-client.h +++ b/src/systemd/sd-dhcp-client.h @@ -172,7 +172,7 @@ int sd_dhcp_client_attach_event( sd_event *event, int64_t priority); int sd_dhcp_client_detach_event(sd_dhcp_client *client); -sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client); +sd_event* sd_dhcp_client_get_event(sd_dhcp_client *client); int sd_dhcp_client_attach_device(sd_dhcp_client *client, sd_device *dev); _SD_DEFINE_POINTER_CLEANUP_FUNC(sd_dhcp_client, sd_dhcp_client_unref); From 0c68816c5648ab42c2ced1682c487c51d1865d56 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sat, 14 Mar 2026 01:31:41 +0900 Subject: [PATCH 5/9] sd-dhcp-client: add missing assertion --- src/libsystemd-network/sd-dhcp-client.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index bb9ea35943..d126aa9e83 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -1490,6 +1490,8 @@ static int client_start_delayed(sd_dhcp_client *client) { } static int client_start(sd_dhcp_client *client) { + assert(client); + client->start_delay = 0; return client_start_delayed(client); } From ddded65d41f691afc4d248343d987775655bcfb7 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Fri, 13 Mar 2026 05:19:06 +0900 Subject: [PATCH 6/9] sd-dhcp-client: add missing error checks --- src/libsystemd-network/sd-dhcp-client.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index d126aa9e83..55c7c741b5 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -1386,8 +1386,9 @@ error: the client reverts to INIT state and restarts the initialization process */ if (client->request_attempt >= client->max_request_attempts) { log_dhcp_client(client, "Max REQUEST attempts reached. Restarting..."); - client_restart(client); - return 0; + r = client_restart(client); + if (r >= 0) + return 0; } client_stop(client, r); @@ -1499,6 +1500,7 @@ static int client_start(sd_dhcp_client *client) { static int client_timeout_expire(sd_event_source *s, uint64_t usec, void *userdata) { sd_dhcp_client *client = userdata; DHCP_CLIENT_DONT_DESTROY(client); + int r; log_dhcp_client(client, "EXPIRED"); @@ -1507,7 +1509,12 @@ static int client_timeout_expire(sd_event_source *s, uint64_t usec, void *userda /* lease was lost, start over if not freed or stopped in callback */ if (client->state != DHCP_STATE_STOPPED) { client_initialize(client); - client_start(client); + + r = client_start(client); + if (r < 0) { + client_stop(client, r); + return 0; + } } return 0; From 2fb192d237f91b8f2f9bb42adc7a3ad010641876 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Wed, 11 Mar 2026 08:50:24 +0900 Subject: [PATCH 7/9] sd-dhcp-client: drop disabled FORCERENEW message support FORCERENEW message support has been disabled so long time for security concern. Most other implementations of DHCP server/client neither support FORCERENEW. Let's completely drop relevant code. --- src/libsystemd-network/sd-dhcp-client.c | 33 +++---------------------- 1 file changed, 3 insertions(+), 30 deletions(-) diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index 55c7c741b5..903add49fd 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -1802,25 +1802,6 @@ static int client_enter_requesting(sd_dhcp_client *client) { return client_enter_requesting_now(client); } -static int client_handle_forcerenew(sd_dhcp_client *client, DHCPMessage *force, size_t len) { - int r; - - r = dhcp_option_parse(force, len, NULL, NULL, NULL); - if (r != DHCP_FORCERENEW) - return -ENOMSG; - -#if 0 - log_dhcp_client(client, "FORCERENEW"); - return 0; -#else - /* FIXME: Ignore FORCERENEW requests until we implement RFC3118 (Authentication for DHCP - * Messages) and/or RFC6704 (Forcerenew Nonce Authentication), as unauthenticated FORCERENEW - * requests causes a security issue (TALOS-2020-1142, CVE-2020-13529). */ - return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(ENOMSG), - "Received FORCERENEW, ignoring."); -#endif -} - static bool lease_equal(const sd_dhcp_lease *a, const sd_dhcp_lease *b) { if (a->address != b->address) return false; @@ -2113,10 +2094,7 @@ static int client_verify_message_header(sd_dhcp_client *client, DHCPMessage *mes return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG), "Received chaddr does not match expected, ignoring."); - if (client->state != DHCP_STATE_BOUND && - be32toh(message->xid) != client->xid) - /* in BOUND state, we may receive FORCERENEW with xid set by server, - so ignore the xid in this case */ + if (be32toh(message->xid) != client->xid) return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EBADMSG), "Received xid (%u) does not match expected (%u), ignoring.", be32toh(message->xid), client->xid); @@ -2170,13 +2148,8 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, s return client_enter_bound(client, r); case DHCP_STATE_BOUND: - r = client_handle_forcerenew(client, message, len); - if (ERRNO_IS_NEG_RESOURCE(r)) - return r; - if (r < 0) - return 0; /* invalid message, let's ignore it */ - - return client_timeout_t1(NULL, 0, client); + log_dhcp_client(client, "Unexpected DHCP message received in BOUND state, ignoring."); + return 0; case DHCP_STATE_INIT: case DHCP_STATE_INIT_REBOOT: From ad4d2ae619dc16abc708c8aeb54148973712a46e Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Fri, 13 Mar 2026 05:16:16 +0900 Subject: [PATCH 8/9] sd-dhcp-client: voidify client_initialize() It never fails. --- src/libsystemd-network/sd-dhcp-client.c | 18 +++++------------- 1 file changed, 5 insertions(+), 13 deletions(-) diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index 903add49fd..683ee3d509 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -702,8 +702,8 @@ static int client_notify(sd_dhcp_client *client, int event) { return 0; } -static int client_initialize(sd_dhcp_client *client) { - assert_return(client, -EINVAL); +static void client_initialize(sd_dhcp_client *client) { + assert(client); client->receive_message = sd_event_source_disable_unref(client->receive_message); @@ -722,8 +722,6 @@ static int client_initialize(sd_dhcp_client *client) { client->xid = 0; client->lease = sd_dhcp_lease_unref(client->lease); - - return 0; } static void client_stop(sd_dhcp_client *client, int error) { @@ -1286,9 +1284,7 @@ static int client_timeout_resend( case DHCP_STATE_REBOOTING: /* start over as we did not receive a timely ack or nak */ - r = client_initialize(client); - if (r < 0) - goto error; + client_initialize(client); r = client_start(client); if (r < 0) @@ -2042,9 +2038,7 @@ static int client_restart(sd_dhcp_client *client) { client_notify(client, SD_DHCP_CLIENT_EVENT_EXPIRED); - r = client_initialize(client); - if (r < 0) - return r; + client_initialize(client); r = client_start_delayed(client); if (r < 0) @@ -2307,9 +2301,7 @@ int sd_dhcp_client_start(sd_dhcp_client *client) { /* Note, do not reset the flag in client_initialize(), as it is also called on expire. */ client->ipv6_acquired = false; - r = client_initialize(client); - if (r < 0) - return r; + client_initialize(client); /* If no client identifier exists, construct an RFC 4361-compliant one */ if (!sd_dhcp_client_id_is_set(&client->client_id)) { From 26f769bea390eb06bef0d709beb47a5a75f9ff3f Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sat, 14 Mar 2026 21:59:42 +0900 Subject: [PATCH 9/9] sd-dhcp-client: propagate errors in client_initialize_{io,time}_events() Call client_stop() on error and return 0 only on callback. Normal non-callback functions should propagate errors. This also makes client_initialize_time_events() use event_reset_time_relative(). --- src/libsystemd-network/sd-dhcp-client.c | 84 +++++++++++++------------ 1 file changed, 45 insertions(+), 39 deletions(-) diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index 683ee3d509..9dcd9859a3 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -1401,59 +1401,56 @@ static int client_initialize_io_events( assert(client); assert(client->event); + assert(io_callback); - r = sd_event_add_io(client->event, &client->receive_message, - client->fd, EPOLLIN, io_callback, - client); + _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL; + r = sd_event_add_io(client->event, &s, client->fd, EPOLLIN, io_callback, client); if (r < 0) - goto error; + return r; - r = sd_event_source_set_priority(client->receive_message, - client->event_priority); + r = sd_event_source_set_priority(s, client->event_priority); if (r < 0) - goto error; + return r; - r = sd_event_source_set_description(client->receive_message, "dhcp4-receive-message"); + r = sd_event_source_set_description(s, "dhcp4-receive-message"); if (r < 0) - goto error; - -error: - if (r < 0) - client_stop(client, r); + return r; + sd_event_source_disable_unref(client->receive_message); + client->receive_message = TAKE_PTR(s); return 0; } static int client_initialize_time_events(sd_dhcp_client *client) { - usec_t usec = 0; - int r; - assert(client); assert(client->event); (void) event_source_disable(client->timeout_ipv6_only_mode); - if (client->start_delay > 0) { - assert_se(sd_event_now(client->event, CLOCK_BOOTTIME, &usec) >= 0); - usec = usec_add(usec, client->start_delay); - } - - r = event_reset_time(client->event, &client->timeout_resend, - CLOCK_BOOTTIME, - usec, 0, - client_timeout_resend, client, - client->event_priority, "dhcp4-resend-timer", true); - if (r < 0) - client_stop(client, r); - - return 0; + return event_reset_time_relative( + client->event, + &client->timeout_resend, + CLOCK_BOOTTIME, + client->start_delay, + /* accuracy= */ 0, + client_timeout_resend, + client, + client->event_priority, + "dhcp4-resend-timer", + /* force_reset= */ true); } static int client_initialize_events(sd_dhcp_client *client, sd_event_io_handler_t io_callback) { - client_initialize_io_events(client, io_callback); - client_initialize_time_events(client); + int r; - return 0; + assert(client); + assert(io_callback); + + r = client_initialize_io_events(client, io_callback); + if (r < 0) + return r; + + return client_initialize_time_events(client); } static int client_start_delayed(sd_dhcp_client *client) { @@ -1472,10 +1469,8 @@ static int client_start_delayed(sd_dhcp_client *client) { &client->hw_addr, &client->bcast_addr, client->arp_type, client->port, client->socket_priority_set, client->socket_priority); - if (r < 0) { - client_stop(client, r); + if (r < 0) return r; - } client->fd = r; client->start_time = now(CLOCK_BOOTTIME); @@ -1538,12 +1533,17 @@ static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) } client->fd = r; - return client_initialize_events(client, client_receive_message_raw); + r = client_initialize_events(client, client_receive_message_raw); + if (r < 0) + client_stop(client, r); + + return 0; } static int client_timeout_t1(sd_event_source *s, uint64_t usec, void *userdata) { sd_dhcp_client *client = userdata; DHCP_CLIENT_DONT_DESTROY(client); + int r; if (client->lease) client_set_state(client, DHCP_STATE_RENEWING); @@ -1552,7 +1552,11 @@ static int client_timeout_t1(sd_event_source *s, uint64_t usec, void *userdata) client->discover_attempt = 0; client->request_attempt = 0; - return client_initialize_time_events(client); + r = client_initialize_time_events(client); + if (r < 0) + client_stop(client, r); + + return 0; } static int dhcp_option_parse_and_verify( @@ -1976,7 +1980,9 @@ static int client_enter_bound_now(sd_dhcp_client *client, int notify_event) { client->receive_message = sd_event_source_disable_unref(client->receive_message); close_and_replace(client->fd, r); - client_initialize_io_events(client, client_receive_message_udp); + r = client_initialize_io_events(client, client_receive_message_udp); + if (r < 0) + return r; } client_notify(client, notify_event);