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

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

/***
  This file is part of systemd.

  Copyright 2013 Tom Gundersen <teg@jklm.no>

  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 "networkd.h"
#include "network-internal.h"
#include "dhcp-lease-internal.h"

static void test_deserialize_in_addr(void) {
        _cleanup_free_ struct in_addr *addresses = NULL;
        _cleanup_free_ struct in6_addr *addresses6 = NULL;
        struct in_addr  a, b, c;
        struct in6_addr d, e, f;
        size_t size;
        const char *addresses_string = "192.168.0.1 0:0:0:0:0:FFFF:204.152.189.116 192.168.0.2 ::1 192.168.0.3 1:0:0:0:0:0:0:8";

        assert_se(inet_pton(AF_INET, "0:0:0:0:0:FFFF:204.152.189.116", &a) == 0);
        assert_se(inet_pton(AF_INET6, "192.168.0.1", &d) == 0);

        assert_se(inet_pton(AF_INET, "192.168.0.1", &a) == 1);
        assert_se(inet_pton(AF_INET, "192.168.0.2", &b) == 1);
        assert_se(inet_pton(AF_INET, "192.168.0.3", &c) == 1);
        assert_se(inet_pton(AF_INET6, "0:0:0:0:0:FFFF:204.152.189.116", &d) == 1);
        assert_se(inet_pton(AF_INET6, "::1", &e) == 1);
        assert_se(inet_pton(AF_INET6, "1:0:0:0:0:0:0:8", &f) == 1);

        assert_se(deserialize_in_addrs(&addresses, &size, addresses_string) >= 0);
        assert_se(size == 3);
        assert_se(!memcmp(&a, &addresses[0], sizeof(struct in_addr)));
        assert_se(!memcmp(&b, &addresses[1], sizeof(struct in_addr)));
        assert_se(!memcmp(&c, &addresses[2], sizeof(struct in_addr)));

        assert_se(deserialize_in6_addrs(&addresses6, &size, addresses_string) >= 0);
        assert_se(size == 3);
        assert_se(!memcmp(&d, &addresses6[0], sizeof(struct in6_addr)));
        assert_se(!memcmp(&e, &addresses6[1], sizeof(struct in6_addr)));
        assert_se(!memcmp(&f, &addresses6[2], sizeof(struct in6_addr)));
}

static void test_deserialize_dhcp_routes(void) {
        size_t size, allocated;

        {
                _cleanup_free_ struct sd_dhcp_route *routes = NULL;
                assert_se(deserialize_dhcp_routes(&routes, &size, &allocated, "") >= 0);
                assert_se(size == 0);
        }

        {
                /* no errors */
                _cleanup_free_ struct sd_dhcp_route *routes = NULL;
                const char *routes_string = "192.168.0.0/16,192.168.0.1 10.1.2.0/24,10.1.2.1 0.0.0.0/0,10.0.1.1";

                assert_se(deserialize_dhcp_routes(&routes, &size, &allocated, routes_string) >= 0);

                assert_se(size == 3);
                assert_se(routes[0].dst_addr.s_addr == inet_addr("192.168.0.0"));
                assert_se(routes[0].gw_addr.s_addr == inet_addr("192.168.0.1"));
                assert_se(routes[0].dst_prefixlen == 16);

                assert_se(routes[1].dst_addr.s_addr == inet_addr("10.1.2.0"));
                assert_se(routes[1].gw_addr.s_addr == inet_addr("10.1.2.1"));
                assert_se(routes[1].dst_prefixlen == 24);

                assert_se(routes[2].dst_addr.s_addr == inet_addr("0.0.0.0"));
                assert_se(routes[2].gw_addr.s_addr == inet_addr("10.0.1.1"));
                assert_se(routes[2].dst_prefixlen == 0);
        }

        {
                /* error in second word */
                _cleanup_free_ struct sd_dhcp_route *routes = NULL;
                const char *routes_string = "192.168.0.0/16,192.168.0.1 10.1.2.0#24,10.1.2.1 0.0.0.0/0,10.0.1.1";

                assert_se(deserialize_dhcp_routes(&routes, &size, &allocated, routes_string) >= 0);

                assert_se(size == 2);
                assert_se(routes[0].dst_addr.s_addr == inet_addr("192.168.0.0"));
                assert_se(routes[0].gw_addr.s_addr == inet_addr("192.168.0.1"));
                assert_se(routes[0].dst_prefixlen == 16);

                assert_se(routes[2].dst_addr.s_addr == inet_addr("0.0.0.0"));
                assert_se(routes[2].gw_addr.s_addr == inet_addr("10.0.1.1"));
                assert_se(routes[2].dst_prefixlen == 0);
        }

        {
                /* error in every word */
                _cleanup_free_ struct sd_dhcp_route *routes = NULL;
                const char *routes_string = "192.168.0.0/55,192.168.0.1 10.1.2.0#24,10.1.2.1 0.0.0.0/0,10.0.1.X";

                assert_se(deserialize_dhcp_routes(&routes, &size, &allocated, routes_string) >= 0);
                assert_se(size == 0);
        }
}

