1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
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.
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.
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/>.
22 #include <netinet/ether.h>
23 #include <linux/netdevice.h>
28 #include "link-config.h"
29 #include "ethtool-util.h"
31 #include "libudev-private.h"
36 #include "path-util.h"
37 #include "conf-parser.h"
38 #include "conf-files.h"
41 #include "rtnl-util.h"
42 #include "network-internal.h"
43 #include "siphash24.h"
45 struct link_config_ctx {
46 LIST_HEAD(link_config, links);
50 bool enable_name_policy;
54 usec_t link_dirs_ts_usec;
57 static const char* const link_dirs[] = {
58 "/etc/systemd/network",
59 "/run/systemd/network",
60 "/usr/lib/systemd/network",
62 "/lib/systemd/network",
66 DEFINE_TRIVIAL_CLEANUP_FUNC(link_config_ctx*, link_config_ctx_free);
67 #define _cleanup_link_config_ctx_free_ _cleanup_(link_config_ctx_freep)
69 int link_config_ctx_new(link_config_ctx **ret) {
70 _cleanup_link_config_ctx_free_ link_config_ctx *ctx = NULL;
75 ctx = new0(link_config_ctx, 1);
79 LIST_HEAD_INIT(ctx->links);
83 ctx->enable_name_policy = true;
91 static int link_config_ctx_connect(link_config_ctx *ctx) {
94 if (ctx->ethtool_fd == -1) {
95 r = ethtool_connect(&ctx->ethtool_fd);
97 log_warning("link_config: could not connect to ethtool: %s",
104 r = sd_rtnl_open(&ctx->rtnl, 0);
106 log_warning("link_config: could not connect to rtnl: %s",
115 static void link_configs_free(link_config_ctx *ctx) {
116 link_config *link, *link_next;
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);
128 free(link->name_policy);
134 void link_config_ctx_free(link_config_ctx *ctx) {
138 safe_close(ctx->ethtool_fd);
140 sd_rtnl_unref(ctx->rtnl);
142 link_configs_free(ctx);
149 static int load_link(link_config_ctx *ctx, const char *filename) {
150 _cleanup_free_ link_config *link = NULL;
151 _cleanup_fclose_ FILE *file = NULL;
157 file = fopen(filename, "re");
165 if (null_or_empty_fd(fileno(file))) {
166 log_debug("Skipping empty file: %s", filename);
170 link = new0(link_config, 1);
174 link->mac_policy = _MACPOLICY_INVALID;
175 link->wol = _WOL_INVALID;
176 link->duplex = _DUP_INVALID;
178 r = config_parse(NULL, filename, file,
179 "Match\0Link\0Ethernet\0",
180 config_item_perf_lookup, link_config_gperf_lookup,
181 false, false, true, link);
185 log_debug("Parsed configuration file %s", filename);
187 link->filename = strdup(filename);
189 LIST_PREPEND(links, ctx->links, link);
195 static bool enable_name_policy(void) {
196 _cleanup_free_ char *line = NULL;
197 const char *word, *state;
201 r = proc_cmdline(&line);
203 log_warning("Failed to read /proc/cmdline, ignoring: %s",
208 FOREACH_WORD_QUOTED(word, l, line, state)
209 if (strneq(word, "net.ifnames=0", l))
215 int link_config_load(link_config_ctx *ctx) {
217 _cleanup_strv_free_ char **files;
220 link_configs_free(ctx);
222 if (!enable_name_policy()) {
223 ctx->enable_name_policy = false;
224 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
227 /* update timestamp */
228 paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
230 r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
232 log_error("failed to enumerate link files: %s", strerror(-r));
236 STRV_FOREACH_BACKWARDS(f, files) {
237 r = load_link(ctx, *f);
245 bool link_config_should_reload(link_config_ctx *ctx) {
246 return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
249 int link_config_get(link_config_ctx *ctx, struct udev_device *device,
253 LIST_FOREACH(links, link, ctx->links) {
254 const char* attr_value = udev_device_get_sysattr_value(device, "address");
256 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
257 link->match_type, NULL, link->match_host,
258 link->match_virt, link->match_kernel, link->match_arch,
259 attr_value ? ether_aton(attr_value) : NULL,
260 udev_device_get_property_value(device, "ID_PATH"),
261 udev_device_get_driver(udev_device_get_parent(device)),
262 udev_device_get_property_value(device, "ID_NET_DRIVER"),
263 udev_device_get_devtype(device),
265 log_debug("Config file %s applies to device %s",
267 udev_device_get_sysname(device));
278 static bool mac_is_random(struct udev_device *device) {
283 /* if we can't get the assign type, assume it is not random */
284 s = udev_device_get_sysattr_value(device, "addr_assign_type");
288 r = safe_atou(s, &type);
292 return type == NET_ADDR_RANDOM;
295 static bool should_rename(struct udev_device *device, bool respect_predictable) {
300 /* if we can't get the assgin type, assume we should rename */
301 s = udev_device_get_sysattr_value(device, "name_assign_type");
305 r = safe_atou(s, &type);
311 case NET_NAME_RENAMED:
312 /* these were already named by userspace, do not touch again */
314 case NET_NAME_PREDICTABLE:
315 /* the kernel claims to have given a predictable name */
316 if (respect_predictable)
321 /* the name is known to be bad, or of an unknown type */
326 static int get_mac(struct udev_device *device, bool want_random,
327 struct ether_addr *mac) {
331 random_bytes(mac->ether_addr_octet, ETH_ALEN);
335 r = net_get_unique_predictable_data(device, result);
339 assert_cc(ETH_ALEN <= sizeof(result));
340 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
343 /* see eth_random_addr in the kernel */
344 mac->ether_addr_octet[0] &= 0xfe; /* clear multicast bit */
345 mac->ether_addr_octet[0] |= 0x02; /* set local assignment bit (IEEE802) */
350 int link_config_apply(link_config_ctx *ctx, link_config *config,
351 struct udev_device *device, const char **name) {
352 const char *old_name;
353 const char *new_name = NULL;
354 struct ether_addr generated_mac;
355 struct ether_addr *mac = NULL;
356 bool respect_predictable = false;
364 r = link_config_ctx_connect(ctx);
368 old_name = udev_device_get_sysname(device);
372 r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed / 1024,
375 log_warning("Could not set speed or duplex of %s to %u Mbps (%s): %s",
376 old_name, config->speed / 1024,
377 duplex_to_string(config->duplex), strerror(-r));
379 r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
381 log_warning("Could not set WakeOnLan of %s to %s: %s",
382 old_name, wol_to_string(config->wol), strerror(-r));
384 ifindex = udev_device_get_ifindex(device);
386 log_warning("Could not find ifindex");
390 if (ctx->enable_name_policy && config->name_policy) {
393 for (policy = config->name_policy;
394 !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
396 case NAMEPOLICY_KERNEL:
397 respect_predictable = true;
399 case NAMEPOLICY_DATABASE:
400 new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
402 case NAMEPOLICY_ONBOARD:
403 new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
405 case NAMEPOLICY_SLOT:
406 new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
408 case NAMEPOLICY_PATH:
409 new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
412 new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
420 if (should_rename(device, respect_predictable)) {
421 /* if not set by policy, fall back manually set name */
423 new_name = config->name;
429 switch (config->mac_policy) {
430 case MACPOLICY_PERSISTENT:
431 if (mac_is_random(device)) {
432 r = get_mac(device, false, &generated_mac);
437 mac = &generated_mac;
440 case MACPOLICY_RANDOM:
441 if (!mac_is_random(device)) {
442 r = get_mac(device, true, &generated_mac);
447 mac = &generated_mac;
454 r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac,
457 log_warning("Could not set Alias, MACAddress or MTU on %s: %s",
458 old_name, strerror(-r));
465 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
470 r = link_config_ctx_connect(ctx);
474 name = udev_device_get_sysname(device);
478 r = ethtool_get_driver(ctx->ethtool_fd, name, &driver);
486 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
487 [MACPOLICY_PERSISTENT] = "persistent",
488 [MACPOLICY_RANDOM] = "random"
491 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
492 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy,
493 "Failed to parse MAC address policy");
495 static const char* const name_policy_table[_NAMEPOLICY_MAX] = {
496 [NAMEPOLICY_KERNEL] = "kernel",
497 [NAMEPOLICY_DATABASE] = "database",
498 [NAMEPOLICY_ONBOARD] = "onboard",
499 [NAMEPOLICY_SLOT] = "slot",
500 [NAMEPOLICY_PATH] = "path",
501 [NAMEPOLICY_MAC] = "mac"
504 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
505 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy,
507 "Failed to parse interface name policy");