src/udev/net/link-config.c

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