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