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 void link_configs_free(link_config_ctx *ctx) {
92 link_config *link, *link_next;
97 LIST_FOREACH_SAFE(links, link, link_next, ctx->links) {
100 free(link->match_path);
101 free(link->match_driver);
102 free(link->match_type);
103 free(link->description);
105 free(link->name_policy);
111 void link_config_ctx_free(link_config_ctx *ctx) {
115 safe_close(ctx->ethtool_fd);
117 sd_rtnl_unref(ctx->rtnl);
119 link_configs_free(ctx);
126 static int load_link(link_config_ctx *ctx, const char *filename) {
127 _cleanup_free_ link_config *link = NULL;
128 _cleanup_fclose_ FILE *file = NULL;
134 file = fopen(filename, "re");
142 if (null_or_empty_fd(fileno(file))) {
143 log_debug("Skipping empty file: %s", filename);
147 link = new0(link_config, 1);
151 link->mac_policy = _MACPOLICY_INVALID;
152 link->wol = _WOL_INVALID;
153 link->duplex = _DUP_INVALID;
155 r = config_parse(NULL, filename, file,
156 "Match\0Link\0Ethernet\0",
157 config_item_perf_lookup, link_config_gperf_lookup,
158 false, false, true, link);
162 log_debug("Parsed configuration file %s", filename);
164 link->filename = strdup(filename);
166 LIST_PREPEND(links, ctx->links, link);
172 static bool enable_name_policy(void) {
173 _cleanup_free_ char *line = NULL;
174 const char *word, *state;
178 r = proc_cmdline(&line);
180 log_warning_errno(r, "Failed to read /proc/cmdline, ignoring: %m");
184 FOREACH_WORD_QUOTED(word, l, line, state)
185 if (strneq(word, "net.ifnames=0", l))
191 int link_config_load(link_config_ctx *ctx) {
193 _cleanup_strv_free_ char **files;
196 link_configs_free(ctx);
198 if (!enable_name_policy()) {
199 ctx->enable_name_policy = false;
200 log_info("Network interface NamePolicy= disabled on kernel command line, ignoring.");
203 /* update timestamp */
204 paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
206 r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
208 return log_error_errno(r, "failed to enumerate link files: %m");
210 STRV_FOREACH_BACKWARDS(f, files) {
211 r = load_link(ctx, *f);
219 bool link_config_should_reload(link_config_ctx *ctx) {
220 return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
223 int link_config_get(link_config_ctx *ctx, struct udev_device *device,
227 LIST_FOREACH(links, link, ctx->links) {
228 const char* attr_value;
230 attr_value = udev_device_get_sysattr_value(device, "address");
232 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
233 link->match_type, link->match_name, link->match_host,
234 link->match_virt, link->match_kernel, link->match_arch,
235 attr_value ? ether_aton(attr_value) : NULL,
236 udev_device_get_property_value(device, "ID_PATH"),
237 udev_device_get_driver(udev_device_get_parent(device)),
238 udev_device_get_property_value(device, "ID_NET_DRIVER"),
239 udev_device_get_devtype(device),
240 udev_device_get_sysname(device))) {
241 if (link->match_name) {
242 unsigned char name_assign_type = NET_NAME_UNKNOWN;
244 attr_value = udev_device_get_sysattr_value(device, "name_assign_type");
246 (void)safe_atou8(attr_value, &name_assign_type);
248 if (name_assign_type == NET_NAME_ENUM) {
249 log_warning("Config file %s applies to device based on potentially unstable interface name '%s'",
250 link->filename, udev_device_get_sysname(device));
254 } else if (name_assign_type == NET_NAME_RENAMED) {
255 log_warning("Config file %s matches device based on renamed interface name '%s', ignoring",
256 link->filename, udev_device_get_sysname(device));
258 log_debug("Config file %s applies to device %s",
259 link->filename, udev_device_get_sysname(device));
266 log_debug("Config file %s applies to device %s",
267 link->filename, udev_device_get_sysname(device));
281 static bool mac_is_random(struct udev_device *device) {
286 /* if we can't get the assign type, assume it is not random */
287 s = udev_device_get_sysattr_value(device, "addr_assign_type");
291 r = safe_atou(s, &type);
295 return type == NET_ADDR_RANDOM;
298 static bool should_rename(struct udev_device *device, bool respect_predictable) {
303 /* if we can't get the assgin type, assume we should rename */
304 s = udev_device_get_sysattr_value(device, "name_assign_type");
308 r = safe_atou(s, &type);
314 case NET_NAME_RENAMED:
315 /* these were already named by userspace, do not touch again */
317 case NET_NAME_PREDICTABLE:
318 /* the kernel claims to have given a predictable name */
319 if (respect_predictable)
324 /* the name is known to be bad, or of an unknown type */
329 static int get_mac(struct udev_device *device, bool want_random,
330 struct ether_addr *mac) {
334 random_bytes(mac->ether_addr_octet, ETH_ALEN);
338 r = net_get_unique_predictable_data(device, result);
342 assert_cc(ETH_ALEN <= sizeof(result));
343 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
346 /* see eth_random_addr in the kernel */
347 mac->ether_addr_octet[0] &= 0xfe; /* clear multicast bit */
348 mac->ether_addr_octet[0] |= 0x02; /* set local assignment bit (IEEE802) */
353 int link_config_apply(link_config_ctx *ctx, link_config *config,
354 struct udev_device *device, const char **name) {
355 const char *old_name;
356 const char *new_name = NULL;
357 struct ether_addr generated_mac;
358 struct ether_addr *mac = NULL;
359 bool respect_predictable = false;
367 old_name = udev_device_get_sysname(device);
371 r = ethtool_set_speed(&ctx->ethtool_fd, old_name, config->speed / 1024,
374 log_warning_errno(r, "Could not set speed or duplex of %s to %u Mbps (%s): %m",
375 old_name, config->speed / 1024,
376 duplex_to_string(config->duplex));
378 r = ethtool_set_wol(&ctx->ethtool_fd, old_name, config->wol);
380 log_warning_errno(r, "Could not set WakeOnLan of %s to %s: %m",
381 old_name, wol_to_string(config->wol));
383 ifindex = udev_device_get_ifindex(device);
385 log_warning("Could not find ifindex");
389 if (ctx->enable_name_policy && config->name_policy) {
392 for (policy = config->name_policy;
393 !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
395 case NAMEPOLICY_KERNEL:
396 respect_predictable = true;
398 case NAMEPOLICY_DATABASE:
399 new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
401 case NAMEPOLICY_ONBOARD:
402 new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
404 case NAMEPOLICY_SLOT:
405 new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
407 case NAMEPOLICY_PATH:
408 new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
411 new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
419 if (should_rename(device, respect_predictable)) {
420 /* if not set by policy, fall back manually set name */
422 new_name = config->name;
426 switch (config->mac_policy) {
427 case MACPOLICY_PERSISTENT:
428 if (mac_is_random(device)) {
429 r = get_mac(device, false, &generated_mac);
434 mac = &generated_mac;
437 case MACPOLICY_RANDOM:
438 if (!mac_is_random(device)) {
439 r = get_mac(device, true, &generated_mac);
444 mac = &generated_mac;
451 r = rtnl_set_link_properties(&ctx->rtnl, ifindex, config->alias, mac,
454 return log_warning_errno(r, "Could not set Alias, MACAddress or MTU on %s: %m", old_name);
461 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
466 name = udev_device_get_sysname(device);
470 r = ethtool_get_driver(&ctx->ethtool_fd, name, &driver);
478 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
479 [MACPOLICY_PERSISTENT] = "persistent",
480 [MACPOLICY_RANDOM] = "random"
483 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
484 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy,
485 "Failed to parse MAC address policy");
487 static const char* const name_policy_table[_NAMEPOLICY_MAX] = {
488 [NAMEPOLICY_KERNEL] = "kernel",
489 [NAMEPOLICY_DATABASE] = "database",
490 [NAMEPOLICY_ONBOARD] = "onboard",
491 [NAMEPOLICY_SLOT] = "slot",
492 [NAMEPOLICY_PATH] = "path",
493 [NAMEPOLICY_MAC] = "mac"
496 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
497 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy,
499 "Failed to parse interface name policy");