[thirdparty/systemd.git] / src / libsystemd-network / test-dhcp-client.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright (C) 2013 Intel Corporation. All rights reserved.

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>

#include "util.h"
#include "socket-util.h"

#include "dhcp-protocol.h"
#include "dhcp-internal.h"
#include "sd-dhcp-client.h"

static struct ether_addr mac_addr = {
        .ether_addr_octet = {'A', 'B', 'C', '1', '2', '3'}
};

typedef int (*test_callback_recv_t)(size_t size, DHCPMessage *dhcp);

static bool verbose = false;
static int test_fd[2];
static test_callback_recv_t callback_recv;
static be32_t xid;
static sd_event_source *test_hangcheck;

static int test_dhcp_hangcheck(sd_event_source *s, uint64_t usec,
                               void *userdata)
{
        assert_not_reached("Test case should have completed in 2 seconds");

        return 0;
}

static void test_request_basic(sd_event *e)
{
        int r;

        sd_dhcp_client *client;

        if (verbose)
                printf("* %s\n", __FUNCTION__);

        r = sd_dhcp_client_new(&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(NULL, 0) == -EINVAL);
        assert_se(sd_dhcp_client_set_request_address(NULL, NULL) == -EINVAL);
        assert_se(sd_dhcp_client_set_index(NULL, 0) == -EINVAL);

        assert_se(sd_dhcp_client_set_index(client, 15) == 0);
        assert_se(sd_dhcp_client_set_index(client, -42) == -EINVAL);
        assert_se(sd_dhcp_client_set_index(client, -1) == 0);

        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_SUBNET_MASK) == -EEXIST);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_ROUTER) == -EEXIST);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_HOST_NAME) == -EEXIST);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_DOMAIN_NAME) == -EEXIST);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_DOMAIN_NAME_SERVER)
                        == -EEXIST);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_NTP_SERVER) == -EEXIST);

        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_PAD) == -EINVAL);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_END) == -EINVAL);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_MESSAGE_TYPE) == -EINVAL);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_OVERLOAD) == -EINVAL);
        assert_se(sd_dhcp_client_set_request_option(client,
                                        DHCP_OPTION_PARAMETER_REQUEST_LIST)
                        == -EINVAL);

        assert_se(sd_dhcp_client_set_request_option(client, 33) == 0);
        assert_se(sd_dhcp_client_set_request_option(client, 33) == -EEXIST);
        assert_se(sd_dhcp_client_set_request_option(client, 44) == 0);
        assert_se(sd_dhcp_client_set_request_option(client, 33) == -EEXIST);
}

static void test_checksum(void)
{
        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)
                printf("* %s\n", __FUNCTION__);

        assert_se(dhcp_packet_checksum(&buf, 20) == be16toh(0x78ae));
}

static int check_options(uint8_t code, uint8_t len, const uint8_t *option,
                void *user_data)
{
        switch(code) {
        case DHCP_OPTION_CLIENT_IDENTIFIER:
                assert_se(len == 7);
                assert_se(option[0] == 0x01);
                assert_se(memcmp(&option[1], &mac_addr, ETH_ALEN) == 0);
                break;

        default:
                break;
        }

        return 0;
}

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;
        uint16_t ip_check, udp_check;

        assert_se(s >= 0);
        assert_se(packet);

        size = sizeof(DHCPPacket) + 4;
        assert_se(len > size);

        discover = 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));

        ip_check = discover->ip.check;

        discover->ip.ttl = 0;
        discover->ip.check = discover->udp.len;

        udp_check = ~dhcp_packet_checksum(&discover->ip.ttl, len - 8);
        assert_se(udp_check == 0xffff);

        discover->ip.ttl = IPDEFTTL;
        discover->ip.check = ip_check;

        ip_check = ~dhcp_packet_checksum(&discover->ip, sizeof(discover->ip));
        assert_se(ip_check == 0xffff);

        assert_se(discover->dhcp.xid);
        assert_se(memcmp(discover->dhcp.chaddr,
                      &mac_addr.ether_addr_octet, 6) == 0);

        size = len - sizeof(struct iphdr) - sizeof(struct udphdr);

        assert_se(callback_recv);
        callback_recv(size, &discover->dhcp);

        return 575;
}

int dhcp_network_bind_raw_socket(int index, union sockaddr_union *link)
{
        if (socketpair(AF_UNIX, SOCK_STREAM, 0, test_fd) < 0)
                return -errno;

        return test_fd[0];
}

int dhcp_network_bind_udp_socket(int index, be32_t address, uint16_t port)
{
        return 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);
        assert_se(res == DHCP_DISCOVER);

        if (verbose)
                printf("  recv DHCP Discover 0x%08x\n", be32toh(dhcp->xid));

        return 0;
}

