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

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  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 "dhcp-lease-internal.h"
#include "network-internal.h"
#include "networkd-manager.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;
        sd_event *event;
        struct udev *udev;
        struct udev_device *loopback;
        int r;

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

        r = sd_event_default(&event);
        assert_se(r >= 0);

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

        r = test_load_config(manager);
        if (r == -EPERM) {
                sd_event_unref(event);
                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);
        sd_event_unref(event);
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
f579559b TG	2	/***
	3	This file is part of systemd.
	4
	5	Copyright 2013 Tom Gundersen <teg@jklm.no>
	6
	7	systemd is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU Lesser General Public License as published by
	9	the Free Software Foundation; either version 2.1 of the License, or
	10	(at your option) any later version.
	11
	12	systemd is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Lesser General Public License for more details.
	16
	17	You should have received a copy of the GNU Lesser General Public License
	18	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	19	***/
	20
b5efdb8a	21	#include "alloc-util.h"
e1ea665e	22	#include "dhcp-lease-internal.h"
cf0fbc49	23	#include "network-internal.h"
23f53b99	24	#include "networkd-manager.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;
a2ba62c7	31	int size;
09bee74d TG	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
a2ba62c7	44	assert_se((size = deserialize_in_addrs(&addresses, addresses_string)) >= 0);
09bee74d TG	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
a2ba62c7	50	assert_se((size = deserialize_in6_addrs(&addresses6, addresses_string)) >= 0);
09bee74d TG	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
5bb14c86 TG	99	assert_se(routes[1].dst_addr.s_addr == inet_addr("0.0.0.0"));
	100	assert_se(routes[1].gw_addr.s_addr == inet_addr("10.0.1.1"));
	101	assert_se(routes[1].dst_prefixlen == 0);
e1ea665e EY	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
5347925a TG	114	static int test_load_config(Manager *manager) {
5347925a TG	115	int r;
7c99d940 TG	116	/* TODO: should_reload, is false if the config dirs do not exist, so
	117	* so we can't do this test here, move it to a test for paths_check_timestamps
	118	* directly
	119	*
12e0f830	120	* assert_se(network_should_reload(manager) == true);
7c99d940	121	*/
5347925a TG	122
	123	r = manager_load_config(manager);
	124	if (r == -EPERM)
	125	return r;
	126	assert_se(r >= 0);
	127
12e0f830	128	assert_se(manager_should_reload(manager) == false);
5347925a TG	129
5347925a TG	130	return 0;
f579559b TG	131	}
	132
	133	static void test_network_get(Manager manager, struct udev_device loopback) {
	134	Network *network;
505f8da7	135	const struct ether_addr mac = {};
f579559b TG	136
	137	/* let's assume that the test machine does not have a .network file
	138	that applies to the loopback device... */
505f8da7	139	assert_se(network_get(manager, loopback, "lo", &mac, &network) == -ENOENT);
12e0f830	140	assert_se(!network);
f579559b TG	141	}
f579559b TG	142
9505d3c6	143	static void test_address_equality(void) {
09bee74d	144	_cleanup_address_free_ Address a1 = NULL, a2 = NULL;
9505d3c6	145
f0213e37 TG	146	assert_se(address_new(&a1) >= 0);
f0213e37 TG	147	assert_se(address_new(&a2) >= 0);
9505d3c6 TG	148
	149	assert_se(address_equal(NULL, NULL));
	150	assert_se(!address_equal(a1, NULL));
	151	assert_se(!address_equal(NULL, a2));
	152	assert_se(address_equal(a1, a2));
	153
	154	a1->family = AF_INET;
	155	assert_se(!address_equal(a1, a2));
	156
	157	a2->family = AF_INET;
	158	assert_se(address_equal(a1, a2));
	159
	160	assert_se(inet_pton(AF_INET, "192.168.3.9", &a1->in_addr.in));
3ac8e543	161	assert_se(!address_equal(a1, a2));
9505d3c6 TG	162	assert_se(inet_pton(AF_INET, "192.168.3.9", &a2->in_addr.in));
9505d3c6 TG	163	assert_se(address_equal(a1, a2));
3ac8e543 TG	164	assert_se(inet_pton(AF_INET, "192.168.3.10", &a1->in_addr_peer.in));
	165	assert_se(address_equal(a1, a2));
	166	assert_se(inet_pton(AF_INET, "192.168.3.11", &a2->in_addr_peer.in));
	167	assert_se(address_equal(a1, a2));
9505d3c6 TG	168	a1->prefixlen = 10;
	169	assert_se(!address_equal(a1, a2));
	170	a2->prefixlen = 10;
	171	assert_se(address_equal(a1, a2));
	172
9505d3c6 TG	173	a1->family = AF_INET6;
	174	assert_se(!address_equal(a1, a2));
	175
	176	a2->family = AF_INET6;
	177	assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::2", &a1->in_addr.in6));
	178	assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::2", &a2->in_addr.in6));
	179	assert_se(address_equal(a1, a2));
	180
	181	a2->prefixlen = 8;
	182	assert_se(address_equal(a1, a2));
	183
	184	assert_se(inet_pton(AF_INET6, "2001:4ca0:4f01::1", &a2->in_addr.in6));
	185	assert_se(!address_equal(a1, a2));
	186	}
	187
f579559b TG	188	int main(void) {
f579559b TG	189	_cleanup_manager_free_ Manager *manager = NULL;
b76d99d9	190	sd_event *event;
f579559b TG	191	struct udev *udev;
f579559b TG	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
b76d99d9 TG	199	r = sd_event_default(&event);
	200	assert_se(r >= 0);
	201
	202	assert_se(manager_new(&manager, event) >= 0);
f579559b	203
5347925a	204	r = test_load_config(manager);
b76d99d9 TG	205	if (r == -EPERM) {
b76d99d9 TG	206	sd_event_unref(event);
5347925a	207	return EXIT_TEST_SKIP;
b76d99d9	208	}
f579559b TG	209
f579559b TG	210	udev = udev_new();
12e0f830	211	assert_se(udev);
f579559b TG	212
f579559b TG	213	loopback = udev_device_new_from_syspath(udev, "/sys/class/net/lo");
12e0f830 TG	214	assert_se(loopback);
12e0f830 TG	215	assert_se(udev_device_get_ifindex(loopback) == 1);
f579559b TG	216
	217	test_network_get(manager, loopback);
	218
505f8da7	219	assert_se(manager_rtnl_enumerate_links(manager) >= 0);
f579559b TG	220
	221	udev_device_unref(loopback);
	222	udev_unref(udev);
b76d99d9	223	sd_event_unref(event);
f579559b	224	}