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 "network-internal.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         _cleanup_free_ link_config *link = NULL;
 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                 return log_oom();
 160
 161         link->mac_policy = _MACPOLICY_INVALID;
 162         link->wol = _WOL_INVALID;
 163         link->duplex = _DUP_INVALID;
 164
 165         r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
 166                          (void*) link_config_gperf_lookup, false, false, link);
 167         if (r < 0) {
 168                 log_warning("Could not parse config file %s: %s", filename, strerror(-r));
 169                 return r;
 170         } else
 171                 log_debug("Parsed configuration file %s", filename);
 172
 173         link->filename = strdup(filename);
 174
 175         LIST_PREPEND(links, ctx->links, link);
 176         link = NULL;
 177
 178         return 0;
 179 }
 180
 181 static bool enable_name_policy(void) {
 182         _cleanup_free_ char *line;
 183         char *w, *state;
 184         int r;
 185         size_t l;
 186
 187         r = proc_cmdline(&line);
 188         if (r < 0)
 189                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
 190         if (r <= 0)
 191                 return true;
 192
 193         FOREACH_WORD_QUOTED(w, l, line, state)
 194                 if (strneq(w, "net.ifnames=0", l))
 195                         return false;
 196
 197         return true;
 198 }
 199
 200 int link_config_load(link_config_ctx *ctx) {
 201         int r;
 202         char **files, **f;
 203
 204         link_configs_free(ctx);
 205
 206         if (!enable_name_policy()) {
 207                 ctx->enable_name_policy = false;
 208                 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
 209         }
 210
 211         /* update timestamp */
 212         paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
 213
 214         r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
 215         if (r < 0) {
 216                 log_error("failed to enumerate link files: %s", strerror(-r));
 217                 return r;
 218         }
 219
 220         STRV_FOREACH_BACKWARDS(f, files) {
 221                 r = load_link(ctx, *f);
 222                 if (r < 0)
 223                         return r;
 224         }
 225
 226         return 0;
 227 }
 228
 229 bool link_config_should_reload(link_config_ctx *ctx) {
 230         return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
 231 }
 232
 233 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
 234         link_config *link;
 235
 236         LIST_FOREACH(links, link, ctx->links) {
 237
 238                 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
 239                                      link->match_type, NULL, link->match_host,
 240                                      link->match_virt, link->match_kernel, link->match_arch,
 241                                      ether_aton(udev_device_get_sysattr_value(device, "address")),
 242                                      udev_device_get_property_value(device, "ID_PATH"),
 243                                      udev_device_get_driver(udev_device_get_parent(device)),
 244                                      udev_device_get_property_value(device, "ID_NET_DRIVER"),
 245                                      udev_device_get_devtype(device),
 246                                      NULL)) {
 247                         log_debug("Config file %s applies to device %s",
 248                                   link->filename,
 249                                   udev_device_get_sysname(device));
 250                         *ret = link;
 251                         return 0;
 252                 }
 253         }
 254
 255         *ret = NULL;
 256
 257         return -ENOENT;
 258 }
 259
 260 static bool mac_is_random(struct udev_device *device) {
 261         const char *s;
 262         unsigned type;
 263         int r;
 264
 265         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 266         if (!s)
 267                 return false; /* if we don't know, assume it is not random */
 268         r = safe_atou(s, &type);
 269         if (r < 0)
 270                 return false;
 271
 272         /* check for NET_ADDR_RANDOM */
 273         return type == 1;
 274 }
 275
 276 static bool mac_is_permanent(struct udev_device *device) {
 277         const char *s;
 278         unsigned type;
 279         int r;
 280
 281         s = udev_device_get_sysattr_value(device, "addr_assign_type");
 282         if (!s)
 283                 return true; /* if we don't know, assume it is permanent */
 284         r = safe_atou(s, &type);
 285         if (r < 0)
 286                 return true;
 287
 288         /* check for NET_ADDR_PERM */
 289         return type == 0;
 290 }
 291
 292 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
 293         int r;
 294
 295         if (want_random)
 296                 random_bytes(mac->ether_addr_octet, ETH_ALEN);
 297         else {
 298                 uint8_t result[8];
 299
 300                 r = net_get_unique_predictable_data(device, result);
 301                 if (r < 0)
 302                         return r;
 303
 304                 assert_cc(ETH_ALEN <= sizeof(result));
 305                 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
 306         }
 307
 308         /* see eth_random_addr in the kernel */
 309         mac->ether_addr_octet[0] &= 0xfe;        /* clear multicast bit */
 310         mac->ether_addr_octet[0] |= 0x02;        /* set local assignment bit (IEEE802) */
 311
 312         return 0;
 313 }
 314
 315 int link_config_apply(link_config_ctx *ctx, link_config *config, struct udev_device *device, const char **name) {
 316         const char *old_name;
 317         const char *new_name = NULL;
 318         struct ether_addr generated_mac;
 319         struct ether_addr *mac = NULL;
 320         int r, ifindex;
 321
 322         assert(ctx);
 323         assert(config);
 324         assert(device);
 325         assert(name);
 326
 327         r = link_config_ctx_connect(ctx);
 328         if (r < 0)
 329                 return r;
 330
 331         old_name = udev_device_get_sysname(device);
 332         if (!old_name)
 333                 return -EINVAL;
 334
 335         r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed / 1024, config->duplex);
 336         if (r < 0)
 337                 log_warning("Could not set speed or duplex of %s to %u Mbps (%s): %s",
 338                             old_name, config->speed / 1024, duplex_to_string(config->duplex),
 339                             strerror(-r));
 340
 341         r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
 342         if (r < 0)
 343                 log_warning("Could not set WakeOnLan of %s to %s: %s",
 344                             old_name, wol_to_string(config->wol), strerror(-r));
 345
 346         ifindex = udev_device_get_ifindex(device);
 347         if (ifindex <= 0) {
 348                 log_warning("Could not find ifindex");
 349                 return -ENODEV;
 350         }
 351
 352         if (ctx->enable_name_policy && config->name_policy) {
 353                 NamePolicy *policy;
 354
 355                 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
 356                         switch (*policy) {
 357                                 case NAMEPOLICY_DATABASE:
 358                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
 359                                         break;
 360                                 case NAMEPOLICY_ONBOARD:
 361                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
 362                                         break;
 363                                 case NAMEPOLICY_SLOT:
 364                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
 365                                         break;
 366                                 case NAMEPOLICY_PATH:
 367                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
 368                                         break;
 369                                 case NAMEPOLICY_MAC:
 370                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
 371                                         break;
 372                                 default:
 373                                         break;
 374                         }
 375                 }
 376         }
 377
 378         if (new_name)
 379                 *name = new_name; /* a name was set by a policy */
 380         else if (config->name)
 381                 *name = config->name; /* a name was set manually in the config */
 382         else
 383                 *name = NULL;
 384
 385         switch (config->mac_policy) {
 386                 case MACPOLICY_PERSISTENT:
 387                         if (!mac_is_permanent(device)) {
 388                                 r = get_mac(device, false, &generated_mac);
 389                                 if (r < 0)
 390                                         return r;
 391                                 mac = &generated_mac;
 392                         }
 393                         break;
 394                 case MACPOLICY_RANDOM:
 395                         if (!mac_is_random(device)) {
 396                                 r = get_mac(device, true, &generated_mac);
 397                                 if (r < 0)
 398                                         return r;
 399                                 mac = &generated_mac;
 400                         }
 401                         break;
 402                 default:
 403                         mac = config->mac;
 404         }
 405
 406         r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
 407         if (r < 0) {
 408                 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
 409                 return r;
 410         }
 411
 412         return 0;
 413 }
 414
 415 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
 416         const char *name;
 417         char *driver;
 418         int r;
 419
 420         r = link_config_ctx_connect(ctx);
 421         if (r < 0)
 422                 return r;
 423
 424         name = udev_device_get_sysname(device);
 425         if (!name)
 426                 return -EINVAL;
 427
 428         r = ethtool_get_driver(ctx->ethtool_fd, name, &driver);
 429         if (r < 0)
 430                 return r;
 431
 432         *ret = driver;
 433         return 0;
 434 }
 435
 436 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
 437         [MACPOLICY_PERSISTENT] = "persistent",
 438         [MACPOLICY_RANDOM] = "random"
 439 };
 440
 441 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
 442 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy, "Failed to parse MAC address policy");
 443
 444 static const char* const name_policy_table[_NAMEPOLICY_MAX] = {
 445         [NAMEPOLICY_DATABASE] = "database",
 446         [NAMEPOLICY_ONBOARD] = "onboard",
 447         [NAMEPOLICY_SLOT] = "slot",
 448         [NAMEPOLICY_PATH] = "path",
 449         [NAMEPOLICY_MAC] = "mac"
 450 };
 451
 452 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
 453 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy, _NAMEPOLICY_INVALID, "Failed to parse interface name policy");