src/udev/net/link-config.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <netinet/ether.h>
   4
   5 #include "sd-device.h"
   6 #include "sd-netlink.h"
   7
   8 #include "alloc-util.h"
   9 #include "conf-files.h"
  10 #include "conf-parser.h"
  11 #include "ethtool-util.h"
  12 #include "fd-util.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, sd_device *device, link_config **ret) {
 221         link_config *link;
 222
 223         assert(ctx);
 224         assert(device);
 225         assert(ret);
 226
 227         LIST_FOREACH(links, link, ctx->links) {
 228                 const char *address = NULL, *id_path = NULL, *parent_driver = NULL, *id_net_driver = NULL, *devtype = NULL, *sysname = NULL;
 229                 sd_device *parent;
 230
 231                 (void) sd_device_get_sysattr_value(device, "address", &address);
 232                 (void) sd_device_get_property_value(device, "ID_PATH", &id_path);
 233                 if (sd_device_get_parent(device, &parent) >= 0)
 234                         (void) sd_device_get_driver(parent, &parent_driver);
 235                 (void) sd_device_get_property_value(device, "ID_NET_DRIVER", &id_net_driver);
 236                 (void) sd_device_get_devtype(device, &devtype);
 237                 (void) sd_device_get_sysname(device, &sysname);
 238
 239                 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
 240                                      link->match_type, link->match_name, link->match_host,
 241                                      link->match_virt, link->match_kernel_cmdline,
 242                                      link->match_kernel_version, link->match_arch,
 243                                      address ? ether_aton(address) : NULL,
 244                                      id_path,
 245                                      parent_driver,
 246                                      id_net_driver,
 247                                      devtype,
 248                                      sysname)) {
 249                         if (link->match_name) {
 250                                 unsigned char name_assign_type = NET_NAME_UNKNOWN;
 251                                 const char *attr_value;
 252
 253                                 if (sd_device_get_sysattr_value(device, "name_assign_type", &attr_value) >= 0)
 254                                         (void) safe_atou8(attr_value, &name_assign_type);
 255
 256                                 if (name_assign_type == NET_NAME_ENUM) {
 257                                         log_warning("Config file %s applies to device based on potentially unpredictable interface name '%s'",
 258                                                   link->filename, sysname);
 259                                         *ret = link;
 260
 261                                         return 0;
 262                                 } else if (name_assign_type == NET_NAME_RENAMED) {
 263                                         log_warning("Config file %s matches device based on renamed interface name '%s', ignoring",
 264                                                   link->filename, sysname);
 265
 266                                         continue;
 267                                 }
 268                         }
 269
 270                         log_debug("Config file %s applies to device %s",
 271                                   link->filename, sysname);
 272
 273                         *ret = link;
 274
 275                         return 0;
 276                 }
 277         }
 278
 279         *ret = NULL;
 280
 281         return -ENOENT;
 282 }
 283
 284 static bool mac_is_random(sd_device *device) {
 285         const char *s;
 286         unsigned type;
 287         int r;
 288
 289         /* if we can't get the assign type, assume it is not random */
 290         if (sd_device_get_sysattr_value(device, "addr_assign_type", &s) < 0)
 291                 return false;
 292
 293         r = safe_atou(s, &type);
 294         if (r < 0)
 295                 return false;
 296
 297         return type == NET_ADDR_RANDOM;
 298 }
 299
 300 static bool should_rename(sd_device *device, bool respect_predictable) {
 301         const char *s;
 302         unsigned type;
 303         int r;
 304
 305         /* if we can't get the assgin type, assume we should rename */
 306         if (sd_device_get_sysattr_value(device, "name_assign_type", &s) < 0)
 307                 return true;
 308
 309         r = safe_atou(s, &type);
 310         if (r < 0)
 311                 return true;
 312
 313         switch (type) {
 314         case NET_NAME_USER:
 315         case NET_NAME_RENAMED:
 316                 /* these were already named by userspace, do not touch again */
 317                 return false;
 318         case NET_NAME_PREDICTABLE:
 319                 /* the kernel claims to have given a predictable name */
 320                 if (respect_predictable)
 321                         return false;
 322                 _fallthrough_;
 323         case NET_NAME_ENUM:
 324         default:
 325                 /* the name is known to be bad, or of an unknown type */
 326                 return true;
 327         }
 328 }
 329
 330 static int get_mac(sd_device *device, bool want_random,
 331                    struct ether_addr *mac) {
 332         int r;
 333
 334         if (want_random)
 335                 random_bytes(mac->ether_addr_octet, ETH_ALEN);
 336         else {
 337                 uint64_t result;
 338
 339                 r = net_get_unique_predictable_data(device, &result);
 340                 if (r < 0)
 341                         return r;
 342
 343                 assert_cc(ETH_ALEN <= sizeof(result));
 344                 memcpy(mac->ether_addr_octet, &result, ETH_ALEN);
 345         }
 346
 347         /* see eth_random_addr in the kernel */
 348         mac->ether_addr_octet[0] &= 0xfe;  /* clear multicast bit */
 349         mac->ether_addr_octet[0] |= 0x02;  /* set local assignment bit (IEEE802) */
 350
 351         return 0;
 352 }
 353
 354 int link_config_apply(link_config_ctx *ctx, link_config *config,
 355                       sd_device *device, const char **name) {
 356         bool respect_predictable = false;
 357         struct ether_addr generated_mac;
 358         struct ether_addr *mac = NULL;
 359         const char *new_name = NULL;
 360         const char *old_name;
 361         unsigned speed;
 362         int r, ifindex;
 363
 364         assert(ctx);
 365         assert(config);
 366         assert(device);
 367         assert(name);
 368
 369         r = sd_device_get_sysname(device, &old_name);
 370         if (r < 0)
 371                 return r;
 372
 373         r = ethtool_set_glinksettings(&ctx->ethtool_fd, old_name, config);
 374         if (r < 0) {
 375
 376                 if (config->port != _NET_DEV_PORT_INVALID)
 377                         log_warning_errno(r,  "Could not set port (%s) of %s: %m", port_to_string(config->port), old_name);
 378
 379                 if (config->advertise)
 380                         log_warning_errno(r, "Could not set advertise mode to 0x%X: %m", config->advertise);
 381
 382                 if (config->speed) {
 383
 384                         speed = DIV_ROUND_UP(config->speed, 1000000);
 385                         if (r == -EOPNOTSUPP) {
 386                                 r = ethtool_set_speed(&ctx->ethtool_fd, old_name, speed, config->duplex);
 387                                 if (r < 0)
 388                                         log_warning_errno(r, "Could not set speed of %s to %u Mbps: %m", old_name, speed);
 389                         }
 390                 }
 391
 392                 if (config->duplex !=_DUP_INVALID)
 393                         log_warning_errno(r, "Could not set duplex of %s to (%s): %m", old_name, duplex_to_string(config->duplex));
 394         }
 395
 396         r = ethtool_set_wol(&ctx->ethtool_fd, old_name, config->wol);
 397         if (r < 0)
 398                 log_warning_errno(r, "Could not set WakeOnLan of %s to %s: %m",
 399                                   old_name, wol_to_string(config->wol));
 400
 401         r = ethtool_set_features(&ctx->ethtool_fd, old_name, config->features);
 402         if (r < 0)
 403                 log_warning_errno(r, "Could not set offload features of %s: %m", old_name);
 404
 405         if (config->channels.rx_count_set || config->channels.tx_count_set || config->channels.other_count_set || config->channels.combined_count_set) {
 406                 r = ethtool_set_channels(&ctx->ethtool_fd, old_name, &config->channels);
 407                 if (r < 0)
 408                         log_warning_errno(r, "Could not set channels of %s: %m", old_name);
 409         }
 410
 411         r = sd_device_get_ifindex(device, &ifindex);
 412         if (r < 0)
 413                 return log_warning_errno(r, "Could not find ifindex: %m");
 414         if (ifindex <= 0)
 415                 return log_warning_errno(EINVAL, "Invalid ifindex '%d'", ifindex);
 416
 417         if (ctx->enable_name_policy && config->name_policy) {
 418                 NamePolicy *policy;
 419
 420                 for (policy = config->name_policy;
 421                      !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
 422                         switch (*policy) {
 423                                 case NAMEPOLICY_KERNEL:
 424                                         respect_predictable = true;
 425                                         break;
 426                                 case NAMEPOLICY_DATABASE:
 427                                         (void) sd_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE", &new_name);
 428                                         break;
 429                                 case NAMEPOLICY_ONBOARD:
 430                                         (void) sd_device_get_property_value(device, "ID_NET_NAME_ONBOARD", &new_name);
 431                                         break;
 432                                 case NAMEPOLICY_SLOT:
 433                                         (void) sd_device_get_property_value(device, "ID_NET_NAME_SLOT", &new_name);
 434                                         break;
 435                                 case NAMEPOLICY_PATH:
 436                                         (void) sd_device_get_property_value(device, "ID_NET_NAME_PATH", &new_name);
 437                                         break;
 438                                 case NAMEPOLICY_MAC:
 439                                         (void) sd_device_get_property_value(device, "ID_NET_NAME_MAC", &new_name);
 440                                         break;
 441                                 default:
 442                                         break;
 443                         }
 444                 }
 445         }
 446
 447         if (should_rename(device, respect_predictable)) {
 448                 /* if not set by policy, fall back manually set name */
 449                 if (!new_name)
 450                         new_name = config->name;
 451         } else
 452                 new_name = NULL;
 453
 454         switch (config->mac_policy) {
 455                 case MACPOLICY_PERSISTENT:
 456                         if (mac_is_random(device)) {
 457                                 r = get_mac(device, false, &generated_mac);
 458                                 if (r == -ENOENT) {
 459                                         log_warning_errno(r, "Could not generate persistent 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_RANDOM:
 467                         if (!mac_is_random(device)) {
 468                                 r = get_mac(device, true, &generated_mac);
 469                                 if (r == -ENOENT) {
 470                                         log_warning_errno(r, "Could not generate random MAC address for %s: %m", old_name);
 471                                         break;
 472                                 } else if (r < 0)
 473                                         return r;
 474                                 mac = &generated_mac;
 475                         }
 476                         break;
 477                 case MACPOLICY_NONE:
 478                 default:
 479                         mac = config->mac;
 480         }
 481
 482         r = rtnl_set_link_properties(&ctx->rtnl, ifindex, config->alias, mac, config->mtu);
 483         if (r < 0)
 484                 return log_warning_errno(r, "Could not set Alias=, MACAddress= or MTU= on %s: %m", old_name);
 485
 486         *name = new_name;
 487
 488         return 0;
 489 }
 490
 491 int link_get_driver(link_config_ctx *ctx, sd_device *device, char **ret) {
 492         const char *name;
 493         char *driver = NULL;
 494         int r;
 495
 496         r = sd_device_get_sysname(device, &name);
 497         if (r < 0)
 498                 return r;
 499
 500         r = ethtool_get_driver(&ctx->ethtool_fd, name, &driver);
 501         if (r < 0)
 502                 return r;
 503
 504         *ret = driver;
 505         return 0;
 506 }
 507
 508 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
 509         [MACPOLICY_PERSISTENT] = "persistent",
 510         [MACPOLICY_RANDOM] = "random",
 511         [MACPOLICY_NONE] = "none"
 512 };
 513
 514 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
 515 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy,
 516                          "Failed to parse MAC address policy");
 517
 518 static const char* const name_policy_table[_NAMEPOLICY_MAX] = {
 519         [NAMEPOLICY_KERNEL] = "kernel",
 520         [NAMEPOLICY_DATABASE] = "database",
 521         [NAMEPOLICY_ONBOARD] = "onboard",
 522         [NAMEPOLICY_SLOT] = "slot",
 523         [NAMEPOLICY_PATH] = "path",
 524         [NAMEPOLICY_MAC] = "mac"
 525 };
 526
 527 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
 528 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy,
 529                           _NAMEPOLICY_INVALID,
 530                           "Failed to parse interface name policy");