[thirdparty/systemd.git] / src / libsystemd-network / test-dhcp-server.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.
  Copyright (C) 2014 Tom Gundersen

  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 <netinet/if_ether.h>
#include <assert.h>
#include <errno.h>

#include "sd-event.h"
#include "event-util.h"

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

static void test_basic(sd_event *event) {
        _cleanup_dhcp_server_unref_ sd_dhcp_server *server = NULL;
        struct in_addr address_lo = {
                .s_addr = htonl(INADDR_LOOPBACK),
        };
        struct in_addr address_any = {
                .s_addr = htonl(INADDR_ANY),
        };

        /* attach to loopback interface */
        assert_se(sd_dhcp_server_new(&server, 1) >= 0);
        assert_se(server);

        assert_se(sd_dhcp_server_attach_event(server, event, 0) >= 0);
        assert_se(sd_dhcp_server_attach_event(server, event, 0) == -EBUSY);
        assert_se(sd_dhcp_server_get_event(server) == event);
        assert_se(sd_dhcp_server_detach_event(server) >= 0);
        assert_se(!sd_dhcp_server_get_event(server));
        assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
        assert_se(sd_dhcp_server_attach_event(server, NULL, 0) == -EBUSY);

        assert_se(sd_dhcp_server_ref(server) == server);
        assert_se(!sd_dhcp_server_unref(server));

        assert_se(sd_dhcp_server_start(server) == -EUNATCH);
        assert_se(sd_dhcp_server_set_address(server, &address_any) == -EINVAL);
        assert_se(sd_dhcp_server_set_address(server, &address_lo) >= 0);
        assert_se(sd_dhcp_server_set_address(server, &address_lo) == -EBUSY);

        assert_se(sd_dhcp_server_set_lease_pool(server, &address_any, 1) == -EINVAL);
        assert_se(sd_dhcp_server_set_lease_pool(server, &address_lo, 0) == -EINVAL);
        assert_se(sd_dhcp_server_set_lease_pool(server, &address_lo, 1) >= 0);
        assert_se(sd_dhcp_server_set_lease_pool(server, &address_lo, 1) == -EBUSY);

        assert_se(sd_dhcp_server_start(server) >= 0);
        assert_se(sd_dhcp_server_start(server) == -EBUSY);
        assert_se(sd_dhcp_server_stop(server) >= 0);
        assert_se(sd_dhcp_server_stop(server) >= 0);
        assert_se(sd_dhcp_server_start(server) >= 0);
}

static void test_message_handler(void) {
        _cleanup_dhcp_server_unref_ sd_dhcp_server *server = NULL;
        struct {
                DHCPMessage 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;
                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 = DHCP_OPTION_MESSAGE_TYPE,
                .option_type.length = 1,
                .option_type.type = DHCP_DISCOVER,
                .end = DHCP_OPTION_END,
        };
        struct in_addr address_lo = {
                .s_addr = htonl(INADDR_LOOPBACK),
        };

        assert_se(sd_dhcp_server_new(&server, 1) >= 0);
        assert_se(sd_dhcp_server_set_address(server, &address_lo) >= 0);
        assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
        assert_se(sd_dhcp_server_start(server) >= 0);

        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
        assert_se(sd_dhcp_server_set_lease_pool(server, &address_lo, 10) >= 0);
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);

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

        test.option_type.code = 0;
        test.option_type.length = 0;
        test.option_type.type = 0;
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
        test.option_type.code = DHCP_OPTION_MESSAGE_TYPE;
        test.option_type.length = 1;
        test.option_type.type = DHCP_DISCOVER;
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);

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

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

        test.message.hlen = 0;
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
        test.message.hlen = ETHER_ADDR_LEN;
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);

        test.option_type.type = DHCP_REQUEST;
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
        test.option_requested_ip.code = DHCP_OPTION_REQUESTED_IP_ADDRESS;
        test.option_requested_ip.length = 4;
        test.option_requested_ip.address = htobe32(0x12345678);
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_NAK);
        test.option_server_id.code = 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_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
        test.option_server_id.address = htobe32(0x12345678);
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
        test.option_server_id.address = htobe32(INADDR_LOOPBACK);
        test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 30);
        assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
}

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

        log_set_max_level(LOG_DEBUG);
        log_parse_environment();
        log_open();

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

        test_basic(e);
        test_message_handler();

        return 0;
}
Commit	Line	Data
b44cd882 TG	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	Copyright (C) 2014 Tom Gundersen
	8
	9	systemd is free software; you can redistribute it and/or modify it
	10	under the terms of the GNU Lesser General Public License as published by
	11	the Free Software Foundation; either version 2.1 of the License, or
	12	(at your option) any later version.
	13
	14	systemd is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License
	20	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	21	***/
	22
