src/network/test-network.c

   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 "alloc-util.h"
  23 #include "dhcp-lease-internal.h"
  24 #include "network-internal.h"
  25 #include "networkd.h"
  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;
  32         int size;
  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
  45         assert_se((size = deserialize_in_addrs(&addresses, addresses_string)) >= 0);
  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
  51         assert_se((size = deserialize_in6_addrs(&addresses6, addresses_string)) >= 0);
  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 }
  57
  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
 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);
 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
 115 static int test_load_config(Manager *manager) {
 116         int r;
 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  *
 121  *        assert_se(network_should_reload(manager) == true);
 122 */
 123
 124         r = manager_load_config(manager);
 125         if (r == -EPERM)
 126                 return r;
 127         assert_se(r >= 0);
 128
 129         assert_se(manager_should_reload(manager) == false);
 130
 131         return 0;
 132 }
 133
 134 static void test_network_get(Manager *manager, struct udev_device *loopback) {
 135         Network *network;
 136         const struct ether_addr mac = {};
 137
 138         /* let's assume that the test machine does not have a .network file
 139            that applies to the loopback device... */
 140         assert_se(network_get(manager, loopback, "lo", &mac, &network) == -ENOENT);
 141         assert_se(!network);
 142 }
 143
 144 static void test_address_equality(void) {
 145         _cleanup_address_free_ Address *a1 = NULL, *a2 = NULL;
 146
 147         assert_se(address_new(&a1) >= 0);
 148         assert_se(address_new(&a2) >= 0);
 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));
 162         assert_se(!address_equal(a1, a2));
 163         assert_se(inet_pton(AF_INET, "192.168.3.9", &a2->in_addr.in));
 164         assert_se(address_equal(a1, a2));
 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));
 169         a1->prefixlen = 10;
 170         assert_se(!address_equal(a1, a2));
 171         a2->prefixlen = 10;
 172         assert_se(address_equal(a1, a2));
 173
 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
 189 int main(void) {
 190         _cleanup_manager_free_ Manager *manager = NULL;
 191         struct udev *udev;
 192         struct udev_device *loopback;
 193         int r;
 194
 195         test_deserialize_in_addr();
 196         test_deserialize_dhcp_routes();
 197         test_address_equality();
 198
 199         assert_se(manager_new(&manager) >= 0);
 200
 201         r = test_load_config(manager);
 202         if (r == -EPERM)
 203                 return EXIT_TEST_SKIP;
 204
 205         udev = udev_new();
 206         assert_se(udev);
 207
 208         loopback = udev_device_new_from_syspath(udev, "/sys/class/net/lo");
 209         assert_se(loopback);
 210         assert_se(udev_device_get_ifindex(loopback) == 1);
 211
 212         test_network_get(manager, loopback);
 213
 214         assert_se(manager_rtnl_enumerate_links(manager) >= 0);
 215
 216         udev_device_unref(loopback);
 217         udev_unref(udev);
 218 }