static void test_load_config(Manager *manager) {
/*  TODO: should_reload, is false if the config dirs do not exist, so
 *        so we can't do this test here, move it to a test for paths_check_timestamps
 *        directly
 *
 *        assert_se(network_should_reload(manager) == true);
*/
        assert_se(manager_load_config(manager) >= 0);
        assert_se(manager_should_reload(manager) == false);
}

static void test_network_get(Manager *manager, struct udev_device *loopback) {
        Network *network;
        const struct ether_addr mac = {};

        /* let's assume that the test machine does not have a .network file
           that applies to the loopback device... */
        assert_se(network_get(manager, loopback, "lo", &mac, &network) == -ENOENT);
        assert_se(!network);
}

static void test_address_equality(void) {
        _cleanup_address_free_ Address *a1 = NULL, *a2 = NULL;

        assert_se(address_new_dynamic(&a1) >= 0);
        assert_se(address_new_dynamic(&a2) >= 0);

        assert_se(address_equal(NULL, NULL));
        assert_se(!address_equal(a1, NULL));
        assert_se(!address_equal(NULL, a2));
        assert_se(address_equal(a1, a2));

        a1->family = AF_INET;
        assert_se(!address_equal(a1, a2));

        a2->family = AF_INET;
        assert_se(address_equal(a1, a2));

        assert_se(inet_pton(AF_INET, "192.168.3.9", &a1->in_addr.in));
        assert_se(!address_equal(a1, a2));
        assert_se(inet_pton(AF_INET, "192.168.3.9", &a2->in_addr.in));
        assert_se(address_equal(a1, a2));

        a1->prefixlen = 10;
        assert_se(!address_equal(a1, a2));
        a2->prefixlen = 10;
        assert_se(address_equal(a1, a2));

        assert_se(inet_pton(AF_INET, "192.168.3.10", &a2->in_addr.in));
        assert_se(address_equal(a1, a2));

        a1->family = AF_INET6;
        assert_se(!address_equal(a1, a2));

        a2->family = AF_INET6;
        assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::2", &a1->in_addr.in6));
        assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::2", &a2->in_addr.in6));
        assert_se(address_equal(a1, a2));

        a2->prefixlen = 8;
        assert_se(address_equal(a1, a2));

        assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::1", &a2->in_addr.in6));
        assert_se(!address_equal(a1, a2));
}

int main(void) {
        _cleanup_manager_free_ Manager *manager = NULL;
        struct udev *udev;
        struct udev_device *loopback;

        test_deserialize_in_addr();
        test_deserialize_dhcp_routes();
        test_address_equality();

        assert_se(manager_new(&manager) >= 0);

        test_load_config(manager);

        udev = udev_new();
        assert_se(udev);

        loopback = udev_device_new_from_syspath(udev, "/sys/class/net/lo");
        assert_se(loopback);
        assert_se(udev_device_get_ifindex(loopback) == 1);

        test_network_get(manager, loopback);

        assert_se(manager_udev_listen(manager) >= 0);
        assert_se(manager_rtnl_listen(manager) >= 0);
        assert_se(manager_rtnl_enumerate_links(manager) >= 0);

        udev_device_unref(loopback);
        udev_unref(udev);
}
Commit	Line	Data
f579559b TG	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Tom Gundersen <teg@jklm.no>
	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 "networkd.h"