be077570	23	#include <netinet/if_ether.h>
b44cd882 TG	24	#include <assert.h>
	25	#include <errno.h>
	26
	27	#include "sd-event.h"
	28	#include "event-util.h"
	29
	30	#include "sd-dhcp-server.h"
	31	#include "dhcp-server-internal.h"
	32
	33	static void test_basic(sd_event *event) {
	34	_cleanup_dhcp_server_unref_ sd_dhcp_server *server = NULL;
20af7091 TG	35	struct in_addr address_lo = {
	36	.s_addr = htonl(INADDR_LOOPBACK),
	37	};
	38	struct in_addr address_any = {
	39	.s_addr = htonl(INADDR_ANY),
	40	};
b44cd882	41
3a864fe4 TG	42	/* attach to loopback interface */
3a864fe4 TG	43	assert_se(sd_dhcp_server_new(&server, 1) >= 0);
b44cd882 TG	44	assert_se(server);
	45
	46	assert_se(sd_dhcp_server_attach_event(server, event, 0) >= 0);
	47	assert_se(sd_dhcp_server_attach_event(server, event, 0) == -EBUSY);
	48	assert_se(sd_dhcp_server_get_event(server) == event);
	49	assert_se(sd_dhcp_server_detach_event(server) >= 0);
	50	assert_se(!sd_dhcp_server_get_event(server));
	51	assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
	52	assert_se(sd_dhcp_server_attach_event(server, NULL, 0) == -EBUSY);
	53
	54	assert_se(sd_dhcp_server_ref(server) == server);
	55	assert_se(!sd_dhcp_server_unref(server));
ff734080	56
20af7091 TG	57	assert_se(sd_dhcp_server_start(server) == -EUNATCH);
	58	assert_se(sd_dhcp_server_set_address(server, &address_any) == -EINVAL);
	59	assert_se(sd_dhcp_server_set_address(server, &address_lo) >= 0);
	60	assert_se(sd_dhcp_server_set_address(server, &address_lo) == -EBUSY);
	61
2dead812 TG	62	assert_se(sd_dhcp_server_set_lease_pool(server, &address_any, 1) == -EINVAL);
	63	assert_se(sd_dhcp_server_set_lease_pool(server, &address_lo, 0) == -EINVAL);
	64	assert_se(sd_dhcp_server_set_lease_pool(server, &address_lo, 1) >= 0);
	65	assert_se(sd_dhcp_server_set_lease_pool(server, &address_lo, 1) == -EBUSY);
	66
ff734080 TG	67	assert_se(sd_dhcp_server_start(server) >= 0);
	68	assert_se(sd_dhcp_server_start(server) == -EBUSY);
	69	assert_se(sd_dhcp_server_stop(server) >= 0);
	70	assert_se(sd_dhcp_server_stop(server) >= 0);
	71	assert_se(sd_dhcp_server_start(server) >= 0);
b44cd882 TG	72	}
b44cd882 TG	73
be077570 TG	74	static void test_message_handler(void) {
	75	_cleanup_dhcp_server_unref_ sd_dhcp_server *server = NULL;
	76	struct {
	77	DHCPMessage message;
	78	struct {
	79	uint8_t code;
	80	uint8_t length;
	81	uint8_t type;
	82	} _packed_ option_type;
2dead812 TG	83	struct {
	84	uint8_t code;
	85	uint8_t length;
	86	be32_t address;
	87	} _packed_ option_requested_ip;
	88	struct {
	89	uint8_t code;
	90	uint8_t length;
	91	be32_t address;
	92	} _packed_ option_server_id;
be077570 TG	93	uint8_t end;
	94	} _packed_ test = {
	95	.message.op = BOOTREQUEST,
	96	.message.htype = ARPHRD_ETHER,
	97	.message.hlen = ETHER_ADDR_LEN,
2dead812 TG	98	.message.xid = htobe32(0x12345678),
2dead812 TG	99	.message.chaddr = { 'A', 'B', 'C', 'D', 'E', 'F' },
be077570 TG	100	.option_type.code = DHCP_OPTION_MESSAGE_TYPE,
	101	.option_type.length = 1,
	102	.option_type.type = DHCP_DISCOVER,
	103	.end = DHCP_OPTION_END,
	104	};
20af7091 TG	105	struct in_addr address_lo = {
	106	.s_addr = htonl(INADDR_LOOPBACK),
	107	};
be077570 TG	108
be077570 TG	109	assert_se(sd_dhcp_server_new(&server, 1) >= 0);
20af7091 TG	110	assert_se(sd_dhcp_server_set_address(server, &address_lo) >= 0);
	111	assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
	112	assert_se(sd_dhcp_server_start(server) >= 0);
be077570	113
2dead812 TG	114	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
2dead812 TG	115	assert_se(sd_dhcp_server_set_lease_pool(server, &address_lo, 10) >= 0);
4dc35568	116	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
be077570 TG	117
	118	test.end = 0;
	119	/* TODO, shouldn't this fail? */
4dc35568	120	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
be077570	121	test.end = DHCP_OPTION_END;
4dc35568	122	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
be077570 TG	123
	124	test.option_type.code = 0;
	125	test.option_type.length = 0;
	126	test.option_type.type = 0;
	127	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
	128	test.option_type.code = DHCP_OPTION_MESSAGE_TYPE;
	129	test.option_type.length = 1;
	130	test.option_type.type = DHCP_DISCOVER;
4dc35568	131	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
be077570 TG	132
	133	test.message.op = 0;
	134	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
	135	test.message.op = BOOTREQUEST;
4dc35568	136	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
be077570 TG	137
	138	test.message.htype = 0;
	139	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
	140	test.message.htype = ARPHRD_ETHER;
4dc35568	141	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
be077570 TG	142
	143	test.message.hlen = 0;
	144	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
	145	test.message.hlen = ETHER_ADDR_LEN;
4dc35568	146	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
2dead812 TG	147
	148	test.option_type.type = DHCP_REQUEST;
	149	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
	150	test.option_requested_ip.code = DHCP_OPTION_REQUESTED_IP_ADDRESS;
	151	test.option_requested_ip.length = 4;
	152	test.option_requested_ip.address = htobe32(0x12345678);
bd57b450	153	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_NAK);
2dead812 TG	154	test.option_server_id.code = DHCP_OPTION_SERVER_IDENTIFIER;
	155	test.option_server_id.length = 4;
	156	test.option_server_id.address = htobe32(INADDR_LOOPBACK);
	157	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
	158	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
	159	test.option_server_id.address = htobe32(0x12345678);
	160	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
	161	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
bd57b450 TG	162	test.option_server_id.address = htobe32(INADDR_LOOPBACK);
bd57b450 TG	163	test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 30);
2dead812	164	assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
be077570 TG	165	}
be077570 TG	166
b44cd882 TG	167	int main(int argc, char *argv[]) {
	168	_cleanup_event_unref_ sd_event *e;
	169
	170	log_set_max_level(LOG_DEBUG);
	171	log_parse_environment();
	172	log_open();
	173
	174	assert_se(sd_event_new(&e) >= 0);
	175
	176	test_basic(e);
be077570	177	test_message_handler();
b44cd882 TG	178
	179	return 0;
	180	}