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

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
  Copyright © 2013 Intel Corporation. All rights reserved.
***/

#include <net/if_arp.h>

#include "sd-dhcp-server.h"
#include "sd-event.h"

#include "dhcp-server-internal.h"
#include "hashmap.h"
#include "siphash24.h"
#include "tests.h"

static void test_pool(struct in_addr *address, unsigned size, int ret) {
        _cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;

        ASSERT_OK(sd_dhcp_server_new(&server, 1));

        if (ret >= 0)
                ASSERT_RETURN_IS_CRITICAL(true, ASSERT_OK_EQ(sd_dhcp_server_configure_pool(server, address, 8, 0, size), ret));
        else
                ASSERT_RETURN_IS_CRITICAL(false, ASSERT_ERROR(sd_dhcp_server_configure_pool(server, address, 8, 0, size), -ret));
}

static int test_basic(bool bind_to_interface) {
        _cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
        _cleanup_(sd_event_unrefp) sd_event *event = NULL;
        struct in_addr address_lo = {
                .s_addr = htobe32(INADDR_LOOPBACK),
        };
        struct in_addr address_any = {
                .s_addr = htobe32(INADDR_ANY),
        };
        int r;

        log_debug("/* %s(bind_to_interface=%s) */", __func__, yes_no(bind_to_interface));

        ASSERT_OK(sd_event_new(&event));

        /* attach to loopback interface */
        ASSERT_OK(sd_dhcp_server_new(&server, 1));
        ASSERT_NOT_NULL(server);
        server->bind_to_interface = bind_to_interface;

        ASSERT_OK(sd_dhcp_server_attach_event(server, event, 0));
        ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_attach_event(server, event, 0), EBUSY));
        ASSERT_TRUE(sd_dhcp_server_get_event(server) == event); /* ASSERT_EQ() doesn't work here. */
        ASSERT_OK(sd_dhcp_server_detach_event(server));
        ASSERT_NULL(sd_dhcp_server_get_event(server));
        ASSERT_OK(sd_dhcp_server_attach_event(server, NULL, 0));
        ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_attach_event(server, NULL, 0), EBUSY));

        ASSERT_TRUE(sd_dhcp_server_ref(server) == server);
        ASSERT_NULL(sd_dhcp_server_unref(server));

        ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_start(server), EUNATCH));

        ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_configure_pool(server, &address_any, 28, 0, 0), EINVAL));
        ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_configure_pool(server, &address_lo, 38, 0, 0), ERANGE));
        ASSERT_OK(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0));
        ASSERT_OK(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0));

        test_pool(&address_any, 1, -EINVAL);
        test_pool(&address_lo, 1, 0);

        r = sd_dhcp_server_start(server);
        /* skip test if running in an environment with no full networking support, CONFIG_PACKET not
         * compiled in kernel, nor af_packet module available. */
        if (r == -EPERM || r == -EAFNOSUPPORT)
                return r;
        ASSERT_OK(r);

        ASSERT_OK(sd_dhcp_server_start(server));
        ASSERT_OK(sd_dhcp_server_stop(server));
        ASSERT_OK(sd_dhcp_server_stop(server));
        ASSERT_OK(sd_dhcp_server_start(server));

        return 0;
}

