src/udev/net/link-config.c

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