09bee74d	23	#include "network-internal.h"
e1ea665e	24	#include "dhcp-lease-internal.h"
09bee74d TG	25
	26	static void test_deserialize_in_addr(void) {
	27	_cleanup_free_ struct in_addr *addresses = NULL;
	28	_cleanup_free_ struct in6_addr *addresses6 = NULL;
	29	struct in_addr a, b, c;
	30	struct in6_addr d, e, f;
	31	size_t size;
	32	const char *addresses_string = "192.168.0.1 0:0:0:0:0:FFFF:204.152.189.116 192.168.0.2 ::1 192.168.0.3 1:0:0:0:0:0:0:8";
	33
	34	assert_se(inet_pton(AF_INET, "0:0:0:0:0:FFFF:204.152.189.116", &a) == 0);
	35	assert_se(inet_pton(AF_INET6, "192.168.0.1", &d) == 0);
	36
	37	assert_se(inet_pton(AF_INET, "192.168.0.1", &a) == 1);
	38	assert_se(inet_pton(AF_INET, "192.168.0.2", &b) == 1);
	39	assert_se(inet_pton(AF_INET, "192.168.0.3", &c) == 1);
	40	assert_se(inet_pton(AF_INET6, "0:0:0:0:0:FFFF:204.152.189.116", &d) == 1);
	41	assert_se(inet_pton(AF_INET6, "::1", &e) == 1);
	42	assert_se(inet_pton(AF_INET6, "1:0:0:0:0:0:0:8", &f) == 1);
	43
	44	assert_se(deserialize_in_addrs(&addresses, &size, addresses_string) >= 0);
	45	assert_se(size == 3);
	46	assert_se(!memcmp(&a, &addresses[0], sizeof(struct in_addr)));
	47	assert_se(!memcmp(&b, &addresses[1], sizeof(struct in_addr)));
	48	assert_se(!memcmp(&c, &addresses[2], sizeof(struct in_addr)));
	49
	50	assert_se(deserialize_in6_addrs(&addresses6, &size, addresses_string) >= 0);
	51	assert_se(size == 3);
	52	assert_se(!memcmp(&d, &addresses6[0], sizeof(struct in6_addr)));
	53	assert_se(!memcmp(&e, &addresses6[1], sizeof(struct in6_addr)));
	54	assert_se(!memcmp(&f, &addresses6[2], sizeof(struct in6_addr)));
	55	}
f579559b	56
e1ea665e EY	57	static void test_deserialize_dhcp_routes(void) {
	58	size_t size, allocated;
	59
	60	{
	61	_cleanup_free_ struct sd_dhcp_route *routes = NULL;
	62	assert_se(deserialize_dhcp_routes(&routes, &size, &allocated, "") >= 0);
	63	assert_se(size == 0);
	64	}
	65
	66	{
	67	/* no errors */
	68	_cleanup_free_ struct sd_dhcp_route *routes = NULL;
	69	const char *routes_string = "192.168.0.0/16,192.168.0.1 10.1.2.0/24,10.1.2.1 0.0.0.0/0,10.0.1.1";
	70
	71	assert_se(deserialize_dhcp_routes(&routes, &size, &allocated, routes_string) >= 0);
	72
	73	assert_se(size == 3);
	74	assert_se(routes[0].dst_addr.s_addr == inet_addr("192.168.0.0"));
	75	assert_se(routes[0].gw_addr.s_addr == inet_addr("192.168.0.1"));
	76	assert_se(routes[0].dst_prefixlen == 16);
	77
	78	assert_se(routes[1].dst_addr.s_addr == inet_addr("10.1.2.0"));
	79	assert_se(routes[1].gw_addr.s_addr == inet_addr("10.1.2.1"));
	80	assert_se(routes[1].dst_prefixlen == 24);
	81
	82	assert_se(routes[2].dst_addr.s_addr == inet_addr("0.0.0.0"));
	83	assert_se(routes[2].gw_addr.s_addr == inet_addr("10.0.1.1"));
	84	assert_se(routes[2].dst_prefixlen == 0);
	85	}
	86
	87	{
	88	/* error in second word */
	89	_cleanup_free_ struct sd_dhcp_route *routes = NULL;
	90	const char *routes_string = "192.168.0.0/16,192.168.0.1 10.1.2.0#24,10.1.2.1 0.0.0.0/0,10.0.1.1";
	91
	92	assert_se(deserialize_dhcp_routes(&routes, &size, &allocated, routes_string) >= 0);
	93
	94	assert_se(size == 2);
	95	assert_se(routes[0].dst_addr.s_addr == inet_addr("192.168.0.0"));
	96	assert_se(routes[0].gw_addr.s_addr == inet_addr("192.168.0.1"));
	97	assert_se(routes[0].dst_prefixlen == 16);
	98
	99	assert_se(routes[2].dst_addr.s_addr == inet_addr("0.0.0.0"));
	100	assert_se(routes[2].gw_addr.s_addr == inet_addr("10.0.1.1"));
	101	assert_se(routes[2].dst_prefixlen == 0);
	102	}
	103
	104	{
	105	/* error in every word */
	106	_cleanup_free_ struct sd_dhcp_route *routes = NULL;
	107	const char *routes_string = "192.168.0.0/55,192.168.0.1 10.1.2.0#24,10.1.2.1 0.0.0.0/0,10.0.1.X";
	108
	109	assert_se(deserialize_dhcp_routes(&routes, &size, &allocated, routes_string) >= 0);
	110	assert_se(size == 0);
	111	}
	112	}
	113