static void test_message_handler(void) {
        _cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
        struct {
                struct {
                        DHCP_MESSAGE_HEADER_DEFINITION;
                } _packed_ message;
                struct {
                        uint8_t code;
                        uint8_t length;
                        uint8_t type;
                } _packed_ option_type;
                struct {
                        uint8_t code;
                        uint8_t length;
                        be32_t address;
                } _packed_ option_requested_ip;
                struct {
                        uint8_t code;
                        uint8_t length;
                        be32_t address;
                } _packed_ option_server_id;
                struct {
                        uint8_t code;
                        uint8_t length;
                        uint8_t id[7];
                } _packed_ option_client_id;
                struct {
                        uint8_t code;
                        uint8_t length;
                        uint8_t hostname[6];
                } _packed_ option_hostname;
                uint8_t end;
        } _packed_ test = {
                .message.op = BOOTREQUEST,
                .message.htype = ARPHRD_ETHER,
                .message.hlen = ETHER_ADDR_LEN,
                .message.xid = htobe32(0x12345678),
                .message.chaddr = { 'A', 'B', 'C', 'D', 'E', 'F' },
                .option_type.code = SD_DHCP_OPTION_MESSAGE_TYPE,
                .option_type.length = 1,
                .option_type.type = DHCP_DISCOVER,
                .option_hostname.code = SD_DHCP_OPTION_HOST_NAME,
                .option_hostname.length = 6,
                .option_hostname.hostname = { 'T', 'E', 'S', 'T', 'H', 'N' },
                .end = SD_DHCP_OPTION_END,
        };
        struct in_addr address_lo = {
                .s_addr = htobe32(INADDR_LOOPBACK),
        };
        struct in_addr static_lease_address = {
                .s_addr = htobe32(INADDR_LOOPBACK + 42),
        };
        static uint8_t static_lease_client_id[7] = {0x01, 'A', 'B', 'C', 'D', 'E', 'G' };
        int r;

        log_debug("/* %s */", __func__);

        ASSERT_OK(sd_dhcp_server_new(&server, 1));
        ASSERT_OK(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0));
        ASSERT_OK(sd_dhcp_server_set_static_lease(server, &static_lease_address, static_lease_client_id,
                                                  ELEMENTSOF(static_lease_client_id)));
        ASSERT_OK(sd_dhcp_server_attach_event(server, NULL, 0));
        ASSERT_OK(sd_dhcp_server_start(server));

        r = dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL);
        if (r == -ENETDOWN)
                return (void) log_tests_skipped("Network is not available");
        ASSERT_OK_EQ(r, DHCP_OFFER);

        test.end = 0;
        /* TODO, shouldn't this fail? */
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
        test.end = SD_DHCP_OPTION_END;
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);

        test.option_type.code = 0;
        test.option_type.length = 0;
        test.option_type.type = 0;
        ASSERT_ERROR(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), ENOMSG);
        test.option_type.code = SD_DHCP_OPTION_MESSAGE_TYPE;
        test.option_type.length = 1;
        test.option_type.type = DHCP_DISCOVER;
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);

        test.message.op = 0;
        ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));
        test.message.op = BOOTREQUEST;
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);

        test.message.htype = 0;
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
        test.message.htype = ARPHRD_ETHER;
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);

        test.message.hlen = 0;
        ASSERT_ERROR(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), EBADMSG);
        test.message.hlen = ETHER_ADDR_LEN;
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);

        test.option_type.type = DHCP_REQUEST;
        ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));
        test.option_requested_ip.code = SD_DHCP_OPTION_REQUESTED_IP_ADDRESS;
        test.option_requested_ip.length = 4;
        test.option_requested_ip.address = htobe32(0x12345678);
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_NAK);
        test.option_server_id.code = SD_DHCP_OPTION_SERVER_IDENTIFIER;
        test.option_server_id.length = 4;
        test.option_server_id.address = htobe32(INADDR_LOOPBACK);
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);

        test.option_server_id.address = htobe32(0x12345678);
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
        ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));
        test.option_server_id.address = htobe32(INADDR_LOOPBACK);
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 4);
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);

        test.option_client_id.code = SD_DHCP_OPTION_CLIENT_IDENTIFIER;
        test.option_client_id.length = 7;
        test.option_client_id.id[0] = 0x01;
        test.option_client_id.id[1] = 'A';
        test.option_client_id.id[2] = 'B';
        test.option_client_id.id[3] = 'C';
        test.option_client_id.id[4] = 'D';
        test.option_client_id.id[5] = 'E';
        test.option_client_id.id[6] = 'F';
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);

        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 30);
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);

        /* request address reserved for static lease (unmatching client ID) */
        test.option_client_id.id[6] = 'H';
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
        ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));

        /* request unmatching address */
        test.option_client_id.id[6] = 'G';
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 41);
        ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));

        /* request matching address */
        test.option_client_id.id[6] = 'G';
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);

        /* try again */
        test.option_client_id.id[6] = 'G';
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
        ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
}

