[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 "alloc-util.h"
#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;
        int 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((size = deserialize_in_addrs(&addresses, 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((size = deserialize_in6_addrs(&addresses6, 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[1].dst_addr.s_addr == inet_addr("0.0.0.0"));
                assert_se(routes[1].gw_addr.s_addr == inet_addr("10.0.1.1"));
                assert_se(routes[1].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 int test_load_config(Manager *manager) {
        int r;
/*  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);
*/

        r = manager_load_config(manager);
        if (r == -EPERM)
                return r;
        assert_se(r >= 0);

        assert_se(manager_should_reload(manager) == false);

        return 0;
}

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(&a1) >= 0);
        assert_se(address_new(&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));
        assert_se(inet_pton(AF_INET, "192.168.3.10", &a1->in_addr_peer.in));
        assert_se(address_equal(a1, a2));
        assert_se(inet_pton(AF_INET, "192.168.3.11", &a2->in_addr_peer.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));

        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;
        int r;

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

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

        r = test_load_config(manager);
        if (r == -EPERM)
                return EXIT_TEST_SKIP;

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