src/udev/net/link-config.c

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