02b59d57	114	static void test_load_config(Manager *manager) {
7c99d940 TG	115	/* TODO: should_reload, is false if the config dirs do not exist, so
	116	* so we can't do this test here, move it to a test for paths_check_timestamps
	117	* directly
	118	*
12e0f830	119	* assert_se(network_should_reload(manager) == true);
7c99d940	120	*/
12e0f830 TG	121	assert_se(manager_load_config(manager) >= 0);
12e0f830 TG	122	assert_se(manager_should_reload(manager) == false);
f579559b TG	123	}
	124
	125	static void test_network_get(Manager manager, struct udev_device loopback) {
	126	Network *network;
505f8da7	127	const struct ether_addr mac = {};
f579559b TG	128
	129	/* let's assume that the test machine does not have a .network file
	130	that applies to the loopback device... */
505f8da7	131	assert_se(network_get(manager, loopback, "lo", &mac, &network) == -ENOENT);
12e0f830	132	assert_se(!network);
f579559b TG	133	}
f579559b TG	134
9505d3c6	135	static void test_address_equality(void) {
09bee74d	136	_cleanup_address_free_ Address a1 = NULL, a2 = NULL;
9505d3c6 TG	137
	138	assert_se(address_new_dynamic(&a1) >= 0);
	139	assert_se(address_new_dynamic(&a2) >= 0);
	140
	141	assert_se(address_equal(NULL, NULL));
	142	assert_se(!address_equal(a1, NULL));
	143	assert_se(!address_equal(NULL, a2));
	144	assert_se(address_equal(a1, a2));
	145
	146	a1->family = AF_INET;
	147	assert_se(!address_equal(a1, a2));
	148
	149	a2->family = AF_INET;
	150	assert_se(address_equal(a1, a2));
	151
	152	assert_se(inet_pton(AF_INET, "192.168.3.9", &a1->in_addr.in));
	153	assert_se(!address_equal(a1, a2));
	154	assert_se(inet_pton(AF_INET, "192.168.3.9", &a2->in_addr.in));
	155	assert_se(address_equal(a1, a2));
	156
	157	a1->prefixlen = 10;
	158	assert_se(!address_equal(a1, a2));
	159	a2->prefixlen = 10;
	160	assert_se(address_equal(a1, a2));
	161
	162	assert_se(inet_pton(AF_INET, "192.168.3.10", &a2->in_addr.in));
	163	assert_se(address_equal(a1, a2));
	164
	165	a1->family = AF_INET6;
	166	assert_se(!address_equal(a1, a2));
	167
	168	a2->family = AF_INET6;
	169	assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::2", &a1->in_addr.in6));
	170	assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::2", &a2->in_addr.in6));
	171	assert_se(address_equal(a1, a2));
	172
	173	a2->prefixlen = 8;
	174	assert_se(address_equal(a1, a2));
	175
	176	assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::1", &a2->in_addr.in6));
	177	assert_se(!address_equal(a1, a2));
	178	}
	179
f579559b TG	180	int main(void) {
	181	_cleanup_manager_free_ Manager *manager = NULL;
	182	struct udev *udev;
	183	struct udev_device *loopback;
	184
09bee74d	185	test_deserialize_in_addr();
e1ea665e	186	test_deserialize_dhcp_routes();
9505d3c6 TG	187	test_address_equality();
9505d3c6 TG	188
12e0f830	189	assert_se(manager_new(&manager) >= 0);
f579559b	190
02b59d57	191	test_load_config(manager);
f579559b TG	192
f579559b TG	193	udev = udev_new();
12e0f830	194	assert_se(udev);
f579559b TG	195
f579559b TG	196	loopback = udev_device_new_from_syspath(udev, "/sys/class/net/lo");
12e0f830 TG	197	assert_se(loopback);
12e0f830 TG	198	assert_se(udev_device_get_ifindex(loopback) == 1);
f579559b TG	199
	200	test_network_get(manager, loopback);
	201
12e0f830	202	assert_se(manager_udev_listen(manager) >= 0);
12e0f830	203	assert_se(manager_rtnl_listen(manager) >= 0);
505f8da7	204	assert_se(manager_rtnl_enumerate_links(manager) >= 0);
f579559b TG	205
	206	udev_device_unref(loopback);
	207	udev_unref(udev);
	208	}