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

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright (C) 2013 Intel Corporation. All rights reserved.
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <sys/socket.h>
  25 #include <unistd.h>
  26
  27 #include "util.h"
  28 #include "sd-event.h"
  29 #include "event-util.h"
  30
  31 #include "dhcp-identifier.h"
  32 #include "dhcp-protocol.h"
  33 #include "dhcp-internal.h"
  34 #include "sd-dhcp-client.h"
  35
  36 static uint8_t mac_addr[] = {'A', 'B', 'C', '1', '2', '3'};
  37
  38 typedef int (*test_callback_recv_t)(size_t size, DHCPMessage *dhcp);
  39
  40 static bool verbose = true;
  41 static int test_fd[2];
  42 static test_callback_recv_t callback_recv;
  43 static be32_t xid;
  44 static sd_event_source *test_hangcheck;
  45
  46 static int test_dhcp_hangcheck(sd_event_source *s, uint64_t usec,
  47                                void *userdata)
  48 {
  49         assert_not_reached("Test case should have completed in 2 seconds");
  50
  51         return 0;
  52 }
  53
  54 static void test_request_basic(sd_event *e)
  55 {
  56         int r;
  57
  58         sd_dhcp_client *client;
  59
  60         if (verbose)
  61                 printf("* %s\n", __FUNCTION__);
  62
  63         r = sd_dhcp_client_new(&client);
  64
  65         assert_se(r >= 0);
  66         assert_se(client);
  67
  68         r = sd_dhcp_client_attach_event(client, e, 0);
  69         assert_se(r >= 0);
  70
  71         assert_se(sd_dhcp_client_set_request_option(NULL, 0) == -EINVAL);
  72         assert_se(sd_dhcp_client_set_request_address(NULL, NULL) == -EINVAL);
  73         assert_se(sd_dhcp_client_set_index(NULL, 0) == -EINVAL);
  74
  75         assert_se(sd_dhcp_client_set_index(client, 15) == 0);
  76         assert_se(sd_dhcp_client_set_index(client, -42) == -EINVAL);
  77         assert_se(sd_dhcp_client_set_index(client, -1) == -EINVAL);
  78         assert_se(sd_dhcp_client_set_index(client, 0) == -EINVAL);
  79         assert_se(sd_dhcp_client_set_index(client, 1) == 0);
  80
  81         assert_se(sd_dhcp_client_set_request_option(client,
  82                                         DHCP_OPTION_SUBNET_MASK) == -EEXIST);
  83         assert_se(sd_dhcp_client_set_request_option(client,
  84                                         DHCP_OPTION_ROUTER) == -EEXIST);
  85         assert_se(sd_dhcp_client_set_request_option(client,
  86                                         DHCP_OPTION_HOST_NAME) == -EEXIST);
  87         assert_se(sd_dhcp_client_set_request_option(client,
  88                                         DHCP_OPTION_DOMAIN_NAME) == -EEXIST);
  89         assert_se(sd_dhcp_client_set_request_option(client,
  90                                         DHCP_OPTION_DOMAIN_NAME_SERVER)
  91                         == -EEXIST);
  92         assert_se(sd_dhcp_client_set_request_option(client,
  93                                         DHCP_OPTION_NTP_SERVER) == -EEXIST);
  94
  95         assert_se(sd_dhcp_client_set_request_option(client,
  96                                         DHCP_OPTION_PAD) == -EINVAL);
  97         assert_se(sd_dhcp_client_set_request_option(client,
  98                                         DHCP_OPTION_END) == -EINVAL);
  99         assert_se(sd_dhcp_client_set_request_option(client,
 100                                         DHCP_OPTION_MESSAGE_TYPE) == -EINVAL);
 101         assert_se(sd_dhcp_client_set_request_option(client,
 102                                         DHCP_OPTION_OVERLOAD) == -EINVAL);
 103         assert_se(sd_dhcp_client_set_request_option(client,
 104                                         DHCP_OPTION_PARAMETER_REQUEST_LIST)
 105                         == -EINVAL);
 106
 107         assert_se(sd_dhcp_client_set_request_option(client, 33) == 0);
 108         assert_se(sd_dhcp_client_set_request_option(client, 33) == -EEXIST);
 109         assert_se(sd_dhcp_client_set_request_option(client, 44) == 0);
 110         assert_se(sd_dhcp_client_set_request_option(client, 33) == -EEXIST);
 111
 112         sd_dhcp_client_unref(client);
 113 }
 114
 115 static void test_checksum(void)
 116 {
 117         uint8_t buf[20] = {
 118                 0x45, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00,
 119                 0x40, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 120                 0xff, 0xff, 0xff, 0xff
 121         };
 122
 123         if (verbose)
 124                 printf("* %s\n", __FUNCTION__);
 125
 126         assert_se(dhcp_packet_checksum((uint8_t*)&buf, 20) == be16toh(0x78ae));
 127 }
 128
 129 static int check_options(uint8_t code, uint8_t len, const uint8_t *option,
 130                 void *userdata)
 131 {
 132         switch(code) {
 133         case DHCP_OPTION_CLIENT_IDENTIFIER:
 134         {
 135                 uint32_t iaid;
 136                 struct duid duid;
 137                 size_t duid_len;
 138
 139                 assert_se(dhcp_identifier_set_duid_en(&duid, &duid_len) >= 0);
 140                 assert_se(dhcp_identifier_set_iaid(42, mac_addr, ETH_ALEN, &iaid) >= 0);
 141
 142                 assert_se(len == sizeof(uint8_t) + sizeof(uint32_t) + duid_len);
 143                 assert_se(len == 19);
 144                 assert_se(option[0] == 0xff);
 145
 146                 assert_se(memcmp(&option[1], &iaid, sizeof(iaid)) == 0);
 147                 assert_se(memcmp(&option[5], &duid, duid_len) == 0);
 148                 break;
 149         }
 150
 151         default:
 152                 break;
 153         }
 154
 155         return 0;
 156 }
 157
 158 int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link,
 159                                  const void *packet, size_t len)
 160 {
 161         size_t size;
 162         _cleanup_free_ DHCPPacket *discover;
 163         uint16_t ip_check, udp_check;
 164
 165         assert_se(s >= 0);
 166         assert_se(packet);
 167
 168         size = sizeof(DHCPPacket);
 169         assert_se(len > size);
 170
 171         discover = memdup(packet, len);
 172
 173         assert_se(discover->ip.ttl == IPDEFTTL);
 174         assert_se(discover->ip.protocol == IPPROTO_UDP);
 175         assert_se(discover->ip.saddr == INADDR_ANY);
 176         assert_se(discover->ip.daddr == INADDR_BROADCAST);
 177         assert_se(discover->udp.source == be16toh(DHCP_PORT_CLIENT));
 178         assert_se(discover->udp.dest == be16toh(DHCP_PORT_SERVER));
 179
 180         ip_check = discover->ip.check;
 181
 182         discover->ip.ttl = 0;
 183         discover->ip.check = discover->udp.len;
 184
 185         udp_check = ~dhcp_packet_checksum((uint8_t*)&discover->ip.ttl, len - 8);
 186         assert_se(udp_check == 0xffff);
 187
 188         discover->ip.ttl = IPDEFTTL;
 189         discover->ip.check = ip_check;
 190
 191         ip_check = ~dhcp_packet_checksum((uint8_t*)&discover->ip, sizeof(discover->ip));
 192         assert_se(ip_check == 0xffff);
 193
 194         assert_se(discover->dhcp.xid);
 195         assert_se(memcmp(discover->dhcp.chaddr, &mac_addr, ETH_ALEN) == 0);
 196
 197         size = len - sizeof(struct iphdr) - sizeof(struct udphdr);
 198
 199         assert_se(callback_recv);
 200         callback_recv(size, &discover->dhcp);
 201
 202         return 575;
 203 }
 204
 205 int dhcp_network_bind_raw_socket(int index, union sockaddr_union *link,
 206                                  uint32_t id, const uint8_t *addr,
 207                                  size_t addr_len, uint16_t arp_type)
 208 {
 209         if (socketpair(AF_UNIX, SOCK_STREAM, 0, test_fd) < 0)
 210                 return -errno;
 211
 212         return test_fd[0];
 213 }
 214
 215 int dhcp_network_bind_udp_socket(be32_t address, uint16_t port)
 216 {
 217         int fd;
 218
 219         fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
 220         if (fd < 0)
 221                 return -errno;
 222
 223         return fd;
 224 }
 225
 226 int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port,
 227                                  const void *packet, size_t len)
 228 {
 229         return 0;
 230 }
 231
 232 static int test_discover_message_verify(size_t size, struct DHCPMessage *dhcp)
 233 {
 234         int res;
 235
 236         res = dhcp_option_parse(dhcp, size, check_options, NULL);
 237         assert_se(res == DHCP_DISCOVER);
 238
 239         if (verbose)
 240                 printf("  recv DHCP Discover 0x%08x\n", be32toh(dhcp->xid));
 241
 242         return 0;
 243 }
 244
 245 static void test_discover_message(sd_event *e)
 246 {
 247         sd_dhcp_client *client;
 248         int res, r;
 249
 250         if (verbose)
 251                 printf("* %s\n", __FUNCTION__);
 252
 253         r = sd_dhcp_client_new(&client);
 254         assert_se(r >= 0);
 255         assert_se(client);
 256
 257         r = sd_dhcp_client_attach_event(client, e, 0);
 258         assert_se(r >= 0);
 259
 260         assert_se(sd_dhcp_client_set_index(client, 42) >= 0);
 261         assert_se(sd_dhcp_client_set_mac(client, mac_addr, ETH_ALEN, ARPHRD_ETHER) >= 0);
 262
 263         assert_se(sd_dhcp_client_set_request_option(client, 248) >= 0);
 264
 265         callback_recv = test_discover_message_verify;
 266
 267         res = sd_dhcp_client_start(client);
 268
 269         assert_se(res == 0 || res == -EINPROGRESS);
 270
 271         sd_event_run(e, (uint64_t) -1);
 272
 273         sd_dhcp_client_stop(client);
 274         sd_dhcp_client_unref(client);
 275
 276         test_fd[1] = safe_close(test_fd[1]);
 277
 278         callback_recv = NULL;
 279 }
 280
 281 static uint8_t test_addr_acq_offer[] = {
 282         0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
 283         0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
 284         0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
 285         0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
 286         0x6f, 0x95, 0x2f, 0x30, 0x00, 0x00, 0x00, 0x00,
 287         0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
 288         0xc0, 0xa8, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
 289         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 290         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 291         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 292         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 293         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 294         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 295         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 296         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 297         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 298         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 299         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 300         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 301         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 302         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 303         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 304         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 305         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 306         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 307         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 308         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 309         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 310         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 311         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 312         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 313         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 314         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 315         0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x02, 0x36,
 316         0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
 317         0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
 318         0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
 319         0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
 320         0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
 321         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 322         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 323 };
 324
 325 static uint8_t test_addr_acq_ack[] = {
 326         0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
 327         0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
 328         0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
 329         0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
 330         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
 331         0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
 332         0xc0, 0xa8, 0x02, 0x01, 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         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 348         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 349         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 350         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 351         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 352         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 353         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 354         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 355         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 356         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 357         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 358         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 359         0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x05, 0x36,
 360         0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
 361         0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
 362         0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
 363         0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
 364         0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
 365         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 366         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 367 };
 368
 369 static void test_addr_acq_acquired(sd_dhcp_client *client, int event,
 370                                    void *userdata) {
 371         sd_event *e = userdata;
 372         sd_dhcp_lease *lease;
 373         struct in_addr addr;
 374
 375         assert_se(client);
 376         assert_se(event == DHCP_EVENT_IP_ACQUIRE);
 377
 378         assert_se(sd_dhcp_client_get_lease(client, &lease) >= 0);
 379         assert_se(lease);
 380
 381         assert_se(sd_dhcp_lease_get_address(lease, &addr) >= 0);
 382         assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[44],
 383                       sizeof(addr.s_addr)) == 0);
 384
 385         assert_se(sd_dhcp_lease_get_netmask(lease, &addr) >= 0);
 386         assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[285],
 387                       sizeof(addr.s_addr)) == 0);
 388
 389         assert_se(sd_dhcp_lease_get_router(lease, &addr) >= 0);
 390         assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[308],
 391                       sizeof(addr.s_addr)) == 0);
 392
 393         if (verbose)
 394                 printf("  DHCP address acquired\n");
 395
 396         sd_event_exit(e, 0);
 397 }
 398
 399 static int test_addr_acq_recv_request(size_t size, DHCPMessage *request) {
 400         uint16_t udp_check = 0;
 401         uint8_t *msg_bytes = (uint8_t *)request;
 402         int res;
 403
 404         res = dhcp_option_parse(request, size, check_options, NULL);
 405         assert_se(res == DHCP_REQUEST);
 406         assert_se(xid == request->xid);
 407
 408         assert_se(msg_bytes[size - 1] == DHCP_OPTION_END);
 409
 410         if (verbose)
 411                 printf("  recv DHCP Request  0x%08x\n", be32toh(xid));
 412
 413         memcpy(&test_addr_acq_ack[26], &udp_check, sizeof(udp_check));
 414         memcpy(&test_addr_acq_ack[32], &xid, sizeof(xid));
 415         memcpy(&test_addr_acq_ack[56], &mac_addr, ETHER_ADDR_LEN);
 416
 417         callback_recv = NULL;
 418
 419         res = write(test_fd[1], test_addr_acq_ack,
 420                     sizeof(test_addr_acq_ack));
 421         assert_se(res == sizeof(test_addr_acq_ack));
 422
 423         if (verbose)
 424                 printf("  send DHCP Ack\n");
 425
 426         return 0;
 427 };
 428
 429 static int test_addr_acq_recv_discover(size_t size, DHCPMessage *discover) {
 430         uint16_t udp_check = 0;
 431         uint8_t *msg_bytes = (uint8_t *)discover;
 432         int res;
 433
 434         res = dhcp_option_parse(discover, size, check_options, NULL);
 435         assert_se(res == DHCP_DISCOVER);
 436
 437         assert_se(msg_bytes[size - 1] == DHCP_OPTION_END);
 438
 439         xid = discover->xid;
 440
 441         if (verbose)
 442                 printf("  recv DHCP Discover 0x%08x\n", be32toh(xid));
 443
 444         memcpy(&test_addr_acq_offer[26], &udp_check, sizeof(udp_check));
 445         memcpy(&test_addr_acq_offer[32], &xid, sizeof(xid));
 446         memcpy(&test_addr_acq_offer[56], &mac_addr, ETHER_ADDR_LEN);
 447
 448         callback_recv = test_addr_acq_recv_request;
 449
 450         res = write(test_fd[1], test_addr_acq_offer,
 451                     sizeof(test_addr_acq_offer));
 452         assert_se(res == sizeof(test_addr_acq_offer));
 453
 454         if (verbose)
 455                 printf("  sent DHCP Offer\n");
 456
 457         return 0;
 458 }
 459
 460 static void test_addr_acq(sd_event *e) {
 461         usec_t time_now = now(clock_boottime_or_monotonic());
 462         sd_dhcp_client *client;
 463         int res, r;
 464
 465         if (verbose)
 466                 printf("* %s\n", __FUNCTION__);
 467
 468         r = sd_dhcp_client_new(&client);
 469         assert_se(r >= 0);
 470         assert_se(client);
 471
 472         r = sd_dhcp_client_attach_event(client, e, 0);
 473         assert_se(r >= 0);
 474
 475         assert_se(sd_dhcp_client_set_index(client, 42) >= 0);
 476         assert_se(sd_dhcp_client_set_mac(client, mac_addr, ETH_ALEN, ARPHRD_ETHER) >= 0);
 477
 478         assert_se(sd_dhcp_client_set_callback(client, test_addr_acq_acquired, e) >= 0);
 479
 480         callback_recv = test_addr_acq_recv_discover;
 481
 482         assert_se(sd_event_add_time(e, &test_hangcheck,
 483                                     clock_boottime_or_monotonic(),
 484                                     time_now + 2 * USEC_PER_SEC, 0,
 485                                     test_dhcp_hangcheck, NULL) >= 0);
 486
 487         res = sd_dhcp_client_start(client);
 488         assert_se(res == 0 || res == -EINPROGRESS);
 489
 490         assert_se(sd_event_loop(e) >= 0);
 491
 492         test_hangcheck = sd_event_source_unref(test_hangcheck);
 493
 494         assert_se(sd_dhcp_client_set_callback(client, NULL, NULL) >= 0);
 495         assert_se(sd_dhcp_client_stop(client) >= 0);
 496         sd_dhcp_client_unref(client);
 497
 498         test_fd[1] = safe_close(test_fd[1]);
 499
 500         callback_recv = NULL;
 501         xid = 0;
 502 }
 503
 504 int main(int argc, char *argv[]) {
 505         _cleanup_event_unref_ sd_event *e;
 506
 507         log_set_max_level(LOG_DEBUG);
 508         log_parse_environment();
 509         log_open();
 510
 511         assert_se(sd_event_new(&e) >= 0);
 512
 513         test_request_basic(e);
 514         test_checksum();
 515
 516         test_discover_message(e);
 517         test_addr_acq(e);
 518
 519 #ifdef VALGRIND
 520         /* Make sure the async_close thread has finished.
 521          * valgrind would report some of the phread_* structures
 522          * as not cleaned up properly. */
 523         sleep(1);
 524 #endif
 525
 526         return 0;
 527 }