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