src/udev/net/link-config.c

   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 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 <netinet/ether.h>
  23 #include <net/if.h>
  24
  25 #include "sd-id128.h"
  26
  27 #include "link-config.h"
  28 #include "ethtool-util.h"
  29
  30 #include "libudev-private.h"
  31 #include "sd-rtnl.h"
  32 #include "util.h"
  33 #include "log.h"
  34 #include "strv.h"
  35 #include "path-util.h"
  36 #include "conf-parser.h"
  37 #include "conf-files.h"
  38 #include "fileio.h"
  39 #include "hashmap.h"
  40 #include "rtnl-util.h"
  41 #include "network-internal.h"
  42 #include "siphash24.h"
  43
  44 struct link_config_ctx {
  45         LIST_HEAD(link_config, links);
  46
  47         int ethtool_fd;
  48
  49         bool enable_name_policy;
  50
  51         sd_rtnl *rtnl;
  52
  53         usec_t link_dirs_ts_usec;
  54 };
  55
  56 static const char* const link_dirs[] = {
  57         "/etc/systemd/network",
  58         "/run/systemd/network",
  59         "/usr/lib/systemd/network",
  60 #ifdef HAVE_SPLIT_USR
  61         "/lib/systemd/network",
  62 #endif
  63         NULL};
  64
  65 DEFINE_TRIVIAL_CLEANUP_FUNC(link_config_ctx*, link_config_ctx_free);
  66 #define _cleanup_link_config_ctx_free_ _cleanup_(link_config_ctx_freep)
  67
  68 int link_config_ctx_new(link_config_ctx **ret) {
  69         _cleanup_link_config_ctx_free_ link_config_ctx *ctx = NULL;
  70
  71         if (!ret)
  72                 return -EINVAL;
  73
  74         ctx = new0(link_config_ctx, 1);
  75         if (!ctx)
  76                 return -ENOMEM;
  77
  78         LIST_HEAD_INIT(ctx->links);
  79
  80         ctx->ethtool_fd = -1;
  81
  82         ctx->enable_name_policy = true;
  83
  84         *ret = ctx;
  85         ctx = NULL;
  86
  87         return 0;
  88 }
  89
  90 static int link_config_ctx_connect(link_config_ctx *ctx) {
  91         int r;
  92
  93         if (ctx->ethtool_fd == -1) {
  94                 r = ethtool_connect(&ctx->ethtool_fd);
  95                 if (r < 0)
  96                         return r;
  97         }
  98
  99         if (!ctx->rtnl) {
 100                 r = sd_rtnl_open(&ctx->rtnl, 0);
 101                 if (r < 0)
 102                         return r;
 103         }
 104
 105         return 0;
 106 }
 107
 108 static void link_configs_free(link_config_ctx *ctx) {
 109         link_config *link, *link_next;
 110
 111         if (!ctx)
 112                 return;
 113
 114         LIST_FOREACH_SAFE(links, link, link_next, ctx->links) {
 115                 free(link->filename);
 116                 free(link->match_path);
 117                 free(link->match_driver);
 118                 free(link->match_type);
 119                 free(link->description);
 120                 free(link->alias);
 121                 free(link->name_policy);
 122
 123                 free(link);
 124         }
 125 }
 126
 127 void link_config_ctx_free(link_config_ctx *ctx) {
 128         if (!ctx)
 129                 return;
 130
 131         safe_close(ctx->ethtool_fd);
 132
 133         sd_rtnl_unref(ctx->rtnl);
 134
 135         link_configs_free(ctx);
 136
 137         free(ctx);
 138
 139         return;
 140 }
 141
 142 static int load_link(link_config_ctx *ctx, const char *filename) {
 143         _cleanup_free_ link_config *link = NULL;
 144         _cleanup_fclose_ FILE *file = NULL;
 145         int r;
 146
 147         assert(ctx);
 148         assert(filename);
 149
 150         if (null_or_empty_path(filename)) {
 151                 log_debug("skipping empty file: %s", filename);
 152                 return 0;
 153         }
 154
 155         file = fopen(filename, "re");
 156         if (!file) {
 157                 if (errno == ENOENT)
 158                         return 0;
 159                 else
 160                         return -errno;
 161         }
 162
 163         link = new0(link_config, 1);
 164         if (!link)
 165                 return log_oom();
 166
 167         link->mac_policy = _MACPOLICY_INVALID;
 168         link->wol = _WOL_INVALID;
 169         link->duplex = _DUP_INVALID;
 170
 171         r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
 172                          (void*) link_config_gperf_lookup, false, false, link);
 173         if (r < 0) {
 174                 log_warning("Could not parse config file %s: %s", filename, strerror(-r));
 175                 return r;
 176         } else
 177                 log_debug("Parsed configuration file %s", filename);
 178
 179         link->filename = strdup(filename);
 180
 181         LIST_PREPEND(links, ctx->links, link);
 182         link = NULL;
 183
 184         return 0;
 185 }
 186
 187 static bool enable_name_policy(void) {
 188         _cleanup_free_ char *line;
 189         char *w, *state;
 190         int r;
 191         size_t l;
 192
 193         r = proc_cmdline(&line);
 194         if (r < 0)
 195                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
 196         if (r <= 0)
 197                 return true;
 198
 199         FOREACH_WORD_QUOTED(w, l, line, state)
 200                 if (strneq(w, "net.ifnames=0", l))
 201                         return false;
 202
 203         return true;
 204 }
 205
 206 int link_config_load(link_config_ctx *ctx) {
 207         int r;
 208         _cleanup_strv_free_ char **files;
 209         char **f;
 210
 211         link_configs_free(ctx);
 212
 213         if (!enable_name_policy()) {
 214                 ctx->enable_name_policy = false;
 215                 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
 216         }
 217
 218         /* update timestamp */
 219         paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
 220
 221         r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
 222         if (r < 0) {
 223                 log_error("failed to enumerate link files: %s", strerror(-r));
 224                 return r;
 225         }
 226
 227         STRV_FOREACH_BACKWARDS(f, files) {
 228                 r = load_link(ctx, *f);
 229                 if (r < 0)
 230                         return r;
 231         }
 232
 233         return 0;
 234 }
 235
 236 bool link_config_should_reload(link_config_ctx *ctx) {
 237         return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
 238 }
 239
 240 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
 241         link_config *link;
 242
 243         LIST_FOREACH(links, link, ctx->links) {
 244
 245                 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
 246                                      link->match_type, NULL, link->match_host,
 247                                      link->match_virt, link->match_kernel, link->match_arch,
 248                                      ether_aton(udev_device_get_sysattr_value(device, "address")),
 249                                      udev_device_get_property_value(device, "ID_PATH"),
 250                                      udev_device_get_driver(udev_device_get_parent(device)),
 251                                      udev_device_get_property_value(device, "ID_NET_DRIVER"),
 252                                      udev_device_get_devtype(device),
 253                                      NULL)) {
 254                         log_debug("Config file %s applies to device %s",
 255                                   link->filename,
 256                                   udev_device_get_sysname(device));
 257                         *ret = link;
 258                         return 0;
 259                 }
 260         }
 261
 262         *ret = NULL;
 263
 264         return -ENOENT;
 265 }
 266
 267 static bool mac_is_random(struct udev_device *device) {
 268         const char *s;
 269         unsigned type;
 270         int r;
 271
 272         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 273         if (!s)
 274                 return false; /* if we don't know, assume it is not random */
 275         r = safe_atou(s, &type);
 276         if (r < 0)
 277                 return false;
 278
 279         /* check for NET_ADDR_RANDOM */
 280         return type == 1;
 281 }
 282
 283 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
 284         int r;
 285
 286         if (want_random)
 287                 random_bytes(mac->ether_addr_octet, ETH_ALEN);
 288         else {
 289                 uint8_t result[8];
 290
 291                 r = net_get_unique_predictable_data(device, result);
 292                 if (r < 0)
 293                         return r;
 294
 295                 assert_cc(ETH_ALEN <= sizeof(result));
 296                 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
 297         }
 298
 299         /* see eth_random_addr in the kernel */
 300         mac->ether_addr_octet[0] &= 0xfe;        /* clear multicast bit */
 301         mac->ether_addr_octet[0] |= 0x02;        /* set local assignment bit (IEEE802) */
 302
 303         return 0;
 304 }
 305
 306 int link_config_apply(link_config_ctx *ctx, link_config *config, struct udev_device *device, const char **name) {
 307         const char *old_name;
 308         const char *new_name = NULL;
 309         struct ether_addr generated_mac;
 310         struct ether_addr *mac = NULL;
 311         int r, ifindex;
 312
 313         assert(ctx);
 314         assert(config);
 315         assert(device);
 316         assert(name);
 317
 318         r = link_config_ctx_connect(ctx);
 319         if (r < 0)
 320                 return r;
 321
 322         old_name = udev_device_get_sysname(device);
 323         if (!old_name)
 324                 return -EINVAL;
 325
 326         r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed / 1024, config->duplex);
 327         if (r < 0)
 328                 log_warning("Could not set speed or duplex of %s to %u Mbps (%s): %s",
 329                             old_name, config->speed / 1024, duplex_to_string(config->duplex),
 330                             strerror(-r));
 331
 332         r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
 333         if (r < 0)
 334                 log_warning("Could not set WakeOnLan of %s to %s: %s",
 335                             old_name, wol_to_string(config->wol), strerror(-r));
 336
 337         ifindex = udev_device_get_ifindex(device);
 338         if (ifindex <= 0) {
 339                 log_warning("Could not find ifindex");
 340                 return -ENODEV;
 341         }
 342
 343         if (ctx->enable_name_policy && config->name_policy) {
 344                 NamePolicy *policy;
 345
 346                 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
 347                         switch (*policy) {
 348                                 case NAMEPOLICY_DATABASE:
 349                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
 350                                         break;
 351                                 case NAMEPOLICY_ONBOARD:
 352                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 353                                         break;
 354                                 case NAMEPOLICY_SLOT:
 355                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 356                                         break;
 357                                 case NAMEPOLICY_PATH:
 358                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 359                                         break;
 360                                 case NAMEPOLICY_MAC:
 361                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
 362                                         break;
 363                                 default:
 364                                         break;
 365                         }
 366                 }
 367         }
 368
 369         if (new_name)
 370                 *name = new_name; /* a name was set by a policy */
 371         else if (config->name)
 372                 *name = config->name; /* a name was set manually in the config */
 373         else
 374                 *name = NULL;
 375
 376         switch (config->mac_policy) {
 377                 case MACPOLICY_PERSISTENT:
 378                         if (mac_is_random(device)) {
 379                                 r = get_mac(device, false, &generated_mac);
 380                                 if (r < 0)
 381                                         return r;
 382                                 mac = &generated_mac;
 383                         }
 384                         break;
 385                 case MACPOLICY_RANDOM:
 386                         if (!mac_is_random(device)) {
 387                                 r = get_mac(device, true, &generated_mac);
 388                                 if (r < 0)
 389                                         return r;
 390                                 mac = &generated_mac;
 391                         }
 392                         break;
 393                 default:
 394                         mac = config->mac;
 395         }
 396
 397         r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
 398         if (r < 0) {
 399                 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
 400                 return r;
 401         }
 402
 403         return 0;
 404 }
 405
 406 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
 407         const char *name;
 408         char *driver;
 409         int r;
 410
 411         r = link_config_ctx_connect(ctx);
 412         if (r < 0)
 413                 return r;
 414
 415         name = udev_device_get_sysname(device);
 416         if (!name)
 417                 return -EINVAL;
 418
 419         r = ethtool_get_driver(ctx->ethtool_fd, name, &driver);
 420         if (r < 0)
 421                 return r;
 422
 423         *ret = driver;
 424         return 0;
 425 }
 426
 427 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
 428         [MACPOLICY_PERSISTENT] = "persistent",
 429         [MACPOLICY_RANDOM] = "random"
 430 };
 431
 432 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
 433 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy, "Failed to parse MAC address policy");
 434
 435 static const char* const name_policy_table[_NAMEPOLICY_MAX] = {
 436         [NAMEPOLICY_DATABASE] = "database",
 437         [NAMEPOLICY_ONBOARD] = "onboard",
 438         [NAMEPOLICY_SLOT] = "slot",
 439         [NAMEPOLICY_PATH] = "path",
 440         [NAMEPOLICY_MAC] = "mac"
 441 };
 442
 443 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
 444 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy, _NAMEPOLICY_INVALID, "Failed to parse interface name policy");