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