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         safe_close(ctx->ethtool_fd);
 131
 132         sd_rtnl_unref(ctx->rtnl);
 133
 134         link_configs_free(ctx);
 135
 136         free(ctx);
 137
 138         return;
 139 }
 140
 141 static int load_link(link_config_ctx *ctx, const char *filename) {
 142         link_config *link;
 143         _cleanup_fclose_ FILE *file;
 144         int r;
 145
 146         assert(ctx);
 147         assert(filename);
 148
 149         file = fopen(filename, "re");
 150         if (!file) {
 151                 if (errno == ENOENT)
 152                         return 0;
 153                 else
 154                         return errno;
 155         }
 156
 157         link = new0(link_config, 1);
 158         if (!link) {
 159                 r = log_oom();
 160                 goto failure;
 161         }
 162
 163         link->mac_policy = _MACPOLICY_INVALID;
 164         link->wol = _WOL_INVALID;
 165         link->duplex = _DUP_INVALID;
 166
 167         r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
 168                          (void*) link_config_gperf_lookup, false, false, link);
 169         if (r < 0) {
 170                 log_warning("Could not parse config file %s: %s", filename, strerror(-r));
 171                 goto failure;
 172         } else
 173                 log_debug("Parsed configuration file %s", filename);
 174
 175         link->filename = strdup(filename);
 176
 177         LIST_PREPEND(links, ctx->links, link);
 178
 179         return 0;
 180
 181 failure:
 182         free(link);
 183         return r;
 184 }
 185
 186 static bool enable_name_policy(void) {
 187         _cleanup_free_ char *line;
 188         char *w, *state;
 189         int r;
 190         size_t l;
 191
 192         r = proc_cmdline(&line);
 193         if (r < 0)
 194                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
 195         if (r <= 0)
 196                 return true;
 197
 198         FOREACH_WORD_QUOTED(w, l, line, state)
 199                 if (strneq(w, "net.ifnames=0", l))
 200                         return false;
 201
 202         return true;
 203 }
 204
 205 int link_config_load(link_config_ctx *ctx) {
 206         int r;
 207         char **files, **f;
 208
 209         link_configs_free(ctx);
 210
 211         if (!enable_name_policy()) {
 212                 ctx->enable_name_policy = false;
 213                 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
 214         }
 215
 216         /* update timestamp */
 217         paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
 218
 219         r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
 220         if (r < 0) {
 221                 log_error("failed to enumerate link files: %s", strerror(-r));
 222                 return r;
 223         }
 224
 225         STRV_FOREACH_BACKWARDS(f, files) {
 226                 r = load_link(ctx, *f);
 227                 if (r < 0)
 228                         return r;
 229         }
 230
 231         return 0;
 232 }
 233
 234 bool link_config_should_reload(link_config_ctx *ctx) {
 235         return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
 236 }
 237
 238 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
 239         link_config *link;
 240
 241         LIST_FOREACH(links, link, ctx->links) {
 242
 243                 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
 244                                      link->match_type, NULL, link->match_host,
 245                                      link->match_virt, link->match_kernel, link->match_arch,
 246                                      udev_device_get_sysattr_value(device, "address"),
 247                                      udev_device_get_property_value(device, "ID_PATH"),
 248                                      udev_device_get_driver(udev_device_get_parent(device)),
 249                                      udev_device_get_property_value(device, "ID_NET_DRIVER"),
 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 / 1024, config->duplex);
 368         if (r < 0)
 369                 log_warning("Could not set speed or duplex of %s to %u Mbps (%s): %s",
 370                             old_name, config->speed / 1024, duplex_to_string(config->duplex),
 371                             strerror(-r));
 372
 373         r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
 374         if (r < 0)
 375                 log_warning("Could not set WakeOnLan of %s to %s: %s",
 376                             old_name, wol_to_string(config->wol), strerror(-r));
 377
 378         ifindex = udev_device_get_ifindex(device);
 379         if (ifindex <= 0) {
 380                 log_warning("Could not find ifindex");
 381                 return -ENODEV;
 382         }
 383
 384         if (ctx->enable_name_policy && config->name_policy) {
 385                 NamePolicy *policy;
 386
 387                 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
 388                         switch (*policy) {
 389                                 case NAMEPOLICY_DATABASE:
 390                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
 391                                         break;
 392                                 case NAMEPOLICY_ONBOARD:
 393                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 394                                         break;
 395                                 case NAMEPOLICY_SLOT:
 396                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 397                                         break;
 398                                 case NAMEPOLICY_PATH:
 399                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 400                                         break;
 401                                 case NAMEPOLICY_MAC:
 402                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
 403                                         break;
 404                                 default:
 405                                         break;
 406                         }
 407                 }
 408         }
 409
 410         if (new_name)
 411                 *name = new_name; /* a name was set by a policy */
 412         else if (config->name)
 413                 *name = config->name; /* a name was set manually in the config */
 414         else
 415                 *name = NULL;
 416
 417         switch (config->mac_policy) {
 418                 case MACPOLICY_PERSISTENT:
 419                         if (!mac_is_permanent(device)) {
 420                                 r = get_mac(device, false, &generated_mac);
 421                                 if (r < 0)
 422                                         return r;
 423                                 mac = &generated_mac;
 424                         }
 425                         break;
 426                 case MACPOLICY_RANDOM:
 427                         if (!mac_is_random(device)) {
 428                                 r = get_mac(device, true, &generated_mac);
 429                                 if (r < 0)
 430                                         return r;
 431                                 mac = &generated_mac;
 432                         }
 433                         break;
 434                 default:
 435                         mac = config->mac;
 436         }
 437
 438         r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
 439         if (r < 0) {
 440                 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
 441                 return r;
 442         }
 443
 444         return 0;
 445 }
 446
 447 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
 448         const char *name;
 449         char *driver;
 450         int r;
 451
 452         r = link_config_ctx_connect(ctx);
 453         if (r < 0)
 454                 return r;
 455
 456         name = udev_device_get_sysname(device);
 457         if (!name)
 458                 return -EINVAL;
 459
 460         r = ethtool_get_driver(ctx->ethtool_fd, name, &driver);
 461         if (r < 0)
 462                 return r;
 463
 464         *ret = driver;
 465         return 0;
 466 }
 467
 468 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
 469         [MACPOLICY_PERSISTENT] = "persistent",
 470         [MACPOLICY_RANDOM] = "random"
 471 };
 472
 473 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
 474 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy, "Failed to parse MAC address policy");
 475
 476 static const char* const name_policy_table[_NAMEPOLICY_MAX] = {
 477         [NAMEPOLICY_DATABASE] = "database",
 478         [NAMEPOLICY_ONBOARD] = "onboard",
 479         [NAMEPOLICY_SLOT] = "slot",
 480         [NAMEPOLICY_PATH] = "path",
 481         [NAMEPOLICY_MAC] = "mac"
 482 };
 483
 484 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
 485 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy, _NAMEPOLICY_INVALID, "Failed to parse interface name policy");