static uint64_t client_id_hash_helper(sd_dhcp_client_id *id, uint8_t key[HASH_KEY_SIZE]) {
        struct siphash state;

        siphash24_init(&state, key);
        client_id_hash_func(id, &state);

        return htole64(siphash24_finalize(&state));
}

static void test_client_id_hash(void) {
        sd_dhcp_client_id a = {
                .size = 4,
        }, b = {
                .size = 4,
        };
        uint8_t hash_key[HASH_KEY_SIZE] = {
                '0', '1', '2', '3', '4', '5', '6', '7',
                '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
        };

        log_debug("/* %s */", __func__);

        memcpy(a.raw, "abcd", 4);
        memcpy(b.raw, "abcd", 4);

        ASSERT_EQ(client_id_compare_func(&a, &b), 0);
        ASSERT_EQ(client_id_hash_helper(&a, hash_key), client_id_hash_helper(&b, hash_key));
        a.size = 3;
        ASSERT_NE(client_id_compare_func(&a, &b), 0);
        a.size = 4;
        ASSERT_EQ(client_id_compare_func(&a, &b), 0);
        ASSERT_EQ(client_id_hash_helper(&a, hash_key), client_id_hash_helper(&b, hash_key));

        b.size = 3;
        ASSERT_NE(client_id_compare_func(&a, &b), 0);
        b.size = 4;
        ASSERT_EQ(client_id_compare_func(&a, &b), 0);
        ASSERT_EQ(client_id_hash_helper(&a, hash_key), client_id_hash_helper(&b, hash_key));

        memcpy(b.raw, "abce", 4);
        ASSERT_NE(client_id_compare_func(&a, &b), 0);
}

