SymbX/systemd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sd-dhcp-client: several trivial cleanups (#41256)

Browse Source
This commit is contained in:
Daan De Meyer
2026-03-22 20:00:33 +01:00
committed by GitHub
parent 55f2fdd508 26f769bea3
commit 9d844012bc
4 changed files with 269 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libsystemd-network/fuzz-dhcp-client.c
+26 -46
View File
@@ -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;
}
src/libsystemd-network/sd-dhcp-client.c
+67 -87
View File
@@ -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) {
@@ -1285,9 +1283,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)
@@ -1385,8 +1381,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);
@@ -1403,59 +1400,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) {
@@ -1474,10 +1468,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);
@@ -1489,6 +1481,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);
}
@@ -1496,6 +1490,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");
@@ -1504,7 +1499,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;
@@ -1532,12 +1532,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);
@@ -1546,7 +1551,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(
@@ -1792,25 +1801,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;
@@ -1989,7 +1979,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);
@@ -2051,9 +2043,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)
@@ -2103,10 +2093,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);
@@ -2160,13 +2147,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:
@@ -2324,9 +2306,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)) {
@@ -2523,7 +2503,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;
@@ -2535,7 +2515,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;
src/libsystemd-network/test-dhcp-client.c
+175 -307
View File
@@ -8,9 +8,6 @@
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#if HAVE_VALGRIND_VALGRIND_H
# include <valgrind/valgrind.h>
#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,59 +408,48 @@ 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;
}
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,
@@ -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);
src/systemd/sd-dhcp-client.h
+1 -1
View File
@@ -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);