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 >= 0 && ctx->rtnl)
  94                 return 0;
  95
  96         r = ethtool_connect(&ctx->ethtool_fd);
  97         if (r < 0)
  98                 return r;
  99
 100         r = sd_rtnl_open(&ctx->rtnl, 0);
 101         if (r < 0)
 102                 return r;
 103
 104         return 0;
 105 }
 106
 107 static void link_configs_free(link_config_ctx *ctx) {
 108         link_config *link, *link_next;
 109
 110         if (!ctx)
 111                 return;
 112
 113         LIST_FOREACH_SAFE(links, link, link_next, ctx->links) {
 114                 free(link->filename);
 115                 free(link->match_path);
 116                 free(link->match_driver);
 117                 free(link->match_type);
 118                 free(link->description);
 119                 free(link->alias);
 120
 121                 free(link);
 122         }
 123 }
 124
 125 void link_config_ctx_free(link_config_ctx *ctx) {
 126         if (!ctx)
 127                 return;
 128
 129         if (ctx->ethtool_fd >= 0)
 130                 close_nointr_nofail(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_devtype(device),
 250                                      NULL)) {
 251                         log_debug("Config file %s applies to device %s",
 252                                   link->filename,
 253                                   udev_device_get_sysname(device));
 254                         *ret = link;
 255                         return 0;
 256                 }
 257         }
 258
 259         *ret = NULL;
 260
 261         return -ENOENT;
 262 }
 263
 264 static bool mac_is_random(struct udev_device *device) {
 265         const char *s;
 266         unsigned type;
 267         int r;
 268
 269         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 270         if (!s)
 271                 return false; /* if we don't know, assume it is not random */
 272         r = safe_atou(s, &type);
 273         if (r < 0)
 274                 return false;
 275
 276         /* check for NET_ADDR_RANDOM */
 277         return type == 1;
 278 }
 279
 280 static bool mac_is_permanent(struct udev_device *device) {
 281         const char *s;
 282         unsigned type;
 283         int r;
 284
 285         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 286         if (!s)
 287                 return true; /* if we don't know, assume it is permanent */
 288         r = safe_atou(s, &type);
 289         if (r < 0)
 290                 return true;
 291
 292         /* check for NET_ADDR_PERM */
 293         return type == 0;
 294 }
 295
 296 #define HASH_KEY SD_ID128_MAKE(d3,1e,48,fa,90,fe,4b,4c,9d,af,d5,d7,a1,b1,2e,8a)
 297
 298 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
 299         int r;
 300
 301         if (want_random)
 302                 random_bytes(mac->ether_addr_octet, ETH_ALEN);
 303         else {
 304                 const char *name;
 305                 uint8_t result[8];
 306                 size_t l, sz;
 307                 uint8_t *v;
 308
 309                 /* fetch some persistent data unique (on this machine) to this device */
 310                 name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 311                 if (!name) {
 312                         name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 313                         if (!name) {
 314                                 name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 315                                 if (!name)
 316                                         return -ENOENT;
 317                         }
 318                 }
 319
 320                 l = strlen(name);
 321                 sz = sizeof(sd_id128_t) + l;
 322                 v = alloca(sz);
 323
 324                 /* fetch some persistent data unique to this machine */
 325                 r = sd_id128_get_machine((sd_id128_t*) v);
 326                 if (r < 0)
 327                         return r;
 328                 memcpy(v + sizeof(sd_id128_t), name, l);
 329
 330                 /* Let's hash the machine ID plus the device name. We
 331                  * use a fixed, but originally randomly created hash
 332                  * key here. */
 333                 siphash24(result, v, sz, HASH_KEY.bytes);
 334
 335                 assert_cc(ETH_ALEN <= sizeof(result));
 336                 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
 337         }
 338
 339         /* see eth_random_addr in the kernel */
 340         mac->ether_addr_octet[0] &= 0xfe;        /* clear multicast bit */
 341         mac->ether_addr_octet[0] |= 0x02;        /* set local assignment bit (IEEE802) */
 342
 343         return 0;
 344 }
 345
 346 int link_config_apply(link_config_ctx *ctx, link_config *config, struct udev_device *device, const char **name) {
 347         const char *old_name;
 348         const char *new_name = NULL;
 349         struct ether_addr generated_mac;
 350         struct ether_addr *mac = NULL;
 351         int r, ifindex;
 352
 353         assert(ctx);
 354         assert(config);
 355         assert(device);
 356         assert(name);
 357
 358         r = link_config_ctx_connect(ctx);
 359         if (r < 0)
 360                 return r;
 361
 362         old_name = udev_device_get_sysname(device);
 363         if (!old_name)
 364                 return -EINVAL;
 365
 366         r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed, config->duplex);
 367         if (r < 0)
 368                 log_warning("Could not set speed or duplex of %s to %u Mbytes (%s): %s",
 369                              old_name, config->speed, duplex_to_string(config->duplex), strerror(-r));
 370
 371         r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
 372         if (r < 0)
 373                 log_warning("Could not set WakeOnLan of %s to %s: %s",
 374                             old_name, wol_to_string(config->wol), strerror(-r));
 375
 376         ifindex = udev_device_get_ifindex(device);
 377         if (ifindex <= 0) {
 378                 log_warning("Could not find ifindex");
 379                 return -ENODEV;
 380         }
 381
 382         if (ctx->enable_name_policy && config->name_policy) {
 383                 NamePolicy *policy;
 384
 385                 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
 386                         switch (*policy) {
 387                                 case NAMEPOLICY_DATABASE:
 388                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
 389                                         break;
 390                                 case NAMEPOLICY_ONBOARD:
 391                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 392                                         break;
 393                                 case NAMEPOLICY_SLOT:
 394                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 395                                         break;
 396                                 case NAMEPOLICY_PATH:
 397                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 398                                         break;
 399                                 case NAMEPOLICY_MAC:
 400                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
 401                                         break;
 402                                 default:
 403                                         break;
 404                         }
 405                 }
 406         }
 407
 408         if (new_name)
 409                 *name = new_name; /* a name was set by a policy */
 410         else if (config->name)
 411                 *name = config->name; /* a name was set manually in the config */
 412         else
 413                 *name = NULL;
 414
 415         switch (config->mac_policy) {
 416                 case MACPOLICY_PERSISTENT:
 417                         if (!mac_is_permanent(device)) {
 418                                 r = get_mac(device, false, &generated_mac);
 419                                 if (r < 0)
 420                                         return r;
 421                                 mac = &generated_mac;
 422                         }
 423                         break;
 424                 case MACPOLICY_RANDOM:
 425                         if (!mac_is_random(device)) {
 426                                 r = get_mac(device, true, &generated_mac);
 427                                 if (r < 0)
 428                                         return r;
 429                                 mac = &generated_mac;
 430                         }
 431                         break;
 432                 default:
 433                         mac = config->mac;
 434         }
 435
 436         r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
 437         if (r < 0) {
 438                 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
 439                 return r;
 440         }
 441
 442         return 0;
 443 }
 444
 445 static const char* const mac_policy_table[] = {
 446         [MACPOLICY_PERSISTENT] = "persistent",
 447         [MACPOLICY_RANDOM] = "random"
 448 };
 449
 450 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
 451 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy, "Failed to parse MAC address policy");
 452
 453 static const char* const name_policy_table[] = {
 454         [NAMEPOLICY_DATABASE] = "database",
 455         [NAMEPOLICY_ONBOARD] = "onboard",
 456         [NAMEPOLICY_SLOT] = "slot",
 457         [NAMEPOLICY_PATH] = "path",
 458         [NAMEPOLICY_MAC] = "mac"
 459 };
 460
 461 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
 462 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy, _NAMEPOLICY_INVALID, "Failed to parse interface name policy");