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

        close(test_fd[0]);
        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_monotonic(e, &test_hangcheck,
                                         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);

        close(test_fd[0]);
        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
8c00042c PF	256	close(test_fd[0]);
8c00042c PF	257	close(test_fd[1]);
6c8a0f07 PF	258
6c8a0f07 PF	259	callback_recv = NULL;
290c7324 PF	260	}
290c7324 PF	261
234ed3eb PF	262	static uint8_t test_addr_acq_offer[] = {
	263	0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
	264	0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
	265	0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
	266	0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
	267	0x6f, 0x95, 0x2f, 0x30, 0x00, 0x00, 0x00, 0x00,
	268	0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
	269	0xc0, 0xa8, 0x02, 0x01, 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	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	296	0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x02, 0x36,
	297	0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
	298	0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
	299	0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
	300	0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
	301	0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
	302	0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	303	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	304	};
	305
	306	static uint8_t test_addr_acq_ack[] = {
	307	0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
	308	0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
	309	0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
	310	0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
	311	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
	312	0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
	313	0xc0, 0xa8, 0x02, 0x01, 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	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
340	0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x05, 0x36,
341	0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
342	0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
343	0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
344	0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
345	0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
346	0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348	};
349
350	static void test_addr_acq_acquired(sd_dhcp_client *client, int event,
351	void *userdata)
352	{
353	sd_event *e = userdata;
354	sd_dhcp_lease *lease;
355	struct in_addr addr;
356
12e0f830 TG	357	assert_se(client);
12e0f830 TG	358	assert_se(event == DHCP_EVENT_IP_ACQUIRE);
234ed3eb	359
12e0f830 TG	360	assert_se(sd_dhcp_client_get_lease(client, &lease) >= 0);
12e0f830 TG	361	assert_se(lease);
234ed3eb	362
12e0f830 TG	363	assert_se(sd_dhcp_lease_get_address(lease, &addr) >= 0);
12e0f830 TG	364	assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[44],
234ed3eb PF	365	sizeof(addr.s_addr)) == 0);
234ed3eb PF	366
12e0f830 TG	367	assert_se(sd_dhcp_lease_get_netmask(lease, &addr) >= 0);
12e0f830 TG	368	assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[285],
234ed3eb PF	369	sizeof(addr.s_addr)) == 0);
234ed3eb PF	370
12e0f830 TG	371	assert_se(sd_dhcp_lease_get_router(lease, &addr) >= 0);
12e0f830 TG	372	assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[308],
234ed3eb PF	373	sizeof(addr.s_addr)) == 0);
	374
	375	if (verbose)
	376	printf(" DHCP address acquired\n");
	377
	378	sd_event_exit(e, 0);
	379	}
	380
	381	static int test_addr_acq_recv_request(size_t size, DHCPMessage *request)
	382	{
	383	uint16_t udp_check = 0;
d790d3f1	384	uint8_t msg_bytes = (uint8_t )request;
234ed3eb PF	385	int res;
	386
	387	res = dhcp_option_parse(request, size, check_options, NULL);
12e0f830 TG	388	assert_se(res == DHCP_REQUEST);
12e0f830 TG	389	assert_se(xid == request->xid);
234ed3eb	390
d790d3f1 PF	391	assert_se(msg_bytes[size - 1] == DHCP_OPTION_END);
d790d3f1 PF	392
234ed3eb PF	393	if (verbose)
	394	printf(" recv DHCP Request 0x%08x\n", be32toh(xid));
	395
	396	memcpy(&test_addr_acq_ack[26], &udp_check, sizeof(udp_check));
	397	memcpy(&test_addr_acq_ack[32], &xid, sizeof(xid));
	398	memcpy(&test_addr_acq_ack[56], &mac_addr.ether_addr_octet,
	399	ETHER_ADDR_LEN);
	400
	401	callback_recv = NULL;
	402
	403	res = write(test_fd[1], test_addr_acq_ack,
	404	sizeof(test_addr_acq_ack));
12e0f830	405	assert_se(res == sizeof(test_addr_acq_ack));
234ed3eb PF	406
	407	if (verbose)
	408	printf(" send DHCP Ack\n");
	409
	410	return 0;
	411	};
	412
	413	static int test_addr_acq_recv_discover(size_t size, DHCPMessage *discover)
	414	{
	415	uint16_t udp_check = 0;
d790d3f1	416	uint8_t msg_bytes = (uint8_t )discover;
234ed3eb PF	417	int res;
	418
	419	res = dhcp_option_parse(discover, size, check_options, NULL);
12e0f830	420	assert_se(res == DHCP_DISCOVER);
234ed3eb	421
d790d3f1 PF	422	assert_se(msg_bytes[size - 1] == DHCP_OPTION_END);
d790d3f1 PF	423
234ed3eb PF	424	xid = discover->xid;
	425
	426	if (verbose)
	427	printf(" recv DHCP Discover 0x%08x\n", be32toh(xid));
	428
	429	memcpy(&test_addr_acq_offer[26], &udp_check, sizeof(udp_check));
	430	memcpy(&test_addr_acq_offer[32], &xid, sizeof(xid));
	431	memcpy(&test_addr_acq_offer[56], &mac_addr.ether_addr_octet,
	432	ETHER_ADDR_LEN);
	433
	434	callback_recv = test_addr_acq_recv_request;
	435
	436	res = write(test_fd[1], test_addr_acq_offer,
	437	sizeof(test_addr_acq_offer));
12e0f830	438	assert_se(res == sizeof(test_addr_acq_offer));
234ed3eb PF	439
	440	if (verbose)
	441	printf(" send DHCP Offer\n");
	442
	443	return 0;
	444	}
	445
	446	static void test_addr_acq(sd_event *e)
	447	{
8fc8e3ab	448	usec_t time_now = now(CLOCK_MONOTONIC);
234ed3eb PF	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);
12e0f830 TG	456	assert_se(r >= 0);
12e0f830 TG	457	assert_se(client);
234ed3eb PF	458
234ed3eb PF	459	r = sd_dhcp_client_attach_event(client, e, 0);
12e0f830	460	assert_se(r >= 0);
234ed3eb	461
12e0f830 TG	462	assert_se(sd_dhcp_client_set_index(client, 42) >= 0);
12e0f830 TG	463	assert_se(sd_dhcp_client_set_mac(client, &mac_addr) >= 0);
234ed3eb	464
12e0f830	465	assert_se(sd_dhcp_client_set_callback(client, test_addr_acq_acquired, e)
234ed3eb PF	466	>= 0);
	467
	468	callback_recv = test_addr_acq_recv_discover;
	469
8fc8e3ab PF	470	assert_se(sd_event_add_monotonic(e, &test_hangcheck,
	471	time_now + 2 * USEC_PER_SEC, 0,
	472	test_dhcp_hangcheck, NULL) >= 0);
	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
	485	close(test_fd[0]);
	486	close(test_fd[1]);
	487
	488	callback_recv = NULL;
	489	xid = 0;
	490	}
	491
be391925 PF	492	int main(int argc, char *argv[])
be391925 PF	493	{
d3d8ac2f PF	494	sd_event *e;
d3d8ac2f PF	495
12e0f830	496	assert_se(sd_event_new(&e) >= 0);
d3d8ac2f PF	497
d3d8ac2f PF	498	test_request_basic(e);
39b7f596	499	test_checksum();
be391925	500
d3d8ac2f	501	test_discover_message(e);
234ed3eb	502	test_addr_acq(e);
290c7324	503
be391925 PF	504	return 0;
be391925 PF	505	}