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 int link_config_ctx_connect(link_config_ctx *ctx) {
93 if (ctx->ethtool_fd == -1) {
94 r = ethtool_connect(&ctx->ethtool_fd);
100 r = sd_rtnl_open(&ctx->rtnl, 0);
108 static void link_configs_free(link_config_ctx *ctx) {
109 link_config *link, *link_next;
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);
126 void link_config_ctx_free(link_config_ctx *ctx) {
130 safe_close(ctx->ethtool_fd);
132 sd_rtnl_unref(ctx->rtnl);
134 link_configs_free(ctx);
141 static int load_link(link_config_ctx *ctx, const char *filename) {
142 _cleanup_free_ link_config *link = NULL;
143 _cleanup_fclose_ FILE *file;
149 file = fopen(filename, "re");
157 link = new0(link_config, 1);
161 link->mac_policy = _MACPOLICY_INVALID;
162 link->wol = _WOL_INVALID;
163 link->duplex = _DUP_INVALID;
165 r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
166 (void*) link_config_gperf_lookup, false, false, link);
168 log_warning("Could not parse config file %s: %s", filename, strerror(-r));
171 log_debug("Parsed configuration file %s", filename);
173 link->filename = strdup(filename);
175 LIST_PREPEND(links, ctx->links, link);
181 static bool enable_name_policy(void) {
182 _cleanup_free_ char *line;
187 r = proc_cmdline(&line);
189 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
193 FOREACH_WORD_QUOTED(w, l, line, state)
194 if (strneq(w, "net.ifnames=0", l))
200 int link_config_load(link_config_ctx *ctx) {
204 link_configs_free(ctx);
206 if (!enable_name_policy()) {
207 ctx->enable_name_policy = false;
208 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
211 /* update timestamp */
212 paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
214 r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
216 log_error("failed to enumerate link files: %s", strerror(-r));
220 STRV_FOREACH_BACKWARDS(f, files) {
221 r = load_link(ctx, *f);
229 bool link_config_should_reload(link_config_ctx *ctx) {
230 return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
233 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
236 LIST_FOREACH(links, link, ctx->links) {
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 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),
247 log_debug("Config file %s applies to device %s",
249 udev_device_get_sysname(device));
260 static bool mac_is_random(struct udev_device *device) {
265 s = udev_device_get_sysattr_value(device, "addr_assign_type");
267 return false; /* if we don't know, assume it is not random */
268 r = safe_atou(s, &type);
272 /* check for NET_ADDR_RANDOM */
276 static bool mac_is_permanent(struct udev_device *device) {
281 s = udev_device_get_sysattr_value(device, "addr_assign_type");
283 return true; /* if we don't know, assume it is permanent */
284 r = safe_atou(s, &type);
288 /* check for NET_ADDR_PERM */
292 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
296 random_bytes(mac->ether_addr_octet, ETH_ALEN);
300 r = net_get_unique_predictable_data(device, result);
304 assert_cc(ETH_ALEN <= sizeof(result));
305 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
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) */
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;
327 r = link_config_ctx_connect(ctx);
331 old_name = udev_device_get_sysname(device);
335 r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed / 1024, config->duplex);
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),
341 r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
343 log_warning("Could not set WakeOnLan of %s to %s: %s",
344 old_name, wol_to_string(config->wol), strerror(-r));
346 ifindex = udev_device_get_ifindex(device);
348 log_warning("Could not find ifindex");
352 if (ctx->enable_name_policy && config->name_policy) {
355 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
357 case NAMEPOLICY_DATABASE:
358 new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
360 case NAMEPOLICY_ONBOARD:
361 new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
363 case NAMEPOLICY_SLOT:
364 new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
366 case NAMEPOLICY_PATH:
367 new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
370 new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
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 */
385 switch (config->mac_policy) {
386 case MACPOLICY_PERSISTENT:
387 if (!mac_is_permanent(device)) {
388 r = get_mac(device, false, &generated_mac);
391 mac = &generated_mac;
394 case MACPOLICY_RANDOM:
395 if (!mac_is_random(device)) {
396 r = get_mac(device, true, &generated_mac);
399 mac = &generated_mac;
406 r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
408 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
415 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
420 r = link_config_ctx_connect(ctx);
424 name = udev_device_get_sysname(device);
428 r = ethtool_get_driver(ctx->ethtool_fd, name, &driver);
436 static const char* const mac_policy_table[_MACPOLICY_MAX] = {
437 [MACPOLICY_PERSISTENT] = "persistent",
438 [MACPOLICY_RANDOM] = "random"
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");
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"
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");