src/udev/net/link-config.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4  This file is part of systemd.
   5
   6  Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <netinet/ether.h>
  23 #include <net/if.h>
  24
  25 #include "sd-id128.h"
  26
  27 #include "link-config.h"
  28 #include "ethtool-util.h"
  29
  30 #include "libudev-private.h"
  31 #include "sd-rtnl.h"
  32 #include "util.h"
  33 #include "log.h"
  34 #include "strv.h"
  35 #include "path-util.h"
  36 #include "conf-parser.h"
  37 #include "conf-files.h"
  38 #include "fileio.h"
  39 #include "hashmap.h"
  40 #include "rtnl-util.h"
  41 #include "net-util.h"
  42 #include "siphash24.h"
  43
  44 struct link_config_ctx {
  45         LIST_HEAD(link_config, links);
  46
  47         int ethtool_fd;
  48
  49         bool enable_name_policy;
  50
  51         sd_rtnl *rtnl;
  52
  53         usec_t link_dirs_ts_usec;
  54 };
  55
  56 static const char* const link_dirs[] = {
  57         "/etc/systemd/network",
  58         "/run/systemd/network",
  59         "/usr/lib/systemd/network",
  60 #ifdef HAVE_SPLIT_USR
  61         "/lib/systemd/network",
  62 #endif
  63         NULL};
  64
  65 DEFINE_TRIVIAL_CLEANUP_FUNC(link_config_ctx*, link_config_ctx_free);
  66 #define _cleanup_link_config_ctx_free_ _cleanup_(link_config_ctx_freep)
  67
  68 int link_config_ctx_new(link_config_ctx **ret) {
  69         _cleanup_link_config_ctx_free_ link_config_ctx *ctx = NULL;
  70
  71         if (!ret)
  72                 return -EINVAL;
  73
  74         ctx = new0(link_config_ctx, 1);
  75         if (!ctx)
  76                 return -ENOMEM;
  77
  78         LIST_HEAD_INIT(ctx->links);
  79
  80         ctx->ethtool_fd = -1;
  81
  82         ctx->enable_name_policy = true;
  83
  84         *ret = ctx;
  85         ctx = NULL;
  86
  87         return 0;
  88 }
  89
  90 static int link_config_ctx_connect(link_config_ctx *ctx) {
  91         int r;
  92
  93         if (ctx->ethtool_fd == -1) {
  94                 r = ethtool_connect(&ctx->ethtool_fd);
  95                 if (r < 0)
  96                         return r;
  97         }
  98
  99         if (!ctx->rtnl) {
 100                 r = sd_rtnl_open(&ctx->rtnl, 0);
 101                 if (r < 0)
 102                         return r;
 103         }
 104
 105         return 0;
 106 }
 107
 108 static void link_configs_free(link_config_ctx *ctx) {
 109         link_config *link, *link_next;
 110
 111         if (!ctx)
 112                 return;
 113
 114         LIST_FOREACH_SAFE(links, link, link_next, ctx->links) {
 115                 free(link->filename);
 116                 free(link->match_path);
 117                 free(link->match_driver);
 118                 free(link->match_type);
 119                 free(link->description);
 120                 free(link->alias);
 121
 122                 free(link);
 123         }
 124 }
 125
 126 void link_config_ctx_free(link_config_ctx *ctx) {
 127         if (!ctx)
 128                 return;
 129
 130         if (ctx->ethtool_fd >= 0)
 131                 close_nointr_nofail(ctx->ethtool_fd);
 132
 133         sd_rtnl_unref(ctx->rtnl);
 134
 135         link_configs_free(ctx);
 136
 137         free(ctx);
 138
 139         return;
 140 }
 141
 142 static int load_link(link_config_ctx *ctx, const char *filename) {
 143         link_config *link;
 144         _cleanup_fclose_ FILE *file;
 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         link = new0(link_config, 1);
 159         if (!link) {
 160                 r = log_oom();
 161                 goto failure;
 162         }
 163
 164         link->mac_policy = _MACPOLICY_INVALID;
 165         link->wol = _WOL_INVALID;
 166         link->duplex = _DUP_INVALID;
 167
 168         r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
 169                          (void*) link_config_gperf_lookup, false, false, link);
 170         if (r < 0) {
 171                 log_warning("Could not parse config file %s: %s", filename, strerror(-r));
 172                 goto failure;
 173         } else
 174                 log_debug("Parsed configuration file %s", filename);
 175
 176         link->filename = strdup(filename);
 177
 178         LIST_PREPEND(links, ctx->links, link);
 179
 180         return 0;
 181
 182 failure:
 183         free(link);
 184         return r;
 185 }
 186
 187 static bool enable_name_policy(void) {
 188         _cleanup_free_ char *line;
 189         char *w, *state;
 190         int r;
 191         size_t l;
 192
 193         r = proc_cmdline(&line);
 194         if (r < 0)
 195                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
 196         if (r <= 0)
 197                 return true;
 198
 199         FOREACH_WORD_QUOTED(w, l, line, state)
 200                 if (strneq(w, "net.ifnames=0", l))
 201                         return false;
 202
 203         return true;
 204 }
 205
 206 int link_config_load(link_config_ctx *ctx) {
 207         int r;
 208         char **files, **f;
 209
 210         link_configs_free(ctx);
 211
 212         if (!enable_name_policy()) {
 213                 ctx->enable_name_policy = false;
 214                 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
 215         }
 216
 217         /* update timestamp */
 218         paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
 219
 220         r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
 221         if (r < 0) {
 222                 log_error("failed to enumerate link files: %s", strerror(-r));
 223                 return r;
 224         }
 225
 226         STRV_FOREACH_BACKWARDS(f, files) {
 227                 r = load_link(ctx, *f);
 228                 if (r < 0)
 229                         return r;
 230         }
 231
 232         return 0;
 233 }
 234
 235 bool link_config_should_reload(link_config_ctx *ctx) {
 236         return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
 237 }
 238
 239 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
 240         link_config *link;
 241
 242         LIST_FOREACH(links, link, ctx->links) {
 243
 244                 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
 245                                      link->match_type, NULL, link->match_host,
 246                                      link->match_virt, link->match_kernel, link->match_arch,
 247                                      udev_device_get_sysattr_value(device, "address"),
 248                                      udev_device_get_property_value(device, "ID_PATH"),
 249                                      udev_device_get_driver(udev_device_get_parent(device)),
 250                                      udev_device_get_devtype(device),
 251                                      NULL)) {
 252                         log_debug("Config file %s applies to device %s",
 253                                   link->filename,
 254                                   udev_device_get_sysname(device));
 255                         *ret = link;
 256                         return 0;
 257                 }
 258         }
 259
 260         *ret = NULL;
 261
 262         return -ENOENT;
 263 }
 264
 265 static bool mac_is_random(struct udev_device *device) {
 266         const char *s;
 267         unsigned type;
 268         int r;
 269
 270         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 271         if (!s)
 272                 return false; /* if we don't know, assume it is not random */
 273         r = safe_atou(s, &type);
 274         if (r < 0)
 275                 return false;
 276
 277         /* check for NET_ADDR_RANDOM */
 278         return type == 1;
 279 }
 280
 281 static bool mac_is_permanent(struct udev_device *device) {
 282         const char *s;
 283         unsigned type;
 284         int r;
 285
 286         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 287         if (!s)
 288                 return true; /* if we don't know, assume it is permanent */
 289         r = safe_atou(s, &type);
 290         if (r < 0)
 291                 return true;
 292
 293         /* check for NET_ADDR_PERM */
 294         return type == 0;
 295 }
 296
 297 #define HASH_KEY SD_ID128_MAKE(d3,1e,48,fa,90,fe,4b,4c,9d,af,d5,d7,a1,b1,2e,8a)
 298
 299 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
 300         int r;
 301
 302         if (want_random)
 303                 random_bytes(mac->ether_addr_octet, ETH_ALEN);
 304         else {
 305                 const char *name;
 306                 uint8_t result[8];
 307                 size_t l, sz;
 308                 uint8_t *v;
 309
 310                 /* fetch some persistent data unique (on this machine) to this device */
 311                 name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 312                 if (!name) {
 313                         name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 314                         if (!name) {
 315                                 name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 316                                 if (!name)
 317                                         return -ENOENT;
 318                         }
 319                 }
 320
 321                 l = strlen(name);
 322                 sz = sizeof(sd_id128_t) + l;
 323                 v = alloca(sz);
 324
 325                 /* fetch some persistent data unique to this machine */
 326                 r = sd_id128_get_machine((sd_id128_t*) v);
 327                 if (r < 0)
 328                         return r;
 329                 memcpy(v + sizeof(sd_id128_t), name, l);
 330
 331                 /* Let's hash the machine ID plus the device name. We
 332                  * use a fixed, but originally randomly created hash
 333                  * key here. */
 334                 siphash24(result, v, sz, HASH_KEY.bytes);
 335
 336                 assert_cc(ETH_ALEN <= sizeof(result));
 337                 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
 338         }
 339
 340         /* see eth_random_addr in the kernel */
 341         mac->ether_addr_octet[0] &= 0xfe;        /* clear multicast bit */
 342         mac->ether_addr_octet[0] |= 0x02;        /* set local assignment bit (IEEE802) */
 343
 344         return 0;
 345 }
 346
 347 int link_config_apply(link_config_ctx *ctx, link_config *config, struct udev_device *device, const char **name) {
 348         const char *old_name;
 349         const char *new_name = NULL;
 350         struct ether_addr generated_mac;
 351         struct ether_addr *mac = NULL;
 352         int r, ifindex;
 353
 354         assert(ctx);
 355         assert(config);
 356         assert(device);
 357         assert(name);
 358
 359         r = link_config_ctx_connect(ctx);
 360         if (r < 0)
 361                 return r;
 362
 363         old_name = udev_device_get_sysname(device);
 364         if (!old_name)
 365                 return -EINVAL;
 366
 367         r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed, config->duplex);
 368         if (r < 0)
 369                 log_warning("Could not set speed or duplex of %s to %u Mbytes (%s): %s",
 370                              old_name, config->speed, duplex_to_string(config->duplex), strerror(-r));
 371
 372         r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
 373         if (r < 0)
 374                 log_warning("Could not set WakeOnLan of %s to %s: %s",
 375                             old_name, wol_to_string(config->wol), strerror(-r));
 376
 377         ifindex = udev_device_get_ifindex(device);
 378         if (ifindex <= 0) {
 379                 log_warning("Could not find ifindex");
 380                 return -ENODEV;
 381         }
 382
 383         if (ctx->enable_name_policy && config->name_policy) {
 384                 NamePolicy *policy;
 385
 386                 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
 387                         switch (*policy) {
 388                                 case NAMEPOLICY_DATABASE:
 389                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
 390                                         break;
 391                                 case NAMEPOLICY_ONBOARD:
 392                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 393                                         break;
 394                                 case NAMEPOLICY_SLOT:
 395                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 396                                         break;
 397                                 case NAMEPOLICY_PATH:
 398                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 399                                         break;
 400                                 case NAMEPOLICY_MAC:
 401                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
 402                                         break;
 403                                 default:
 404                                         break;
 405                         }
 406                 }
 407         }
 408
 409         if (new_name)
 410                 *name = new_name; /* a name was set by a policy */
 411         else if (config->name)
 412                 *name = config->name; /* a name was set manually in the config */
 413         else
 414                 *name = NULL;
 415
 416         switch (config->mac_policy) {
 417                 case MACPOLICY_PERSISTENT:
 418                         if (!mac_is_permanent(device)) {
 419                                 r = get_mac(device, false, &generated_mac);
 420                                 if (r < 0)
 421                                         return r;
 422                                 mac = &generated_mac;
 423                         }
 424                         break;
 425                 case MACPOLICY_RANDOM:
 426                         if (!mac_is_random(device)) {
 427                                 r = get_mac(device, true, &generated_mac);
 428                                 if (r < 0)
 429                                         return r;
 430                                 mac = &generated_mac;
 431                         }
 432                         break;
 433                 default:
 434                         mac = config->mac;
 435         }
 436
 437         r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
 438         if (r < 0) {
 439                 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
 440                 return r;
 441         }
 442
 443         return 0;
 444 }
 445
 446 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
 447         const char *name;
 448         char *driver;
 449         int r;
 450
 451         r = link_config_ctx_connect(ctx);
 452         if (r < 0)
 453                 return r;
 454
 455         name = udev_device_get_sysname(device);
 456         if (!name)
 457                 return -EINVAL;
 458
 459         r = ethtool_get_driver(ctx->ethtool_fd, name, &driver);
 460         if (r < 0)
 461                 return r;
 462
 463         *ret = driver;
 464         return 0;
 465 }
 466
 467 static const char* const mac_policy_table[] = {
 468         [MACPOLICY_PERSISTENT] = "persistent",
 469         [MACPOLICY_RANDOM] = "random"
 470 };
 471
 472 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
 473 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy, "Failed to parse MAC address policy");
 474
 475 static const char* const name_policy_table[] = {
 476         [NAMEPOLICY_DATABASE] = "database",
 477         [NAMEPOLICY_ONBOARD] = "onboard",
 478         [NAMEPOLICY_SLOT] = "slot",
 479         [NAMEPOLICY_PATH] = "path",
 480         [NAMEPOLICY_MAC] = "mac"
 481 };
 482
 483 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
 484 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy, _NAMEPOLICY_INVALID, "Failed to parse interface name policy");