chiark / gitweb /
598f93e384cdfaa40627fc62ad279f7047c3ed0f
[elogind.git] / src / udev / net / link-config.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4  This file is part of systemd.
5
6  Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
7
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.
12
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.
17
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/>.
20 ***/
21
22 #include <netinet/ether.h>
23 #include <net/if.h>
24
25 #include "sd-id128.h"
26
27 #include "link-config.h"
28 #include "ethtool-util.h"
29
30 #include "libudev-private.h"
31 #include "sd-rtnl.h"
32 #include "util.h"
33 #include "log.h"
34 #include "strv.h"
35 #include "path-util.h"
36 #include "conf-parser.h"
37 #include "conf-files.h"
38 #include "fileio.h"
39 #include "hashmap.h"
40
41 struct link_config_ctx {
42         LIST_HEAD(link_config, links);
43
44         int ethtool_fd;
45
46         sd_rtnl *rtnl;
47
48         char **link_dirs;
49         usec_t link_dirs_ts_usec;
50 };
51
52 int link_config_ctx_new(link_config_ctx **ret) {
53         link_config_ctx *ctx;
54         int r;
55
56         if (!ret)
57                 return -EINVAL;
58
59         ctx = new0(link_config_ctx, 1);
60         if (!ctx)
61                 return -ENOMEM;
62
63         r = ethtool_connect(&ctx->ethtool_fd);
64         if (r < 0) {
65                 link_config_ctx_free(ctx);
66                 return r;
67         }
68
69         r = sd_rtnl_open(0, &ctx->rtnl);
70         if (r < 0) {
71                 link_config_ctx_free(ctx);
72                 return r;
73         }
74
75         LIST_HEAD_INIT(ctx->links);
76
77         ctx->link_dirs = strv_new("/etc/systemd/network",
78                                   "/run/systemd/network",
79                                   "/usr/lib/systemd/network",
80                                   NULL);
81         if (!ctx->link_dirs) {
82                 log_error("failed to build link config directory array");
83                 link_config_ctx_free(ctx);
84                 return -ENOMEM;
85         }
86         if (!path_strv_canonicalize_uniq(ctx->link_dirs)) {
87                 log_error("failed to canonicalize link config directories\n");
88                 link_config_ctx_free(ctx);
89                 return -ENOMEM;
90         }
91
92         *ret = ctx;
93         return 0;
94 }
95
96 static void link_configs_free(link_config_ctx *ctx) {
97         link_config *link, *link_next;
98
99         if (!ctx)
100                 return;
101
102         LIST_FOREACH_SAFE(links, link, link_next, ctx->links) {
103                 free(link->filename);
104                 free(link->match_path);
105                 free(link->match_driver);
106                 free(link->match_type);
107                 free(link->description);
108
109                 free(link);
110         }
111 }
112
113 void link_config_ctx_free(link_config_ctx *ctx) {
114         if (!ctx)
115                 return;
116
117         if (ctx->ethtool_fd >= 0)
118                 close_nointr_nofail(ctx->ethtool_fd);
119
120         sd_rtnl_unref(ctx->rtnl);
121
122         strv_free(ctx->link_dirs);
123         link_configs_free(ctx);
124
125         free(ctx);
126
127         return;
128 }
129
130 static int load_link(link_config_ctx *ctx, const char *filename) {
131         link_config *link;
132         FILE *file;
133         int r;
134
135         file = fopen(filename, "re");
136         if (!file) {
137                 if (errno == ENOENT)
138                         return 0;
139                 else
140                         return errno;
141         }
142
143         link = new0(link_config, 1);
144         if (!link) {
145                 r = log_oom();
146                 goto failure;
147         }
148
149         link->mac_policy = _MACPOLICY_INVALID;
150         link->wol = _WOL_INVALID;
151         link->duplex = _DUP_INVALID;
152
153
154         r = config_parse(NULL, filename, file, "Match\0Link\0Ethernet\0", config_item_perf_lookup,
155                          (void*) link_config_gperf_lookup, false, false, link);
156         if (r < 0) {
157                 log_warning("Colud not parse config file %s: %s", filename, strerror(-r));
158                 goto failure;
159         } else
160                 log_info("Parsed configuration file %s", filename);
161
162         link->filename = strdup(filename);
163
164         LIST_PREPEND(links, ctx->links, link);
165
166         return 0;
167
168 failure:
169         free(link);
170         return r;
171 }
172
173 int link_config_load(link_config_ctx *ctx) {
174         int r;
175         char **files, **f;
176
177         link_configs_free(ctx);
178
179         /* update timestamp */
180         paths_check_timestamp(ctx->link_dirs, &ctx->link_dirs_ts_usec, true);
181
182         r = conf_files_list_strv(&files, ".link", NULL, (const char **)ctx->link_dirs);
183         if (r < 0) {
184                 log_error("failed to enumerate link files: %s", strerror(-r));
185                 return r;
186         }
187
188         STRV_FOREACH_BACKWARDS(f, files) {
189                 r = load_link(ctx, *f);
190                 if (r < 0)
191                         return r;
192         }
193
194         return 0;
195 }
196
197 bool link_config_should_reload(link_config_ctx *ctx) {
198         return paths_check_timestamp(ctx->link_dirs, &ctx->link_dirs_ts_usec, false);
199 }
200
201 static bool match_config(link_config *match, struct udev_device *device) {
202         const char *property;
203
204         if (match->match_mac) {
205                 property = udev_device_get_sysattr_value(device, "address");
206                 if (!property || memcmp(match->match_mac, ether_aton(property), ETH_ALEN)) {
207                         log_debug("Device MAC address (%s) did not match MACAddress=%s",
208                                   property, ether_ntoa(match->match_mac));
209                         return 0;
210                 }
211         }
212
213         if (match->match_path) {
214                 property = udev_device_get_property_value(device, "ID_PATH");
215                 if (!streq_ptr(match->match_path, property)) {
216                         log_debug("Device's persistent path (%s) did not match Path=%s",
217                                   property, match->match_path);
218                         return 0;
219                 }
220         }
221
222         if (match->match_driver) {
223                 property = udev_device_get_driver(device);
224                 if (!streq_ptr(match->match_driver, property)) {
225                         log_debug("Device driver (%s) did not match Driver=%s",
226                                   property, match->match_driver);
227                         return 0;
228                 }
229         }
230
231         if (match->match_type) {
232                 property = udev_device_get_devtype(device);
233                 if (!streq_ptr(match->match_type, property)) {
234                         log_debug("Device type (%s) did not match Type=%s",
235                                   property, match->match_type);
236                         return 0;
237                 }
238         }
239
240         return 1;
241 }
242
243 int link_config_get(link_config_ctx *ctx, struct udev_device *device, link_config **ret) {
244         link_config *link;
245
246         LIST_FOREACH(links, link, ctx->links) {
247                 if (!match_config(link, device)) {
248                         log_info("Config file %s does not apply to device %s", link->filename, udev_device_get_sysname(device));
249                 } else {
250                         log_info("Config file %s applies to device %s", link->filename, udev_device_get_sysname(device));
251                         *ret = link;
252                         return 0;
253                 }
254         }
255
256         return -ENOENT;
257 }
258
259 static int rtnl_set_properties(sd_rtnl *rtnl, int ifindex, const char *name, const struct ether_addr *mac, unsigned int mtu) {
260         _cleanup_sd_rtnl_message_unref_ sd_rtnl_message *message;
261         bool need_update = false;
262         int r;
263
264         assert(rtnl);
265         assert(ifindex > 0);
266
267         r = sd_rtnl_message_link_new(RTM_NEWLINK, ifindex, 0, 0, &message);
268         if (r < 0)
269                 return r;
270
271         if (name) {
272                 r = sd_rtnl_message_append(message, IFLA_IFNAME, name);
273                 if (r < 0)
274                         return r;
275
276                 need_update = true;
277         }
278
279         if (mac) {
280                 r = sd_rtnl_message_append(message, IFLA_ADDRESS, mac);
281                 if (r < 0)
282                         return r;
283
284                 need_update = true;
285         }
286
287         if (mtu > 0) {
288                 r = sd_rtnl_message_append(message, IFLA_MTU, &mtu);
289                 if (r < 0)
290                         return r;
291
292                 need_update = true;
293         }
294
295         if  (need_update) {
296                 r = sd_rtnl_send_with_reply_and_block(rtnl, message, 5 * USEC_PER_SEC, NULL);
297                 if (r < 0)
298                         return r;
299         }
300
301         return 0;
302 }
303
304 static bool enable_name_policy(void) {
305         _cleanup_free_ char *line;
306         char *w, *state;
307         int r;
308         size_t l;
309
310         r = read_one_line_file("/proc/cmdline", &line);
311         if (r < 0) {
312                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
313                 return true; /* something is very wrong, let's not make it worse */
314         }
315
316         FOREACH_WORD_QUOTED(w, l, line, state)
317                 if (strneq(w, "net.ifnames=0", l))
318                         return false;
319
320         return true;
321 }
322
323 static bool mac_is_random(struct udev_device *device) {
324         const char *s;
325         int type;
326
327         s = udev_device_get_sysattr_value(device, "addr_assign_type");
328         if (!s)
329                 return -EINVAL;
330         type = strtoul(s, NULL, 0);
331
332         /* check for NET_ADDR_RANDOM */
333         return type == 1;
334 }
335
336 static bool mac_is_permanent(struct udev_device *device) {
337         const char *s;
338         int type;
339
340         s = udev_device_get_sysattr_value(device, "addr_assign_type");
341         if (!s)
342                 return -EINVAL;
343         type = strtoul(s, NULL, 0);
344
345         /* check for NET_ADDR_PERM */
346         return type == 0;
347 }
348
349 static int get_mac(struct udev_device *device, bool want_random, struct ether_addr *mac) {
350         unsigned int seed;
351         int r, i;
352
353         if (want_random)
354                 seed = random_u();
355         else {
356                 const char *name;
357                 sd_id128_t machine;
358                 char machineid_buf[33];
359                 const char *seed_str;
360
361                 /* fetch some persistent data unique (on this machine) to this device */
362                 name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
363                 if (!name) {
364                         name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
365                         if (!name) {
366                                 name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
367                                 if (!name)
368                                         return -1;
369                         }
370                 }
371                 /* fetch some persistent data unique to this machine */
372                 r = sd_id128_get_machine(&machine);
373                 if (r < 0)
374                         return -1;
375
376                 /* combine the data */
377                 seed_str = strappenda(name, sd_id128_to_string(machine, machineid_buf));
378
379                 /* hash to get seed */
380                 seed = string_hash_func(seed_str);
381         }
382
383         srandom(seed);
384
385         for(i = 0; i < ETH_ALEN; i++) {
386                 mac->ether_addr_octet[i] = random();
387         }
388
389         /* see eth_random_addr in the kernel */
390         mac->ether_addr_octet[0] &= 0xfe;        /* clear multicast bit */
391         mac->ether_addr_octet[0] |= 0x02;        /* set local assignment bit (IEEE802) */
392
393         return 0;
394 }
395
396 int link_config_apply(link_config_ctx *ctx, link_config *config, struct udev_device *device) {
397         const char *name;
398         const char *new_name = NULL;
399         struct ether_addr generated_mac;
400         struct ether_addr *mac = NULL;
401         int r, ifindex;
402
403         name = udev_device_get_sysname(device);
404         if (!name)
405                 return -EINVAL;
406
407         log_info("Configuring %s", name);
408
409         if (config->description) {
410                 r = udev_device_set_sysattr_value(device, "ifalias",
411                                                   config->description);
412                 if (r < 0)
413                         log_warning("Could not set description of %s to '%s': %s",
414                                     name, config->description, strerror(-r));
415         }
416
417         r = ethtool_set_speed(ctx->ethtool_fd, name, config->speed, config->duplex);
418         if (r < 0)
419                 log_warning("Could not set speed or duplex of %s to %u Mbytes (%s): %s",
420                              name, config->speed, duplex_to_string(config->duplex), strerror(-r));
421
422         r = ethtool_set_wol(ctx->ethtool_fd, name, config->wol);
423         if (r < 0)
424                 log_warning("Could not set WakeOnLan of %s to %s: %s",
425                             name, wol_to_string(config->wol), strerror(-r));
426
427         ifindex = udev_device_get_ifindex(device);
428         if (ifindex <= 0) {
429                 log_warning("Could not find ifindex");
430                 return -ENODEV;
431         }
432
433         if (config->name_policy && enable_name_policy()) {
434                 NamePolicy *policy;
435
436                 for (policy = config->name_policy; !new_name && *policy != _NAMEPOLICY_INVALID; policy++) {
437                         switch (*policy) {
438                                 case NAMEPOLICY_ONBOARD:
439                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_ONBOARD");
440                                         break;
441                                 case NAMEPOLICY_SLOT:
442                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_SLOT");
443                                         break;
444                                 case NAMEPOLICY_PATH:
445                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_PATH");
446                                         break;
447                                 case NAMEPOLICY_MAC:
448                                         new_name = udev_device_get_property_value(device, "ID_NET_NAME_MAC");
449                                         break;
450                                 default:
451                                         break;
452                         }
453                 }
454         }
455
456         if (!new_name && config->name) {
457                 new_name = config->name;
458         }
459
460         switch (config->mac_policy) {
461                 case MACPOLICY_PERSISTENT:
462                         if (!mac_is_permanent(device)) {
463                                 r = get_mac(device, false, &generated_mac);
464                                 if (r < 0)
465                                         return r;
466                                 mac = &generated_mac;
467                         }
468                         break;
469                 case MACPOLICY_RANDOM:
470                         if (!mac_is_random(device)) {
471                                 r = get_mac(device, true, &generated_mac);
472                                 if (r < 0)
473                                         return r;
474                                 mac = &generated_mac;
475                         }
476                         break;
477                 default:
478                         mac = config->mac;
479         }
480
481         r = rtnl_set_properties(ctx->rtnl, ifindex, new_name, mac, config->mtu);
482         if (r < 0) {
483                 log_warning("Could not set Name, MACAddress or MTU on %s: %s", name, strerror(-r));
484                 return r;
485         }
486
487         return 0;
488 }