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