static void test_static_lease(void) {
        _cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;

        log_debug("/* %s */", __func__);

        ASSERT_OK(sd_dhcp_server_new(&server, 1));

        ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
                                                  (uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)));
        /* Duplicated entry. */
        ASSERT_ERROR(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
                                                     (uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)), EEXIST);
        /* Address is conflicted. */
        ASSERT_ERROR(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
                                                     (uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)), EEXIST);
        /* Client ID is conflicted. */
        ASSERT_ERROR(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020305 },
                                                     (uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)), EEXIST);

        ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020305 },
                                                  (uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
        /* Remove the previous entry. */
        ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
                                                  (uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
        /* Then, set a different address. */
        ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020306 },
                                                  (uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
        /* Remove again. */
        ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
                                                  (uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
        /* Try to remove non-existent entry. */
        ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
                                                  (uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
        /* Try to remove non-existent entry. */
        ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
                                                  (uint8_t*) &(uint32_t) { 0x01020306 }, sizeof(uint32_t)));
}

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

        test_setup_logging(LOG_DEBUG);

        test_client_id_hash();
        test_static_lease();

        r = test_basic(true);
        if (r < 0)
                return log_tests_skipped_errno(r, "cannot start dhcp server(bound to interface)");

        r = test_basic(false);
        if (r < 0)
                return log_tests_skipped_errno(r, "cannot start dhcp server(non-bound to interface)");

        test_message_handler();

        return 0;
}
Commit	Line	Data
	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
	2	/***
	3	Copyright © 2013 Intel Corporation. All rights reserved.
	4	***/
	5
	6	#include <net/if_arp.h>
	7
	8	#include "sd-dhcp-server.h"
	9	#include "sd-event.h"
	10
	11	#include "dhcp-server-internal.h"
	12	#include "hashmap.h"
	13	#include "siphash24.h"
	14	#include "tests.h"
	15
	16	static void test_pool(struct in_addr *address, unsigned size, int ret) {
	17	_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
	18
	19	ASSERT_OK(sd_dhcp_server_new(&server, 1));
	20
	21	if (ret >= 0)
	22	ASSERT_RETURN_IS_CRITICAL(true, ASSERT_OK_EQ(sd_dhcp_server_configure_pool(server, address, 8, 0, size), ret));
	23	else
	24	ASSERT_RETURN_IS_CRITICAL(false, ASSERT_ERROR(sd_dhcp_server_configure_pool(server, address, 8, 0, size), -ret));
	25	}
	26
	27	static int test_basic(bool bind_to_interface) {
	28	_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
	29	_cleanup_(sd_event_unrefp) sd_event *event = NULL;
	30	struct in_addr address_lo = {
	31	.s_addr = htobe32(INADDR_LOOPBACK),
	32	};
	33	struct in_addr address_any = {
	34	.s_addr = htobe32(INADDR_ANY),
	35	};
	36	int r;
	37
	38	log_debug("/* %s(bind_to_interface=%s) */", __func__, yes_no(bind_to_interface));
	39
	40	ASSERT_OK(sd_event_new(&event));
	41
	42	/* attach to loopback interface */
	43	ASSERT_OK(sd_dhcp_server_new(&server, 1));
	44	ASSERT_NOT_NULL(server);
	45	server->bind_to_interface = bind_to_interface;
	46
	47	ASSERT_OK(sd_dhcp_server_attach_event(server, event, 0));
	48	ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_attach_event(server, event, 0), EBUSY));
	49	ASSERT_TRUE(sd_dhcp_server_get_event(server) == event); /* ASSERT_EQ() doesn't work here. */
	50	ASSERT_OK(sd_dhcp_server_detach_event(server));
	51	ASSERT_NULL(sd_dhcp_server_get_event(server));
	52	ASSERT_OK(sd_dhcp_server_attach_event(server, NULL, 0));
	53	ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_attach_event(server, NULL, 0), EBUSY));
	54
	55	ASSERT_TRUE(sd_dhcp_server_ref(server) == server);
	56	ASSERT_NULL(sd_dhcp_server_unref(server));
	57
	58	ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_start(server), EUNATCH));
	59
	60	ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_configure_pool(server, &address_any, 28, 0, 0), EINVAL));
	61	ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_dhcp_server_configure_pool(server, &address_lo, 38, 0, 0), ERANGE));
	62	ASSERT_OK(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0));
	63	ASSERT_OK(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0));
	64
	65	test_pool(&address_any, 1, -EINVAL);
	66	test_pool(&address_lo, 1, 0);
	67
	68	r = sd_dhcp_server_start(server);
	69	/* skip test if running in an environment with no full networking support, CONFIG_PACKET not
	70	* compiled in kernel, nor af_packet module available. */
	71	if (r == -EPERM \|\| r == -EAFNOSUPPORT)
	72	return r;
	73	ASSERT_OK(r);
	74
	75	ASSERT_OK(sd_dhcp_server_start(server));
	76	ASSERT_OK(sd_dhcp_server_stop(server));
	77	ASSERT_OK(sd_dhcp_server_stop(server));
	78	ASSERT_OK(sd_dhcp_server_start(server));
	79
	80	return 0;
	81	}
	82
	83	static void test_message_handler(void) {
	84	_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
	85	struct {
	86	struct {
	87	DHCP_MESSAGE_HEADER_DEFINITION;
	88	} _packed_ message;
	89	struct {
	90	uint8_t code;
	91	uint8_t length;
	92	uint8_t type;
	93	} _packed_ option_type;
	94	struct {
	95	uint8_t code;
	96	uint8_t length;
	97	be32_t address;
	98	} _packed_ option_requested_ip;
	99	struct {
	100	uint8_t code;
	101	uint8_t length;
	102	be32_t address;
	103	} _packed_ option_server_id;
	104	struct {
	105	uint8_t code;
	106	uint8_t length;
	107	uint8_t id[7];
	108	} _packed_ option_client_id;
	109	struct {
	110	uint8_t code;
	111	uint8_t length;
	112	uint8_t hostname[6];
	113	} _packed_ option_hostname;
	114	uint8_t end;
	115	} _packed_ test = {
	116	.message.op = BOOTREQUEST,
	117	.message.htype = ARPHRD_ETHER,
	118	.message.hlen = ETHER_ADDR_LEN,
	119	.message.xid = htobe32(0x12345678),
	120	.message.chaddr = { 'A', 'B', 'C', 'D', 'E', 'F' },
	121	.option_type.code = SD_DHCP_OPTION_MESSAGE_TYPE,
	122	.option_type.length = 1,
	123	.option_type.type = DHCP_DISCOVER,
	124	.option_hostname.code = SD_DHCP_OPTION_HOST_NAME,
	125	.option_hostname.length = 6,
	126	.option_hostname.hostname = { 'T', 'E', 'S', 'T', 'H', 'N' },
	127	.end = SD_DHCP_OPTION_END,
	128	};
	129	struct in_addr address_lo = {
	130	.s_addr = htobe32(INADDR_LOOPBACK),
	131	};
	132	struct in_addr static_lease_address = {
	133	.s_addr = htobe32(INADDR_LOOPBACK + 42),
	134	};
	135	static uint8_t static_lease_client_id[7] = {0x01, 'A', 'B', 'C', 'D', 'E', 'G' };
	136	int r;
	137
	138	log_debug("/* %s */", __func__);
	139
	140	ASSERT_OK(sd_dhcp_server_new(&server, 1));
	141	ASSERT_OK(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0));
	142	ASSERT_OK(sd_dhcp_server_set_static_lease(server, &static_lease_address, static_lease_client_id,
	143	ELEMENTSOF(static_lease_client_id)));
	144	ASSERT_OK(sd_dhcp_server_attach_event(server, NULL, 0));
	145	ASSERT_OK(sd_dhcp_server_start(server));
	146
	147	r = dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL);
	148	if (r == -ENETDOWN)
	149	return (void) log_tests_skipped("Network is not available");
	150	ASSERT_OK_EQ(r, DHCP_OFFER);
	151
	152	test.end = 0;
	153	/* TODO, shouldn't this fail? */
	154	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
	155	test.end = SD_DHCP_OPTION_END;
	156	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
	157
	158	test.option_type.code = 0;
	159	test.option_type.length = 0;
	160	test.option_type.type = 0;
	161	ASSERT_ERROR(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), ENOMSG);
	162	test.option_type.code = SD_DHCP_OPTION_MESSAGE_TYPE;
	163	test.option_type.length = 1;
	164	test.option_type.type = DHCP_DISCOVER;
	165	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
	166
	167	test.message.op = 0;
	168	ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));
	169	test.message.op = BOOTREQUEST;
	170	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
	171
	172	test.message.htype = 0;
	173	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
	174	test.message.htype = ARPHRD_ETHER;
	175	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
	176
	177	test.message.hlen = 0;
	178	ASSERT_ERROR(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), EBADMSG);
	179	test.message.hlen = ETHER_ADDR_LEN;
	180	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_OFFER);
	181
	182	test.option_type.type = DHCP_REQUEST;
	183	ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));
	184	test.option_requested_ip.code = SD_DHCP_OPTION_REQUESTED_IP_ADDRESS;
	185	test.option_requested_ip.length = 4;
	186	test.option_requested_ip.address = htobe32(0x12345678);
	187	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_NAK);
	188	test.option_server_id.code = SD_DHCP_OPTION_SERVER_IDENTIFIER;
	189	test.option_server_id.length = 4;
	190	test.option_server_id.address = htobe32(INADDR_LOOPBACK);
	191	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
	192	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
	193
	194	test.option_server_id.address = htobe32(0x12345678);
	195	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
	196	ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));
	197	test.option_server_id.address = htobe32(INADDR_LOOPBACK);
	198	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 4);
	199	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
	200	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
	201	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
	202
	203	test.option_client_id.code = SD_DHCP_OPTION_CLIENT_IDENTIFIER;
	204	test.option_client_id.length = 7;
	205	test.option_client_id.id[0] = 0x01;
	206	test.option_client_id.id[1] = 'A';
	207	test.option_client_id.id[2] = 'B';
	208	test.option_client_id.id[3] = 'C';
	209	test.option_client_id.id[4] = 'D';
	210	test.option_client_id.id[5] = 'E';
	211	test.option_client_id.id[6] = 'F';
	212	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
	213
	214	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 30);
	215	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
	216
	217	/* request address reserved for static lease (unmatching client ID) */
	218	test.option_client_id.id[6] = 'H';
	219	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
	220	ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));
	221
	222	/* request unmatching address */
	223	test.option_client_id.id[6] = 'G';
	224	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 41);
	225	ASSERT_OK_ZERO(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL));
	226
	227	/* request matching address */
	228	test.option_client_id.id[6] = 'G';
	229	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
	230	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
	231
	232	/* try again */
	233	test.option_client_id.id[6] = 'G';
	234	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
	235	ASSERT_OK_EQ(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test), NULL), DHCP_ACK);
	236	}
	237
	238	static uint64_t client_id_hash_helper(sd_dhcp_client_id *id, uint8_t key[HASH_KEY_SIZE]) {
	239	struct siphash state;
	240
	241	siphash24_init(&state, key);
	242	client_id_hash_func(id, &state);
	243
	244	return htole64(siphash24_finalize(&state));
	245	}
	246
	247	static void test_client_id_hash(void) {
	248	sd_dhcp_client_id a = {
	249	.size = 4,
	250	}, b = {
	251	.size = 4,
	252	};
	253	uint8_t hash_key[HASH_KEY_SIZE] = {
	254	'0', '1', '2', '3', '4', '5', '6', '7',
	255	'8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
	256	};
	257
	258	log_debug("/* %s */", __func__);
	259
	260	memcpy(a.raw, "abcd", 4);
	261	memcpy(b.raw, "abcd", 4);
	262
	263	ASSERT_EQ(client_id_compare_func(&a, &b), 0);
	264	ASSERT_EQ(client_id_hash_helper(&a, hash_key), client_id_hash_helper(&b, hash_key));
	265	a.size = 3;
	266	ASSERT_NE(client_id_compare_func(&a, &b), 0);
	267	a.size = 4;
	268	ASSERT_EQ(client_id_compare_func(&a, &b), 0);
	269	ASSERT_EQ(client_id_hash_helper(&a, hash_key), client_id_hash_helper(&b, hash_key));
	270
	271	b.size = 3;
	272	ASSERT_NE(client_id_compare_func(&a, &b), 0);
	273	b.size = 4;
	274	ASSERT_EQ(client_id_compare_func(&a, &b), 0);
	275	ASSERT_EQ(client_id_hash_helper(&a, hash_key), client_id_hash_helper(&b, hash_key));
	276
	277	memcpy(b.raw, "abce", 4);
	278	ASSERT_NE(client_id_compare_func(&a, &b), 0);
	279	}
	280
	281	static void test_static_lease(void) {
	282	_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
	283
	284	log_debug("/* %s */", __func__);
	285
	286	ASSERT_OK(sd_dhcp_server_new(&server, 1));
	287
	288	ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
	289	(uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)));
	290	/* Duplicated entry. */
	291	ASSERT_ERROR(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
	292	(uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)), EEXIST);
	293	/* Address is conflicted. */
	294	ASSERT_ERROR(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
	295	(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)), EEXIST);
	296	/* Client ID is conflicted. */
	297	ASSERT_ERROR(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020305 },
	298	(uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)), EEXIST);
	299
	300	ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020305 },
	301	(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
	302	/* Remove the previous entry. */
	303	ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
	304	(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
	305	/* Then, set a different address. */
	306	ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020306 },
	307	(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
	308	/* Remove again. */
	309	ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
	310	(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
	311	/* Try to remove non-existent entry. */
	312	ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
	313	(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)));
	314	/* Try to remove non-existent entry. */
	315	ASSERT_OK(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
	316	(uint8_t*) &(uint32_t) { 0x01020306 }, sizeof(uint32_t)));
	317	}
	318
	319	int main(int argc, char *argv[]) {
	320	int r;
	321
	322	test_setup_logging(LOG_DEBUG);
	323
	324	test_client_id_hash();
	325	test_static_lease();
	326
	327	r = test_basic(true);
	328	if (r < 0)
	329	return log_tests_skipped_errno(r, "cannot start dhcp server(bound to interface)");
	330
	331	r = test_basic(false);
	332	if (r < 0)
	333	return log_tests_skipped_errno(r, "cannot start dhcp server(non-bound to interface)");
	334
	335	test_message_handler();
	336
	337	return 0;
	338	}