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>
27 #include "link-config.h"
28 #include "ethtool-util.h"
30 #include "libudev-private.h"
35 #include "path-util.h"
36 #include "conf-parser.h"
37 #include "conf-files.h"
40 #include "rtnl-util.h"
41 #include "network-internal.h"
42 #include "siphash24.h"
44 struct link_config_ctx {
45 LIST_HEAD(link_config, links);
49 bool enable_name_policy;
53 usec_t link_dirs_ts_usec;
56 static const char* const link_dirs[] = {
57 "/etc/systemd/network",
58 "/run/systemd/network",
59 "/usr/lib/systemd/network",
61 "/lib/systemd/network",
65 DEFINE_TRIVIAL_CLEANUP_FUNC(link_config_ctx*, link_config_ctx_free);
66 #define _cleanup_link_config_ctx_free_ _cleanup_(link_config_ctx_freep)
68 int link_config_ctx_new(link_config_ctx **ret) {
69 _cleanup_link_config_ctx_free_ link_config_ctx *ctx = NULL;
74 ctx = new0(link_config_ctx, 1);
78 LIST_HEAD_INIT(ctx->links);
82 ctx->enable_name_policy = true;
90 static void link_configs_free(link_config_ctx *ctx) {
91 link_config *link, *link_next;
96 LIST_FOREACH_SAFE(links, link, link_next, ctx->links) {
98 free(link->match_path);
99 free(link->match_driver);
100 free(link->match_type);
101 free(link->description);
103 free(link->name_policy);
109 void link_config_ctx_free(link_config_ctx *ctx) {
113 safe_close(ctx->ethtool_fd);
115 sd_rtnl_unref(ctx->rtnl);
117 link_configs_free(ctx);
124 static int load_link(link_config_ctx *ctx, const char *filename) {
125 _cleanup_free_ link_config *link = NULL;
126 _cleanup_fclose_ FILE *file = NULL;
132 file = fopen(filename, "re");
140 if (null_or_empty_fd(fileno(file))) {
141 log_debug("Skipping empty file: %s", filename);
145 link = new0(link_config, 1);
149 link->mac_policy = _MACPOLICY_INVALID;
150 link->wol = _WOL_INVALID;
151 link->duplex = _DUP_INVALID;
153 r = config_parse(NULL, filename, file,
154 "Match\0Link\0Ethernet\0",
155 config_item_perf_lookup, link_config_gperf_lookup,
156 false, false, true, link);
160 log_debug("Parsed configuration file %s", filename);
162 link->filename = strdup(filename);
164 LIST_PREPEND(links, ctx->links, link);
170 static bool enable_name_policy(void) {
171 _cleanup_free_ char *line = NULL;
172 const char *word, *state;
176 r = proc_cmdline(&line);
178 log_warning_errno(r, "Failed to read /proc/cmdline, ignoring: %m");
182 FOREACH_WORD_QUOTED(word, l, line, state)
183 if (strneq(word, "net.ifnames=0", l))
189 int link_config_load(link_config_ctx *ctx) {
191 _cleanup_strv_free_ char **files;
194 link_configs_free(ctx);
196 if (!enable_name_policy()) {
197 ctx->enable_name_policy = false;
198 log_info("Network interface NamePolicy= disabled on kernel command line, ignoring.");
201 /* update timestamp */
202 paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
204 r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
206 return log_error_errno(r, "failed to enumerate link files: %m");
208 STRV_FOREACH_BACKWARDS(f, files) {
209 r = load_link(ctx, *f);
217 bool link_config_should_reload(link_config_ctx *ctx) {
218 return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
221 int link_config_get(link_config_ctx *ctx, struct udev_device *device,
225 LIST_FOREACH(links, link, ctx->links) {
226 const char* attr_value = udev_device_get_sysattr_value(device, "address");
228 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
229 link->match_type, NULL, link->match_host,
230 link->match_virt, link->match_kernel, link->match_arch,
231 attr_value ? ether_aton(attr_value) : NULL,
232 udev_device_get_property_value(device, "ID_PATH"),
233 udev_device_get_driver(udev_device_get_parent(device)),
234 udev_device_get_property_value(device, "ID_NET_DRIVER"),
235 udev_device_get_devtype(device),
237 log_debug("Config file %s applies to device %s",
239 udev_device_get_sysname(device));
250 static bool mac_is_random(struct udev_device *device) {
255 /* if we can't get the assign type, assume it is not random */
256 s = udev_device_get_sysattr_value(device, "addr_assign_type");
260 r = safe_atou(s, &type);
264 return type == NET_ADDR_RANDOM;
267 static bool should_rename(struct udev_device *device, bool respect_predictable) {
272 /* if we can't get the assgin type, assume we should rename */
273 s = udev_device_get_sysattr_value(device, "name_assign_type");
277 r = safe_atou(s, &type);
283 case NET_NAME_RENAMED:
284 /* these were already named by userspace, do not touch again */
286 case NET_NAME_PREDICTABLE:
287 /* the kernel claims to have given a predictable name */
288 if (respect_predictable)
293 /* the name is known to be bad, or of an unknown type */
298 static int get_mac(struct udev_device *device, bool want_random,
299 struct ether_addr *mac) {
303 random_bytes(mac->ether_addr_octet, ETH_ALEN);
307 r = net_get_unique_predictable_data(device, result);
311 assert_cc(ETH_ALEN <= sizeof(result));
312 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
315 /* see eth_random_addr in the kernel */
316 mac->ether_addr_octet[0] &= 0xfe; /* clear multicast bit */
317 mac->ether_addr_octet[0] |= 0x02; /* set local assignment bit (IEEE802) */
322 int link_config_apply(link_config_ctx *ctx, link_config *config,
323 struct udev_device *device, const char **name) {
324 const char *old_name;
325 const char *new_name = NULL;
326 struct ether_addr generated_mac;
327 struct ether_addr *mac = NULL;
328 bool respect_predictable = false;
336 old_name = udev_device_get_sysname(device);
340 r = ethtool_set_speed(&ctx->ethtool_fd, old_name, config->speed / 1024,
343 log_warning_errno(r, "Could not set speed or duplex of %s to %u Mbps (%s): %m",
344 old_name, config->speed / 1024,
345 duplex_to_string(config->duplex));
347 r = ethtool_set_wol(&ctx->ethtool_fd, old_name, config->wol);
349 log_warning_errno(r, "Could not set WakeOnLan of %s to %s: %m",
350 old_name, wol_to_string(config->wol));
352 ifindex = udev_device_get_ifindex(device);
354 log_warning("Could not find ifindex");
358 if (ctx->enable_name_policy && config->name_policy) {
361 for (policy = config->name_policy;
362 !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
364 case NAMEPOLICY_KERNEL:
365 respect_predictable = true;
367 case NAMEPOLICY_DATABASE:
368 new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
370 case NAMEPOLICY_ONBOARD:
371 new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
373 case NAMEPOLICY_SLOT:
374 new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
376 case NAMEPOLICY_PATH:
377 new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
380 new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
388 if (should_rename(device, respect_predictable)) {
389 /* if not set by policy, fall back manually set name */
391 new_name = config->name;
395 switch (config->mac_policy) {
396 case MACPOLICY_PERSISTENT:
397 if (mac_is_random(device)) {
398 r = get_mac(device, false, &generated_mac);
403 mac = &generated_mac;
406 case MACPOLICY_RANDOM:
407 if (!mac_is_random(device)) {
408 r = get_mac(device, true, &generated_mac);
413 mac = &generated_mac;
420 r = rtnl_set_link_properties(&ctx->rtnl, ifindex, config->alias, mac,
423 return log_warning_errno(r, "Could not set Alias, MACAddress or MTU on %s: %m", old_name);
430 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
435 name = udev_device_get_sysname(device);
439 r = ethtool_get_driver(&ctx->ethtool_fd, name, &driver);
447 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
448 [MACPOLICY_PERSISTENT] = "persistent",
449 [MACPOLICY_RANDOM] = "random"
452 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
453 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy,
454 "Failed to parse MAC address policy");
456 static const char* const name_policy_table[_NAMEPOLICY_MAX] = {
457 [NAMEPOLICY_KERNEL] = "kernel",
458 [NAMEPOLICY_DATABASE] = "database",
459 [NAMEPOLICY_ONBOARD] = "onboard",
460 [NAMEPOLICY_SLOT] = "slot",
461 [NAMEPOLICY_PATH] = "path",
462 [NAMEPOLICY_MAC] = "mac"
465 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
466 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy,
468 "Failed to parse interface name policy");