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 == -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 if (ctx->ethtool_fd >= 0)
131 close_nointr_nofail(ctx->ethtool_fd);
133 sd_rtnl_unref(ctx->rtnl);
135 link_configs_free(ctx);
142 static int load_link(link_config_ctx *ctx, const char *filename) {
144 _cleanup_fclose_ FILE *file;
150 file = fopen(filename, "re");
158 link = new0(link_config, 1);
164 link->mac_policy = _MACPOLICY_INVALID;
165 link->wol = _WOL_INVALID;
166 link->duplex = _DUP_INVALID;
168 r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
169 (void*) link_config_gperf_lookup, false, false, link);
171 log_warning("Could not parse config file %s: %s", filename, strerror(-r));
174 log_debug("Parsed configuration file %s", filename);
176 link->filename = strdup(filename);
178 LIST_PREPEND(links, ctx->links, link);
187 static bool enable_name_policy(void) {
188 _cleanup_free_ char *line;
193 r = proc_cmdline(&line);
195 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
199 FOREACH_WORD_QUOTED(w, l, line, state)
200 if (strneq(w, "net.ifnames=0", l))
206 int link_config_load(link_config_ctx *ctx) {
210 link_configs_free(ctx);
212 if (!enable_name_policy()) {
213 ctx->enable_name_policy = false;
214 log_info("Network interface NamePolicy= disabled on kernel commandline, ignoring.");
217 /* update timestamp */
218 paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, true);
220 r = conf_files_list_strv(&files, ".link", NULL, link_dirs);
222 log_error("failed to enumerate link files: %s", strerror(-r));
226 STRV_FOREACH_BACKWARDS(f, files) {
227 r = load_link(ctx, *f);
235 bool link_config_should_reload(link_config_ctx *ctx) {
236 return paths_check_timestamp(link_dirs, &ctx->link_dirs_ts_usec, false);
239 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
242 LIST_FOREACH(links, link, ctx->links) {
244 if (net_match_config(link->match_mac, link->match_path, link->match_driver,
245 link->match_type, NULL, link->match_host,
246 link->match_virt, link->match_kernel, link->match_arch,
247 udev_device_get_sysattr_value(device, "address"),
248 udev_device_get_property_value(device, "ID_PATH"),
249 udev_device_get_driver(udev_device_get_parent(device)),
250 udev_device_get_property_value(device, "ID_NET_DRIVER"),
251 udev_device_get_devtype(device),
253 log_debug("Config file %s applies to device %s",
255 udev_device_get_sysname(device));
266 static bool mac_is_random(struct udev_device *device) {
271 s = udev_device_get_sysattr_value(device, "addr_assign_type");
273 return false; /* if we don't know, assume it is not random */
274 r = safe_atou(s, &type);
278 /* check for NET_ADDR_RANDOM */
282 static bool mac_is_permanent(struct udev_device *device) {
287 s = udev_device_get_sysattr_value(device, "addr_assign_type");
289 return true; /* if we don't know, assume it is permanent */
290 r = safe_atou(s, &type);
294 /* check for NET_ADDR_PERM */
298 #define HASH_KEY SD_ID128_MAKE(d3,1e,48,fa,90,fe,4b,4c,9d,af,d5,d7,a1,b1,2e,8a)
300 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
304 random_bytes(mac->ether_addr_octet, ETH_ALEN);
311 /* fetch some persistent data unique (on this machine) to this device */
312 name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
314 name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
316 name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
323 sz = sizeof(sd_id128_t) + l;
326 /* fetch some persistent data unique to this machine */
327 r = sd_id128_get_machine((sd_id128_t*) v);
330 memcpy(v + sizeof(sd_id128_t), name, l);
332 /* Let's hash the machine ID plus the device name. We
333 * use a fixed, but originally randomly created hash
335 siphash24(result, v, sz, HASH_KEY.bytes);
337 assert_cc(ETH_ALEN <= sizeof(result));
338 memcpy(mac->ether_addr_octet, result, ETH_ALEN);
341 /* see eth_random_addr in the kernel */
342 mac->ether_addr_octet[0] &= 0xfe; /* clear multicast bit */
343 mac->ether_addr_octet[0] |= 0x02; /* set local assignment bit (IEEE802) */
348 int link_config_apply(link_config_ctx *ctx, link_config *config, struct udev_device *device, const char **name) {
349 const char *old_name;
350 const char *new_name = NULL;
351 struct ether_addr generated_mac;
352 struct ether_addr *mac = NULL;
360 r = link_config_ctx_connect(ctx);
364 old_name = udev_device_get_sysname(device);
368 r = ethtool_set_speed(ctx->ethtool_fd, old_name, config->speed / 1024, config->duplex);
370 log_warning("Could not set speed or duplex of %s to %u Mbps (%s): %s",
371 old_name, config->speed / 1024, duplex_to_string(config->duplex),
374 r = ethtool_set_wol(ctx->ethtool_fd, old_name, config->wol);
376 log_warning("Could not set WakeOnLan of %s to %s: %s",
377 old_name, wol_to_string(config->wol), strerror(-r));
379 ifindex = udev_device_get_ifindex(device);
381 log_warning("Could not find ifindex");
385 if (ctx->enable_name_policy && config->name_policy) {
388 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
390 case NAMEPOLICY_DATABASE:
391 new_name = udev_device_get_property_value(device, "ID_NET_NAME_FROM_DATABASE");
393 case NAMEPOLICY_ONBOARD:
394 new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
396 case NAMEPOLICY_SLOT:
397 new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
399 case NAMEPOLICY_PATH:
400 new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
403 new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
412 *name = new_name; /* a name was set by a policy */
413 else if (config->name)
414 *name = config->name; /* a name was set manually in the config */
418 switch (config->mac_policy) {
419 case MACPOLICY_PERSISTENT:
420 if (!mac_is_permanent(device)) {
421 r = get_mac(device, false, &generated_mac);
424 mac = &generated_mac;
427 case MACPOLICY_RANDOM:
428 if (!mac_is_random(device)) {
429 r = get_mac(device, true, &generated_mac);
432 mac = &generated_mac;
439 r = rtnl_set_link_properties(ctx->rtnl, ifindex, config->alias, mac, config->mtu);
441 log_warning("Could not set Alias, MACAddress or MTU on %s: %s", old_name, strerror(-r));
448 int link_get_driver(link_config_ctx *ctx, struct udev_device *device, char **ret) {
453 r = link_config_ctx_connect(ctx);
457 name = udev_device_get_sysname(device);
461 r = ethtool_get_driver(ctx->ethtool_fd, name, &driver);
469 static const char* const mac_policy_table[] = {
470 [MACPOLICY_PERSISTENT] = "persistent",
471 [MACPOLICY_RANDOM] = "random"
474 DEFINE_STRING_TABLE_LOOKUP(mac_policy, MACPolicy);
475 DEFINE_CONFIG_PARSE_ENUM(config_parse_mac_policy, mac_policy, MACPolicy, "Failed to parse MAC address policy");
477 static const char* const name_policy_table[] = {
478 [NAMEPOLICY_DATABASE] = "database",
479 [NAMEPOLICY_ONBOARD] = "onboard",
480 [NAMEPOLICY_SLOT] = "slot",
481 [NAMEPOLICY_PATH] = "path",
482 [NAMEPOLICY_MAC] = "mac"
485 DEFINE_STRING_TABLE_LOOKUP(name_policy, NamePolicy);
486 DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy, _NAMEPOLICY_INVALID, "Failed to parse interface name policy");