src/libsystemd-network/test-dhcp-client.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 /***
   3   Copyright © 2013 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include <errno.h>
   7 #include <net/if.h>
   8 #include <net/if_arp.h>
   9 #include <stdio.h>
  10 #include <sys/socket.h>
  11 #include <unistd.h>
  12
  13 #include "sd-dhcp-client.h"
  14 #include "sd-event.h"
  15
  16 #include "alloc-util.h"
  17 #include "dhcp-identifier.h"
  18 #include "dhcp-internal.h"
  19 #include "dhcp-protocol.h"
  20 #include "fd-util.h"
  21 #include "random-util.h"
  22 #include "tests.h"
  23 #include "util.h"
  24
  25 static uint8_t mac_addr[] = {'A', 'B', 'C', '1', '2', '3'};
  26 static uint8_t bcast_addr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  27
  28 typedef int (*test_callback_recv_t)(size_t size, DHCPMessage *dhcp);
  29
  30 static bool verbose = true;
  31 static int test_fd[2];
  32 static test_callback_recv_t callback_recv;
  33 static be32_t xid;
  34 static sd_event_source *test_hangcheck;
  35
  36 static int test_dhcp_hangcheck(sd_event_source *s, uint64_t usec, void *userdata) {
  37         assert_not_reached();
  38
  39         return 0;
  40 }
  41
  42 static void test_request_basic(sd_event *e) {
  43         int r;
  44
  45         sd_dhcp_client *client;
  46
  47         if (verbose)
  48                 printf("* %s\n", __func__);
  49
  50         /* Initialize client without Anonymize settings. */
  51         r = sd_dhcp_client_new(&client, false);
  52
  53         assert_se(r >= 0);
  54         assert_se(client);
  55
  56         r = sd_dhcp_client_attach_event(client, e, 0);
  57         assert_se(r >= 0);
  58
  59         assert_se(sd_dhcp_client_set_request_option(NULL, 0) == -EINVAL);
  60         assert_se(sd_dhcp_client_set_request_address(NULL, NULL) == -EINVAL);
  61         assert_se(sd_dhcp_client_set_ifindex(NULL, 0) == -EINVAL);
  62
  63         assert_se(sd_dhcp_client_set_ifindex(client, 15) == 0);
  64         assert_se(sd_dhcp_client_set_ifindex(client, -42) == -EINVAL);
  65         assert_se(sd_dhcp_client_set_ifindex(client, -1) == -EINVAL);
  66         assert_se(sd_dhcp_client_set_ifindex(client, 0) == -EINVAL);
  67         assert_se(sd_dhcp_client_set_ifindex(client, 1) == 0);
  68
  69         assert_se(sd_dhcp_client_set_hostname(client, "host") == 1);
  70         assert_se(sd_dhcp_client_set_hostname(client, "host.domain") == 1);
  71         assert_se(sd_dhcp_client_set_hostname(client, NULL) == 1);
  72         assert_se(sd_dhcp_client_set_hostname(client, "~host") == -EINVAL);
  73         assert_se(sd_dhcp_client_set_hostname(client, "~host.domain") == -EINVAL);
  74
  75         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_SUBNET_MASK) == 0);
  76         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_ROUTER) == 0);
  77         /* This PRL option is not set when using Anonymize, but in this test
  78          * Anonymize settings are not being used. */
  79         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_HOST_NAME) == 0);
  80         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_DOMAIN_NAME) == 0);
  81         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_DOMAIN_NAME_SERVER) == 0);
  82
  83         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PAD) == -EINVAL);
  84         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_END) == -EINVAL);
  85         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_MESSAGE_TYPE) == -EINVAL);
  86         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_OVERLOAD) == -EINVAL);
  87         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST) == -EINVAL);
  88
  89         /* RFC7844: option 33 (SD_DHCP_OPTION_STATIC_ROUTE) is set in the
  90          * default PRL when using Anonymize, so it is changed to other option
  91          * that is not set by default, to check that it was set successfully.
  92          * Options not set by default (using or not anonymize) are option 17
  93          * (SD_DHCP_OPTION_ROOT_PATH) and 42 (SD_DHCP_OPTION_NTP_SERVER) */
  94         assert_se(sd_dhcp_client_set_request_option(client, 17) == 1);
  95         assert_se(sd_dhcp_client_set_request_option(client, 17) == 0);
  96         assert_se(sd_dhcp_client_set_request_option(client, 42) == 1);
  97         assert_se(sd_dhcp_client_set_request_option(client, 17) == 0);
  98
  99         sd_dhcp_client_unref(client);
 100 }
 101
 102 static void test_request_anonymize(sd_event *e) {
 103         int r;
 104
 105         sd_dhcp_client *client;
 106
 107         if (verbose)
 108                 printf("* %s\n", __func__);
 109
 110         /* Initialize client with Anonymize settings. */
 111         r = sd_dhcp_client_new(&client, true);
 112
 113         assert_se(r >= 0);
 114         assert_se(client);
 115
 116         r = sd_dhcp_client_attach_event(client, e, 0);
 117         assert_se(r >= 0);
 118
 119         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_NETBIOS_NAMESERVER) == 0);
 120         /* This PRL option is not set when using Anonymize */
 121         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_HOST_NAME) == 1);
 122         assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST) == -EINVAL);
 123
 124         /* RFC7844: option 101 (SD_DHCP_OPTION_NEW_TZDB_TIMEZONE) is not set in the
 125          * default PRL when using Anonymize, */
 126         assert_se(sd_dhcp_client_set_request_option(client, 101) == 1);
 127         assert_se(sd_dhcp_client_set_request_option(client, 101) == 0);
 128
 129         sd_dhcp_client_unref(client);
 130 }
 131
 132 static void test_checksum(void) {
 133         uint8_t buf[20] = {
 134                 0x45, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00,
 135                 0x40, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 136                 0xff, 0xff, 0xff, 0xff
 137         };
 138
 139         if (verbose)
 140                 printf("* %s\n", __func__);
 141
 142         assert_se(dhcp_packet_checksum((uint8_t*)&buf, 20) == be16toh(0x78ae));
 143 }
 144
 145 static void test_dhcp_identifier_set_iaid(void) {
 146         uint32_t iaid_legacy;
 147         be32_t iaid;
 148
 149         assert_se(dhcp_identifier_set_iaid(42, mac_addr, sizeof(mac_addr), /* legacy = */ true,
 150                                            /* use_mac = */ true, &iaid_legacy) >= 0);
 151         assert_se(dhcp_identifier_set_iaid(42, mac_addr, sizeof(mac_addr), /* legacy = */ false,
 152                                            /* use_mac = */ true, &iaid) >= 0);
 153
 154         /* we expect, that the MAC address was hashed. The legacy value is in native
 155          * endianness. */
 156         assert_se(iaid_legacy == 0x8dde4ba8u);
 157         assert_se(iaid  == htole32(0x8dde4ba8u));
 158 #if __BYTE_ORDER == __LITTLE_ENDIAN
 159         assert_se(iaid == iaid_legacy);
 160 #else
 161         assert_se(iaid == bswap_32(iaid_legacy));
 162 #endif
 163 }
 164
 165 static int check_options(uint8_t code, uint8_t len, const void *option, void *userdata) {
 166         switch(code) {
 167         case SD_DHCP_OPTION_CLIENT_IDENTIFIER:
 168         {
 169                 uint32_t iaid;
 170                 struct duid duid;
 171                 size_t duid_len;
 172
 173                 assert_se(dhcp_identifier_set_duid_en(/* test_mode = */ true, &duid, &duid_len) >= 0);
 174                 assert_se(dhcp_identifier_set_iaid(42, mac_addr, ETH_ALEN, true, /* use_mac = */ true, &iaid) >= 0);
 175
 176                 assert_se(len == sizeof(uint8_t) + sizeof(uint32_t) + duid_len);
 177                 assert_se(len == 19);
 178                 assert_se(((uint8_t*) option)[0] == 0xff);
 179
 180                 assert_se(memcmp((uint8_t*) option + 1, &iaid, sizeof(iaid)) == 0);
 181                 assert_se(memcmp((uint8_t*) option + 5, &duid, duid_len) == 0);
 182                 break;
 183         }
 184
 185         default:
 186                 break;
 187         }
 188
 189         return 0;
 190 }
 191
 192 int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link, const void *packet, size_t len) {
 193         size_t size;
 194         _cleanup_free_ DHCPPacket *discover;
 195         uint16_t ip_check, udp_check;
 196
 197         assert_se(s >= 0);
 198         assert_se(packet);
 199
 200         size = sizeof(DHCPPacket);
 201         assert_se(len > size);
 202
 203         discover = memdup(packet, len);
 204
 205         assert_se(discover->ip.ttl == IPDEFTTL);
 206         assert_se(discover->ip.protocol == IPPROTO_UDP);
 207         assert_se(discover->ip.saddr == INADDR_ANY);
 208         assert_se(discover->ip.daddr == INADDR_BROADCAST);
 209         assert_se(discover->udp.source == be16toh(DHCP_PORT_CLIENT));
 210         assert_se(discover->udp.dest == be16toh(DHCP_PORT_SERVER));
 211
 212         ip_check = discover->ip.check;
 213
 214         discover->ip.ttl = 0;
 215         discover->ip.check = discover->udp.len;
 216
 217         udp_check = ~dhcp_packet_checksum((uint8_t*)&discover->ip.ttl, len - 8);
 218         assert_se(udp_check == 0xffff);
 219
 220         discover->ip.ttl = IPDEFTTL;
 221         discover->ip.check = ip_check;
 222
 223         ip_check = ~dhcp_packet_checksum((uint8_t*)&discover->ip, sizeof(discover->ip));
 224         assert_se(ip_check == 0xffff);
 225
 226         assert_se(discover->dhcp.xid);
 227         assert_se(memcmp(discover->dhcp.chaddr, &mac_addr, ETH_ALEN) == 0);
 228
 229         size = len - sizeof(struct iphdr) - sizeof(struct udphdr);
 230
 231         assert_se(callback_recv);
 232         callback_recv(size, &discover->dhcp);
 233
 234         return 575;
 235 }
 236
 237 int dhcp_network_bind_raw_socket(
 238                 int ifindex,
 239                 union sockaddr_union *link,
 240                 uint32_t id,
 241                 const uint8_t *addr, size_t addr_len,
 242                 const uint8_t *bcaddr, size_t bcaddr_len,
 243                 uint16_t arp_type, uint16_t port) {
 244
 245         if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
 246                 return -errno;
 247
 248         return test_fd[0];
 249 }
 250
 251 int dhcp_network_bind_udp_socket(int ifindex, be32_t address, uint16_t port, int ip_service_type) {
 252         int fd;
 253
 254         fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
 255         if (fd < 0)
 256                 return -errno;
 257
 258         return fd;
 259 }
 260
 261 int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port, const void *packet, size_t len) {
 262         return 0;
 263 }
 264
 265 static int test_discover_message_verify(size_t size, struct DHCPMessage *dhcp) {
 266         int res;
 267
 268         res = dhcp_option_parse(dhcp, size, check_options, NULL, NULL);
 269         assert_se(res == DHCP_DISCOVER);
 270
 271         if (verbose)
 272                 printf("  recv DHCP Discover 0x%08x\n", be32toh(dhcp->xid));
 273
 274         return 0;
 275 }
 276
 277 static void test_discover_message(sd_event *e) {
 278         sd_dhcp_client *client;
 279         int res, r;
 280
 281         if (verbose)
 282                 printf("* %s\n", __func__);
 283
 284         r = sd_dhcp_client_new(&client, false);
 285         assert_se(r >= 0);
 286         assert_se(client);
 287
 288         r = sd_dhcp_client_attach_event(client, e, 0);
 289         assert_se(r >= 0);
 290
 291         assert_se(sd_dhcp_client_set_ifindex(client, 42) >= 0);
 292         assert_se(sd_dhcp_client_set_mac(client, mac_addr, bcast_addr, ETH_ALEN, ARPHRD_ETHER) >= 0);
 293         dhcp_client_set_test_mode(client, true);
 294
 295         assert_se(sd_dhcp_client_set_request_option(client, 248) >= 0);
 296
 297         callback_recv = test_discover_message_verify;
 298
 299         res = sd_dhcp_client_start(client);
 300
 301         assert_se(IN_SET(res, 0, -EINPROGRESS));
 302
 303         sd_event_run(e, UINT64_MAX);
 304
 305         sd_dhcp_client_stop(client);
 306         sd_dhcp_client_unref(client);
 307
 308         test_fd[1] = safe_close(test_fd[1]);
 309
 310         callback_recv = NULL;
 311 }
 312
 313 static uint8_t test_addr_acq_offer[] = {
 314         0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
 315         0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
 316         0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
 317         0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
 318         0x6f, 0x95, 0x2f, 0x30, 0x00, 0x00, 0x00, 0x00,
 319         0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
 320         0xc0, 0xa8, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
 321         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 322         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 323         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 324         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 325         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 326         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 327         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 328         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 329         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 330         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 331         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 332         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 333         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 334         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 335         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 336         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 337         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 338         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 339         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 340         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 341         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 342         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 343         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 344         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 345         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 346         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 347         0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x02, 0x36,
 348         0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
 349         0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
 350         0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
 351         0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
 352         0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
 353         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 354         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 355 };
 356
 357 static uint8_t test_addr_acq_ack[] = {
 358         0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
 359         0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
 360         0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
 361         0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
 362         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
 363         0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
 364         0xc0, 0xa8, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
 365         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 366         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 367         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 368         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 369         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 370         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 371         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 372         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 373         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 374         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 375         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 376         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 377         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 378         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 379         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 380         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 381         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 382         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 383         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 384         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 385         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 386         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 387         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 388         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 389         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 390         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 391         0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x05, 0x36,
 392         0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
 393         0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
 394         0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
 395         0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
 396         0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
 397         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 398         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 399 };
 400
 401 static int test_addr_acq_acquired(sd_dhcp_client *client, int event,
 402                                    void *userdata) {
 403         sd_event *e = userdata;
 404         sd_dhcp_lease *lease;
 405         struct in_addr addr;
 406         const struct in_addr *addrs;
 407
 408         assert_se(client);
 409         assert_se(IN_SET(event, SD_DHCP_CLIENT_EVENT_IP_ACQUIRE, SD_DHCP_CLIENT_EVENT_SELECTING));
 410
 411         assert_se(sd_dhcp_client_get_lease(client, &lease) >= 0);
 412         assert_se(lease);
 413
 414         assert_se(sd_dhcp_lease_get_address(lease, &addr) >= 0);
 415         assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[44],
 416                       sizeof(addr.s_addr)) == 0);
 417
 418         assert_se(sd_dhcp_lease_get_netmask(lease, &addr) >= 0);
 419         assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[285],
 420                       sizeof(addr.s_addr)) == 0);
 421
 422         assert_se(sd_dhcp_lease_get_router(lease, &addrs) == 1);
 423         assert_se(memcmp(&addrs[0].s_addr, &test_addr_acq_ack[308],
 424                          sizeof(addrs[0].s_addr)) == 0);
 425
 426         if (verbose)
 427                 printf("  DHCP address acquired\n");
 428
 429         sd_event_exit(e, 0);
 430
 431         return 0;
 432 }
 433
 434 static int test_addr_acq_recv_request(size_t size, DHCPMessage *request) {
 435         uint16_t udp_check = 0;
 436         uint8_t *msg_bytes = (uint8_t *)request;
 437         int res;
 438
 439         res = dhcp_option_parse(request, size, check_options, NULL, NULL);
 440         assert_se(res == DHCP_REQUEST);
 441         assert_se(xid == request->xid);
 442
 443         assert_se(msg_bytes[size - 1] == SD_DHCP_OPTION_END);
 444
 445         if (verbose)
 446                 printf("  recv DHCP Request  0x%08x\n", be32toh(xid));
 447
 448         memcpy(&test_addr_acq_ack[26], &udp_check, sizeof(udp_check));
 449         memcpy(&test_addr_acq_ack[32], &xid, sizeof(xid));
 450         memcpy(&test_addr_acq_ack[56], &mac_addr, ETHER_ADDR_LEN);
 451
 452         callback_recv = NULL;
 453
 454         res = write(test_fd[1], test_addr_acq_ack,
 455                     sizeof(test_addr_acq_ack));
 456         assert_se(res == sizeof(test_addr_acq_ack));
 457
 458         if (verbose)
 459                 printf("  send DHCP Ack\n");
 460
 461         return 0;
 462 };
 463
 464 static int test_addr_acq_recv_discover(size_t size, DHCPMessage *discover) {
 465         uint16_t udp_check = 0;
 466         uint8_t *msg_bytes = (uint8_t *)discover;
 467         int res;
 468
 469         res = dhcp_option_parse(discover, size, check_options, NULL, NULL);
 470         assert_se(res == DHCP_DISCOVER);
 471
 472         assert_se(msg_bytes[size - 1] == SD_DHCP_OPTION_END);
 473
 474         xid = discover->xid;
 475
 476         if (verbose)
 477                 printf("  recv DHCP Discover 0x%08x\n", be32toh(xid));
 478
 479         memcpy(&test_addr_acq_offer[26], &udp_check, sizeof(udp_check));
 480         memcpy(&test_addr_acq_offer[32], &xid, sizeof(xid));
 481         memcpy(&test_addr_acq_offer[56], &mac_addr, ETHER_ADDR_LEN);
 482
 483         callback_recv = test_addr_acq_recv_request;
 484
 485         res = write(test_fd[1], test_addr_acq_offer,
 486                     sizeof(test_addr_acq_offer));
 487         assert_se(res == sizeof(test_addr_acq_offer));
 488
 489         if (verbose)
 490                 printf("  sent DHCP Offer\n");
 491
 492         return 0;
 493 }
 494
 495 static void test_addr_acq(sd_event *e) {
 496         sd_dhcp_client *client;
 497         int res, r;
 498
 499         if (verbose)
 500                 printf("* %s\n", __func__);
 501
 502         r = sd_dhcp_client_new(&client, false);
 503         assert_se(r >= 0);
 504         assert_se(client);
 505
 506         r = sd_dhcp_client_attach_event(client, e, 0);
 507         assert_se(r >= 0);
 508
 509         assert_se(sd_dhcp_client_set_ifindex(client, 42) >= 0);
 510         assert_se(sd_dhcp_client_set_mac(client, mac_addr, bcast_addr, ETH_ALEN, ARPHRD_ETHER) >= 0);
 511         dhcp_client_set_test_mode(client, true);
 512
 513         assert_se(sd_dhcp_client_set_callback(client, test_addr_acq_acquired, e) >= 0);
 514
 515         callback_recv = test_addr_acq_recv_discover;
 516
 517         assert_se(sd_event_add_time_relative(
 518                                   e, &test_hangcheck,
 519                                   clock_boottime_or_monotonic(),
 520                                   2 * USEC_PER_SEC, 0,
 521                                   test_dhcp_hangcheck, NULL) >= 0);
 522
 523         res = sd_dhcp_client_start(client);
 524         assert_se(IN_SET(res, 0, -EINPROGRESS));
 525
 526         assert_se(sd_event_loop(e) >= 0);
 527
 528         test_hangcheck = sd_event_source_unref(test_hangcheck);
 529
 530         assert_se(sd_dhcp_client_set_callback(client, NULL, NULL) >= 0);
 531         assert_se(sd_dhcp_client_stop(client) >= 0);
 532         sd_dhcp_client_unref(client);
 533
 534         test_fd[1] = safe_close(test_fd[1]);
 535
 536         callback_recv = NULL;
 537         xid = 0;
 538 }
 539
 540 int main(int argc, char *argv[]) {
 541         _cleanup_(sd_event_unrefp) sd_event *e;
 542
 543         test_setup_logging(LOG_DEBUG);
 544
 545         assert_se(sd_event_new(&e) >= 0);
 546
 547         test_request_basic(e);
 548         test_request_anonymize(e);
 549         test_checksum();
 550         test_dhcp_identifier_set_iaid();
 551
 552         test_discover_message(e);
 553         test_addr_acq(e);
 554
 555 #if VALGRIND
 556         /* Make sure the async_close thread has finished.
 557          * valgrind would report some of the phread_* structures
 558          * as not cleaned up properly. */
 559         sleep(1);
 560 #endif
 561
 562         return 0;
 563 }