static void test_discover_message(sd_event *e)
{
        sd_dhcp_client *client;
        int res, r;

        if (verbose)
                printf("* %s\n", __FUNCTION__);

        r = sd_dhcp_client_new(&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_index(client, 42) >= 0);
        assert_se(sd_dhcp_client_set_mac(client, &mac_addr) >= 0);

        assert_se(sd_dhcp_client_set_request_option(client, 248) >= 0);

        callback_recv = test_discover_message_verify;

        res = sd_dhcp_client_start(client);

        assert_se(res == 0 || res == -EINPROGRESS);

        sd_event_run(e, (uint64_t) -1);

        sd_dhcp_client_stop(client);
        sd_dhcp_client_free(client);

        test_fd[1] = safe_close(test_fd[1]);

        callback_recv = NULL;
}

static uint8_t test_addr_acq_offer[] = {
        0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
        0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
        0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
        0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
        0x6f, 0x95, 0x2f, 0x30, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
        0xc0, 0xa8, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x02, 0x36,
        0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
        0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
        0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
        0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
        0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
        0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};

static uint8_t test_addr_acq_ack[] = {
        0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
        0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
        0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
        0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
        0xc0, 0xa8, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x05, 0x36,
        0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
        0x00, 0x02, 0x58, 0x01, 0x04,   0xff, 0xff, 0xff,
        0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
        0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
        0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
        0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};

static void test_addr_acq_acquired(sd_dhcp_client *client, int event,
                                   void *userdata)
{
        sd_event *e = userdata;
        sd_dhcp_lease *lease;
        struct in_addr addr;

        assert_se(client);
        assert_se(event == DHCP_EVENT_IP_ACQUIRE);

        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, &addr) >= 0);
        assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[308],
                      sizeof(addr.s_addr)) == 0);

        if (verbose)
                printf("  DHCP address acquired\n");

        sd_event_exit(e, 0);
}

static int 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);
        assert_se(res == DHCP_REQUEST);
        assert_se(xid == request->xid);

        assert_se(msg_bytes[size - 1] == DHCP_OPTION_END);

        if (verbose)
                printf("  recv DHCP Request  0x%08x\n", be32toh(xid));

        memcpy(&test_addr_acq_ack[26], &udp_check, sizeof(udp_check));
        memcpy(&test_addr_acq_ack[32], &xid, sizeof(xid));
        memcpy(&test_addr_acq_ack[56], &mac_addr.ether_addr_octet,
               ETHER_ADDR_LEN);

        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));

        if (verbose)
                printf("  send DHCP Ack\n");

        return 0;
};

static int 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);
        assert_se(res == DHCP_DISCOVER);

        assert_se(msg_bytes[size - 1] == DHCP_OPTION_END);

        xid = discover->xid;

        if (verbose)
                printf("  recv DHCP Discover 0x%08x\n", be32toh(xid));

        memcpy(&test_addr_acq_offer[26], &udp_check, sizeof(udp_check));
        memcpy(&test_addr_acq_offer[32], &xid, sizeof(xid));
        memcpy(&test_addr_acq_offer[56], &mac_addr.ether_addr_octet,
               ETHER_ADDR_LEN);

        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));

        if (verbose)
                printf("  send DHCP Offer\n");

        return 0;
}

static void test_addr_acq(sd_event *e)
{
        usec_t time_now = now(CLOCK_MONOTONIC);
        sd_dhcp_client *client;
        int res, r;

        if (verbose)
                printf("* %s\n", __FUNCTION__);

        r = sd_dhcp_client_new(&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_index(client, 42) >= 0);
        assert_se(sd_dhcp_client_set_mac(client, &mac_addr) >= 0);

        assert_se(sd_dhcp_client_set_callback(client, test_addr_acq_acquired, e)
                >= 0);

        callback_recv = test_addr_acq_recv_discover;

        assert_se(sd_event_add_time(e, &test_hangcheck,
                                    CLOCK_MONOTONIC,
                                    time_now + 2 * USEC_PER_SEC, 0,
                                    test_dhcp_hangcheck, NULL) >= 0);

        res = sd_dhcp_client_start(client);
        assert_se(res == 0 || res == -EINPROGRESS);

        sd_event_loop(e);

        test_hangcheck = sd_event_source_unref(test_hangcheck);

        sd_dhcp_client_set_callback(client, NULL, NULL);
        sd_dhcp_client_stop(client);
        sd_dhcp_client_free(client);

        test_fd[1] = safe_close(test_fd[1]);

        callback_recv = NULL;
        xid = 0;
}

int main(int argc, char *argv[])
{
        sd_event *e;

        assert_se(sd_event_new(&e) >= 0);

        test_request_basic(e);
        test_checksum();

        test_discover_message(e);
        test_addr_acq(e);

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