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
  43 struct link_config_ctx {
  44         LIST_HEAD(link_config, links);
  45
  46         int ethtool_fd;
  47
  48         bool enable_name_policy;
  49
  50         sd_rtnl *rtnl;
  51
  52         char **link_dirs;
  53         usec_t link_dirs_ts_usec;
  54 };
  55
  56 DEFINE_TRIVIAL_CLEANUP_FUNC(link_config_ctx*, link_config_ctx_free);
  57 #define _cleanup_link_config_ctx_free_ _cleanup_(link_config_ctx_freep)
  58
  59 int link_config_ctx_new(link_config_ctx **ret) {
  60         _cleanup_link_config_ctx_free_ link_config_ctx *ctx = NULL;
  61
  62         if (!ret)
  63                 return -EINVAL;
  64
  65         ctx = new0(link_config_ctx, 1);
  66         if (!ctx)
  67                 return -ENOMEM;
  68
  69         LIST_HEAD_INIT(ctx->links);
  70
  71         ctx->ethtool_fd = -1;
  72
  73         ctx->enable_name_policy = true;
  74
  75         ctx->link_dirs = strv_new("/etc/systemd/network",
  76                                   "/run/systemd/network",
  77                                   "/usr/lib/systemd/network",
  78 #ifdef HAVE_SPLIT_USR
  79                                   "/lib/systemd/network",
  80 #endif
  81                                   NULL);
  82         if (!ctx->link_dirs) {
  83                 log_error("failed to build link config directory array");
  84                 return -ENOMEM;
  85         }
  86
  87         if (!path_strv_canonicalize_uniq(ctx->link_dirs)) {
  88                 log_error("failed to canonicalize link config directories\n");
  89                 return -ENOMEM;
  90         }
  91
  92         *ret = ctx;
  93         ctx = NULL;
  94
  95         return 0;
  96 }
  97
  98 static int link_config_ctx_connect(link_config_ctx *ctx) {
  99         int r;
 100
 101         if (ctx->ethtool_fd >= 0 && ctx->rtnl)
 102                 return 0;
 103
 104         r = ethtool_connect(&ctx->ethtool_fd);
 105         if (r < 0)
 106                 return r;
 107
 108         r = sd_rtnl_open(0, &ctx->rtnl);
 109         if (r < 0)
 110                 return r;
 111
 112         return 0;
 113 }
 114
 115 static void link_configs_free(link_config_ctx *ctx) {
 116         link_config *link, *link_next;
 117
 118         if (!ctx)
 119                 return;
 120
 121         LIST_FOREACH_SAFE(links, link, link_next, ctx->links) {
 122                 free(link->filename);
 123                 free(link->match_path);
 124                 free(link->match_driver);
 125                 free(link->match_type);
 126                 free(link->description);
 127                 free(link->alias);
 128
 129                 free(link);
 130         }
 131 }
 132
 133 void link_config_ctx_free(link_config_ctx *ctx) {
 134         if (!ctx)
 135                 return;
 136
 137         if (ctx->ethtool_fd >= 0)
 138                 close_nointr_nofail(ctx->ethtool_fd);
 139
 140         sd_rtnl_unref(ctx->rtnl);
 141
 142         strv_free(ctx->link_dirs);
 143         link_configs_free(ctx);
 144
 145         free(ctx);
 146
 147         return;
 148 }
 149
 150 static int load_link(link_config_ctx *ctx, const char *filename) {
 151         link_config *link;
 152         _cleanup_fclose_ FILE *file;
 153         int r;
 154
 155         file = fopen(filename, "re");
 156         if (!file) {
 157                 if (errno == ENOENT)
 158                         return 0;
 159                 else
 160                         return errno;
 161         }
 162
 163         link = new0(link_config, 1);
 164         if (!link) {
 165                 r = log_oom();
 166                 goto failure;
 167         }
 168
 169         link->mac_policy = _MACPOLICY_INVALID;
 170         link->wol = _WOL_INVALID;
 171         link->duplex = _DUP_INVALID;
 172
 173         r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
 174                          (void*) link_config_gperf_lookup, false, false, link);
 175         if (r < 0) {
 176                 log_warning("Could not parse config file %s: %s", filename, strerror(-r));
 177                 goto failure;
 178         } else
 179                 log_debug("Parsed configuration file %s", filename);
 180
 181         link->filename = strdup(filename);
 182
 183         LIST_PREPEND(links, ctx->links, link);
 184
 185         return 0;
 186
 187 failure:
 188         free(link);
 189         return r;
 190 }
 191
 192 static bool enable_name_policy(void) {
 193         _cleanup_free_ char *line;
 194         char *w, *state;
 195         int r;
 196         size_t l;
 197
 198         r = proc_cmdline(&line);
 199         if (r < 0)
 200                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
 201         if (r <= 0)
 202                 return true;
 203
 204         FOREACH_WORD_QUOTED(w, l, line, state)
 205                 if (strneq(w, "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         char **files, **f;
 214
 215         link_configs_free(ctx);
 216
 217         if (!enable_name_policy()) {
 218                 ctx->enable_name_policy = false;
 219                 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
 220         }
 221
 222         /* update timestamp */
 223         paths_check_timestamp(ctx->link_dirs, &ctx->link_dirs_ts_usec, true);
 224
 225         r = conf_files_list_strv(&files, ".link", NULL, (const char **)ctx->link_dirs);
 226         if (r < 0) {
 227                 log_error("failed to enumerate link files: %s", strerror(-r));
 228                 return r;
 229         }
 230
 231         STRV_FOREACH_BACKWARDS(f, files) {
 232                 r = load_link(ctx, *f);
 233                 if (r < 0)
 234                         return r;
 235         }
 236
 237         return 0;
 238 }
 239
 240 bool link_config_should_reload(link_config_ctx *ctx) {
 241         return paths_check_timestamp(ctx->link_dirs, &ctx->link_dirs_ts_usec, false);
 242 }
 243
 244 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
 245         link_config *link;
 246
 247         LIST_FOREACH(links, link, ctx->links) {
 248
 249                 if (net_match_config(link->match_mac, link->match_path,
 250                                      link->match_driver, link->match_type, NULL,
 251                                      udev_device_get_sysattr_value(device, "address"),
 252                                      udev_device_get_property_value(device, "ID_PATH"),
 253                                      udev_device_get_driver(device),
 254                                      udev_device_get_devtype(device),
 255                                      NULL)) {
 256                         log_debug("Config file %s applies to device %s",
 257                                   link->filename,
 258                                   udev_device_get_sysname(device));
 259                         *ret = link;
 260                         return 0;
 261                 }
 262         }
 263
 264         *ret = NULL;
 265
 266         return -ENOENT;
 267 }
 268
 269 static bool mac_is_random(struct udev_device *device) {
 270         const char *s;
 271         unsigned type;
 272         int r;
 273
 274         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 275         if (!s)
 276                 return false; /* if we don't know, assume it is not random */
 277         r = safe_atou(s, &type);
 278         if (r < 0)
 279                 return false;
 280
 281         /* check for NET_ADDR_RANDOM */
 282         return type == 1;
 283 }
 284
 285 static bool mac_is_permanent(struct udev_device *device) {
 286         const char *s;
 287         unsigned type;
 288         int r;
 289
 290         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 291         if (!s)
 292                 return true; /* if we don't know, assume it is permanent */
 293         r = safe_atou(s, &type);
 294         if (r < 0)
 295                 return true;
 296
 297         /* check for NET_ADDR_PERM */
 298         return type == 0;
 299 }
 300
 301 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
 302         unsigned int seed;
 303         int r, i;
 304
 305         if (want_random)
 306                 seed = random_u();
 307         else {
 308                 const char *name;
 309                 sd_id128_t machine;
 310                 char machineid_buf[33];
 311                 const char *seed_str;
 312
 313                 /* fetch some persistent data unique (on this machine) to this device */
 314                 name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 315                 if (!name) {
 316                         name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 317                         if (!name) {
 318                                 name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 319                                 if (!name)
 320                                         return -ENOENT;
 321                         }
 322                 }
 323                 /* fetch some persistent data unique to this machine */
 324                 r = sd_id128_get_machine(&machine);
 325                 if (r < 0)
 326                         return r;
 327
 328                 /* combine the data */
 329                 seed_str = strappenda(name, sd_id128_to_string(machine, machineid_buf));
 330
 331                 /* hash to get seed */
 332                 seed = string_hash_func(seed_str);
 333         }
 334
 335         srandom(seed);
 336
 337         for (i = 0; i < ETH_ALEN; i++) {
 338                 mac->ether_addr_octet[i] = random();
 339         }
 340
 341         /* see eth_random_addr in the kernel */
 342         mac->ether_addr_octet[0] &= 0xfe;        /* clear multicast bit */
 343         mac->ether_addr_octet[0] |= 0x02;        /* set local assignment bit (IEEE802) */
 344
 345         return 0;
 346 }
 347
 348 int link_config_apply(link_config_ctx *ctx, link_config *config, struct udev_device *device, const char **name) {
 349         const char *old_name;
 350         const char *new_name = NULL;
 351         struct ether_addr generated_mac;
 352         struct ether_addr *mac = NULL;
 353         int r, ifindex;
 354
 355         assert(ctx);
 356         assert(config);
 357         assert(device);
 358         assert(name);
 359
 360         r = link_config_ctx_connect(ctx);
 361         if (r < 0)
 362                 return r;
 363
 364         old_name = udev_device_get_sysname(device);
 365         if (!old_name)
 366                 return -EINVAL;
 367
 368         r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed, config->duplex);
 369         if (r < 0)
 370                 log_warning("Could not set speed or duplex of %s to %u Mbytes (%s): %s",
 371                              old_name, config->speed, duplex_to_string(config->duplex), 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_ONBOARD:
 390                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 391                                         break;
 392                                 case NAMEPOLICY_SLOT:
 393                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 394                                         break;
 395                                 case NAMEPOLICY_PATH:
 396                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 397                                         break;
 398                                 case NAMEPOLICY_MAC:
 399                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
 400                                         break;
 401                                 default:
 402                                         break;
 403                         }
 404                 }
 405         }
 406
 407         if (new_name)
 408                 *name = new_name; /* a name was set by a policy */
 409         else if (config->name)
 410                 *name = config->name; /* a name was set manually in the config */
 411         else
 412                 *name = NULL;
 413
 414         switch (config->mac_policy) {
 415                 case MACPOLICY_PERSISTENT:
 416                         if (!mac_is_permanent(device)) {
 417                                 r = get_mac(device, false, &generated_mac);
 418                                 if (r < 0)
 419                                         return r;
 420                                 mac = &generated_mac;
 421                         }
 422                         break;
 423                 case MACPOLICY_RANDOM:
 424                         if (!mac_is_random(device)) {
 425                                 r = get_mac(device, true, &generated_mac);
 426                                 if (r < 0)
 427                                         return r;
 428                                 mac = &generated_mac;
 429                         }
 430                         break;
 431                 default:
 432                         mac = config->mac;
 433         }
 434
 435         r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
 436         if (r < 0) {
 437                 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
 438                 return r;
 439         }
 440
 441         return 0;
 442 }
 443
 444 static const char* const mac_policy_table[] = {
 445         [MACPOLICY_PERSISTENT] = "persistent",
 446         [MACPOLICY_RANDOM] = "random"
 447 };
 448
 449 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
 450 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy, "Failed to parse MAC address policy");
 451
 452 static const char* const name_policy_table[] = {
 453         [NAMEPOLICY_ONBOARD] = "onboard",
 454         [NAMEPOLICY_SLOT] = "slot",
 455         [NAMEPOLICY_PATH] = "path",
 456         [NAMEPOLICY_MAC] = "mac"
 457 };
 458
 459 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
 460 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy, _NAMEPOLICY_INVALID, "Failed to parse interface name policy");