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