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