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"
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 >= 0 && ctx->rtnl)
96 r = ethtool_connect(&ctx->ethtool_fd);
100 r = sd_rtnl_open(&ctx->rtnl, 0);
107 static void link_configs_free(link_config_ctx *ctx) {
108 link_config *link, *link_next;
113 LIST_FOREACH_SAFE(links, link, link_next, ctx->links) {
114 free(link->filename);
115 free(link->match_path);
116 free(link->match_driver);
117 free(link->match_type);
118 free(link->description);
125 void link_config_ctx_free(link_config_ctx *ctx) {
129 if (ctx->ethtool_fd >= 0)
130 close_nointr_nofail(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) {
143 _cleanup_fclose_ FILE *file;
149 file = fopen(filename, "re");
157 link = new0(link_config, 1);
163 link->mac_policy = _MACPOLICY_INVALID;
164 link->wol = _WOL_INVALID;
165 link->duplex = _DUP_INVALID;
167 r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
168 (void*) link_config_gperf_lookup, false, false, link);
170 log_warning("Could not parse config file %s: %s", filename, strerror(-r));
173 log_debug("Parsed configuration file %s", filename);
175 link->filename = strdup(filename);
177 LIST_PREPEND(links, ctx->links, link);
186 static bool enable_name_policy(void) {
187 _cleanup_free_ char *line;
192 r = proc_cmdline(&line);
194 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
198 FOREACH_WORD_QUOTED(w, l, line, state)
199 if (strneq(w, "net.ifnames=0", l))
205 int link_config_load(link_config_ctx *ctx) {
209 link_configs_free(ctx);
211 if (!enable_name_policy()) {
212 ctx->enable_name_policy = false;
213 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
216 /* update timestamp */
217 paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
219 r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
221 log_error("failed to enumerate link files: %s", strerror(-r));
225 STRV_FOREACH_BACKWARDS(f, files) {
226 r = load_link(ctx, *f);
234 bool link_config_should_reload(link_config_ctx *ctx) {
235 return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
238 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
241 LIST_FOREACH(links, link, ctx->links) {
243 if (net_match_config(link->match_mac, link->match_path,
244 link->match_driver, link->match_type, NULL,
245 link->match_host, link->match_virt, link->match_kernel,
246 udev_device_get_sysattr_value(device, "address"),
247 udev_device_get_property_value(device, "ID_PATH"),
248 udev_device_get_driver(udev_device_get_parent(device)),
249 udev_device_get_devtype(device),
251 log_debug("Config file %s applies to device %s",
253 udev_device_get_sysname(device));
264 static bool mac_is_random(struct udev_device *device) {
269 s = udev_device_get_sysattr_value(device, "addr_assign_type");
271 return false; /* if we don't know, assume it is not random */
272 r = safe_atou(s, &type);
276 /* check for NET_ADDR_RANDOM */
280 static bool mac_is_permanent(struct udev_device *device) {
285 s = udev_device_get_sysattr_value(device, "addr_assign_type");
287 return true; /* if we don't know, assume it is permanent */
288 r = safe_atou(s, &type);
292 /* check for NET_ADDR_PERM */
296 #define HASH_KEY SD_ID128_MAKE(d3,1e,48,fa,90,fe,4b,4c,9d,af,d5,d7,a1,b1,2e,8a)
298 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
302 random_bytes(mac->ether_addr_octet, ETH_ALEN);
309 /* fetch some persistent data unique (on this machine) to this device */
310 name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
312 name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
314 name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
321 sz = sizeof(sd_id128_t) + l;
324 /* fetch some persistent data unique to this machine */
325 r = sd_id128_get_machine((sd_id128_t*) v);
328 memcpy(v + sizeof(sd_id128_t), name, l);
330 /* Let's hash the machine ID plus the device name. We
331 * use a fixed, but originally randomly created hash
333 siphash24(result, v, sz, HASH_KEY.bytes);
335 assert_cc(ETH_ALEN <= sizeof(result));
336 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
339 /* see eth_random_addr in the kernel */
340 mac->ether_addr_octet[0] &= 0xfe; /* clear multicast bit */
341 mac->ether_addr_octet[0] |= 0x02; /* set local assignment bit (IEEE802) */
346 int link_config_apply(link_config_ctx *ctx, link_config *config, struct udev_device *device, const char **name) {
347 const char *old_name;
348 const char *new_name = NULL;
349 struct ether_addr generated_mac;
350 struct ether_addr *mac = NULL;
358 r = link_config_ctx_connect(ctx);
362 old_name = udev_device_get_sysname(device);
366 r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed, config->duplex);
368 log_warning("Could not set speed or duplex of %s to %u Mbytes (%s): %s",
369 old_name, config->speed, duplex_to_string(config->duplex), strerror(-r));
371 r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
373 log_warning("Could not set WakeOnLan of %s to %s: %s",
374 old_name, wol_to_string(config->wol), strerror(-r));
376 ifindex = udev_device_get_ifindex(device);
378 log_warning("Could not find ifindex");
382 if (ctx->enable_name_policy && config->name_policy) {
385 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
387 case NAMEPOLICY_DATABASE:
388 new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
390 case NAMEPOLICY_ONBOARD:
391 new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
393 case NAMEPOLICY_SLOT:
394 new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
396 case NAMEPOLICY_PATH:
397 new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
400 new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
409 *name = new_name; /* a name was set by a policy */
410 else if (config->name)
411 *name = config->name; /* a name was set manually in the config */
415 switch (config->mac_policy) {
416 case MACPOLICY_PERSISTENT:
417 if (!mac_is_permanent(device)) {
418 r = get_mac(device, false, &generated_mac);
421 mac = &generated_mac;
424 case MACPOLICY_RANDOM:
425 if (!mac_is_random(device)) {
426 r = get_mac(device, true, &generated_mac);
429 mac = &generated_mac;
436 r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
438 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
445 static const char* const mac_policy_table[] = {
446 [MACPOLICY_PERSISTENT] = "persistent",
447 [MACPOLICY_RANDOM] = "random"
450 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
451 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy, "Failed to parse MAC address policy");
453 static const char* const name_policy_table[] = {
454 [NAMEPOLICY_DATABASE] = "database",
455 [NAMEPOLICY_ONBOARD] = "onboard",
456 [NAMEPOLICY_SLOT] = "slot",
457 [NAMEPOLICY_PATH] = "path",
458 [NAMEPOLICY_MAC] = "mac"
461 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
462 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy, _NAMEPOLICY_INVALID, "Failed to parse interface name policy");