src/udev/net/link-config.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3  This file is part of systemd.
   4
   5  Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
   6 ***/
   7
   8 #include <netinet/ether.h>
   9
  10 #include "sd-netlink.h"
  11
  12 #include "alloc-util.h"
  13 #include "conf-files.h"
  14 #include "conf-parser.h"
  15 #include "ethtool-util.h"
  16 #include "fd-util.h"
  17 #include "libudev-private.h"
  18 #include "link-config.h"
  19 #include "log.h"
  20 #include "missing.h"
  21 #include "netlink-util.h"
  22 #include "network-internal.h"
  23 #include "parse-util.h"
  24 #include "path-util.h"
  25 #include "proc-cmdline.h"
  26 #include "random-util.h"
  27 #include "stat-util.h"
  28 #include "string-table.h"
  29 #include "string-util.h"
  30 #include "strv.h"
  31 #include "util.h"
  32
  33 struct link_config_ctx {
  34         LIST_HEAD(link_config, links);
  35
  36         int ethtool_fd;
  37
  38         bool enable_name_policy;
  39
  40         sd_netlink *rtnl;
  41
  42         usec_t link_dirs_ts_usec;
  43 };
  44
  45 static const char* const link_dirs[] = {
  46         "/etc/systemd/network",
  47         "/run/systemd/network",
  48         "/usr/lib/systemd/network",
  49 #if HAVE_SPLIT_USR
  50         "/lib/systemd/network",
  51 #endif
  52         NULL};
  53
  54 static void link_config_free(link_config *link) {
  55         if (!link)
  56                 return;
  57
  58         free(link->filename);
  59
  60         free(link->match_mac);
  61         strv_free(link->match_path);
  62         strv_free(link->match_driver);
  63         strv_free(link->match_type);
  64         free(link->match_name);
  65         free(link->match_host);
  66         free(link->match_virt);
  67         free(link->match_kernel_cmdline);
  68         free(link->match_kernel_version);
  69         free(link->match_arch);
  70
  71         free(link->description);
  72         free(link->mac);
  73         free(link->name_policy);
  74         free(link->name);
  75         free(link->alias);
  76
  77         free(link);
  78 }
  79
  80 DEFINE_TRIVIAL_CLEANUP_FUNC(link_config*, link_config_free);
  81
  82 static void link_configs_free(link_config_ctx *ctx) {
  83         link_config *link, *link_next;
  84
  85         if (!ctx)
  86                 return;
  87
  88         LIST_FOREACH_SAFE(links, link, link_next, ctx->links)
  89                 link_config_free(link);
  90 }
  91
  92 void link_config_ctx_free(link_config_ctx *ctx) {
  93         if (!ctx)
  94                 return;
  95
  96         safe_close(ctx->ethtool_fd);
  97
  98         sd_netlink_unref(ctx->rtnl);
  99
 100         link_configs_free(ctx);
 101
 102         free(ctx);
 103
 104         return;
 105 }
 106
 107 DEFINE_TRIVIAL_CLEANUP_FUNC(link_config_ctx*, link_config_ctx_free);
 108
 109 int link_config_ctx_new(link_config_ctx **ret) {
 110         _cleanup_(link_config_ctx_freep) link_config_ctx *ctx = NULL;
 111
 112         if (!ret)
 113                 return -EINVAL;
 114
 115         ctx = new0(link_config_ctx, 1);
 116         if (!ctx)
 117                 return -ENOMEM;
 118
 119         LIST_HEAD_INIT(ctx->links);
 120
 121         ctx->ethtool_fd = -1;
 122
 123         ctx->enable_name_policy = true;
 124
 125         *ret = TAKE_PTR(ctx);
 126
 127         return 0;
 128 }
 129
 130 static int load_link(link_config_ctx *ctx, const char *filename) {
 131         _cleanup_(link_config_freep) link_config *link = NULL;
 132         _cleanup_fclose_ FILE *file = NULL;
 133         int r;
 134
 135         assert(ctx);
 136         assert(filename);
 137
 138         file = fopen(filename, "re");
 139         if (!file) {
 140                 if (errno == ENOENT)
 141                         return 0;
 142                 else
 143                         return -errno;
 144         }
 145
 146         if (null_or_empty_fd(fileno(file))) {
 147                 log_debug("Skipping empty file: %s", filename);
 148                 return 0;
 149         }
 150
 151         link = new0(link_config, 1);
 152         if (!link)
 153                 return log_oom();
 154
 155         link->mac_policy = _MACPOLICY_INVALID;
 156         link->wol = _WOL_INVALID;
 157         link->duplex = _DUP_INVALID;
 158         link->port = _NET_DEV_PORT_INVALID;
 159         link->autonegotiation = -1;
 160
 161         memset(&link->features, 0xFF, sizeof(link->features));
 162
 163         r = config_parse(NULL, filename, file,
 164                          "Match\0Link\0Ethernet\0",
 165                          config_item_perf_lookup, link_config_gperf_lookup,
 166                          CONFIG_PARSE_WARN, link);
 167         if (r < 0)
 168                 return r;
 169         else
 170                 log_debug("Parsed configuration file %s", filename);
 171
 172         if (link->mtu > UINT_MAX || link->speed > UINT_MAX)
 173                 return -ERANGE;
 174
 175         link->filename = strdup(filename);
 176         if (!link->filename)
 177                 return log_oom();
 178
 179         LIST_PREPEND(links, ctx->links, link);
 180         link = NULL;
 181
 182         return 0;
 183 }
 184
 185 static bool enable_name_policy(void) {
 186         bool b;
 187
 188         return proc_cmdline_get_bool("net.ifnames", &b) <= 0 || b;
 189 }
 190
 191 int link_config_load(link_config_ctx *ctx) {
 192         _cleanup_strv_free_ char **files;
 193         char **f;
 194         int r;
 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, 0, 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         assert(ctx);
 228         assert(device);
 229         assert(ret);
 230
 231         LIST_FOREACH(links, link, ctx->links) {
 232                 const char* attr_value;
 233
 234                 attr_value = udev_device_get_sysattr_value(device, "address");
 235
 236                 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
 237                                      link->match_type, link->match_name, link->match_host,
 238                                      link->match_virt, link->match_kernel_cmdline,
 239                                      link->match_kernel_version, link->match_arch,
 240                                      attr_value ? ether_aton(attr_value) : NULL,
 241                                      udev_device_get_property_value(device, "ID_PATH"),
 242                                      udev_device_get_driver(udev_device_get_parent(device)),
 243                                      udev_device_get_property_value(device, "ID_NET_DRIVER"),
 244                                      udev_device_get_devtype(device),
 245                                      udev_device_get_sysname(device))) {
 246                         if (link->match_name) {
 247                                 unsigned char name_assign_type = NET_NAME_UNKNOWN;
 248
 249                                 attr_value = udev_device_get_sysattr_value(device, "name_assign_type");
 250                                 if (attr_value)
 251                                         (void) safe_atou8(attr_value, &name_assign_type);
 252
 253                                 if (name_assign_type == NET_NAME_ENUM) {
 254                                         log_warning("Config file %s applies to device based on potentially unpredictable interface name '%s'",
 255                                                   link->filename, udev_device_get_sysname(device));
 256                                         *ret = link;
 257
 258                                         return 0;
 259                                 } else if (name_assign_type == NET_NAME_RENAMED) {
 260                                         log_warning("Config file %s matches device based on renamed interface name '%s', ignoring",
 261                                                   link->filename, udev_device_get_sysname(device));
 262
 263                                         continue;
 264                                 }
 265                         }
 266
 267                         log_debug("Config file %s applies to device %s",
 268                                   link->filename,  udev_device_get_sysname(device));
 269
 270                         *ret = link;
 271
 272                         return 0;
 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                 _fallthrough_;
 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                 uint64_t result;
 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         bool respect_predictable = false;
 356         struct ether_addr generated_mac;
 357         struct ether_addr *mac = NULL;
 358         const char *new_name = NULL;
 359         const char *old_name;
 360         unsigned speed;
 361         int r, ifindex;
 362
 363         assert(ctx);
 364         assert(config);
 365         assert(device);
 366         assert(name);
 367
 368         old_name = udev_device_get_sysname(device);
 369         if (!old_name)
 370                 return -EINVAL;
 371
 372         r = ethtool_set_glinksettings(&ctx->ethtool_fd, old_name, config);
 373         if (r < 0) {
 374
 375                 if (config->port != _NET_DEV_PORT_INVALID)
 376                         log_warning_errno(r,  "Could not set port (%s) of %s: %m", port_to_string(config->port), old_name);
 377
 378                 speed = DIV_ROUND_UP(config->speed, 1000000);
 379                 if (r == -EOPNOTSUPP)
 380                         r = ethtool_set_speed(&ctx->ethtool_fd, old_name, speed, config->duplex);
 381
 382                 if (r < 0)
 383                         log_warning_errno(r, "Could not set speed or duplex of %s to %u Mbps (%s): %m",
 384                                           old_name, speed, duplex_to_string(config->duplex));
 385         }
 386
 387         r = ethtool_set_wol(&ctx->ethtool_fd, old_name, config->wol);
 388         if (r < 0)
 389                 log_warning_errno(r, "Could not set WakeOnLan of %s to %s: %m",
 390                                   old_name, wol_to_string(config->wol));
 391
 392         r = ethtool_set_features(&ctx->ethtool_fd, old_name, config->features);
 393         if (r < 0)
 394                 log_warning_errno(r, "Could not set offload features of %s: %m", old_name);
 395
 396         ifindex = udev_device_get_ifindex(device);
 397         if (ifindex <= 0) {
 398                 log_warning("Could not find ifindex");
 399                 return -ENODEV;
 400         }
 401
 402         if (ctx->enable_name_policy && config->name_policy) {
 403                 NamePolicy *policy;
 404
 405                 for (policy = config->name_policy;
 406                      !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
 407                         switch (*policy) {
 408                                 case NAMEPOLICY_KERNEL:
 409                                         respect_predictable = true;
 410                                         break;
 411                                 case NAMEPOLICY_DATABASE:
 412                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
 413                                         break;
 414                                 case NAMEPOLICY_ONBOARD:
 415                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 416                                         break;
 417                                 case NAMEPOLICY_SLOT:
 418                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 419                                         break;
 420                                 case NAMEPOLICY_PATH:
 421                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 422                                         break;
 423                                 case NAMEPOLICY_MAC:
 424                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
 425                                         break;
 426                                 default:
 427                                         break;
 428                         }
 429                 }
 430         }
 431
 432         if (should_rename(device, respect_predictable)) {
 433                 /* if not set by policy, fall back manually set name */
 434                 if (!new_name)
 435                         new_name = config->name;
 436         } else
 437                 new_name = NULL;
 438
 439         switch (config->mac_policy) {
 440                 case MACPOLICY_PERSISTENT:
 441                         if (mac_is_random(device)) {
 442                                 r = get_mac(device, false, &generated_mac);
 443                                 if (r == -ENOENT) {
 444                                         log_warning_errno(r, "Could not generate persistent MAC address for %s: %m", old_name);
 445                                         break;
 446                                 } else if (r < 0)
 447                                         return r;
 448                                 mac = &generated_mac;
 449                         }
 450                         break;
 451                 case MACPOLICY_RANDOM:
 452                         if (!mac_is_random(device)) {
 453                                 r = get_mac(device, true, &generated_mac);
 454                                 if (r == -ENOENT) {
 455                                         log_warning_errno(r, "Could not generate random MAC address for %s: %m", old_name);
 456                                         break;
 457                                 } else if (r < 0)
 458                                         return r;
 459                                 mac = &generated_mac;
 460                         }
 461                         break;
 462                 case MACPOLICY_NONE:
 463                 default:
 464                         mac = config->mac;
 465         }
 466
 467         r = rtnl_set_link_properties(&ctx->rtnl, ifindex, config->alias, mac, config->mtu);
 468         if (r < 0)
 469                 return log_warning_errno(r, "Could not set Alias, MACAddress or MTU on %s: %m", old_name);
 470
 471         *name = new_name;
 472
 473         return 0;
 474 }
 475
 476 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
 477         const char *name;
 478         char *driver = NULL;
 479         int r;
 480
 481         name = udev_device_get_sysname(device);
 482         if (!name)
 483                 return -EINVAL;
 484
 485         r = ethtool_get_driver(&ctx->ethtool_fd, name, &driver);
 486         if (r < 0)
 487                 return r;
 488
 489         *ret = driver;
 490         return 0;
 491 }
 492
 493 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
 494         [MACPOLICY_PERSISTENT] = "persistent",
 495         [MACPOLICY_RANDOM] = "random",
 496         [MACPOLICY_NONE] = "none"
 497 };
 498
 499 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
 500 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy,
 501                          "Failed to parse MAC address policy");
 502
 503 static const char* const name_policy_table[_NAMEPOLICY_MAX] = {
 504         [NAMEPOLICY_KERNEL] = "kernel",
 505         [NAMEPOLICY_DATABASE] = "database",
 506         [NAMEPOLICY_ONBOARD] = "onboard",
 507         [NAMEPOLICY_SLOT] = "slot",
 508         [NAMEPOLICY_PATH] = "path",
 509         [NAMEPOLICY_MAC] = "mac"
 510 };
 511
 512 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
 513 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy,
 514                           _NAMEPOLICY_INVALID,
 515                           "Failed to parse interface name policy");