chiark / gitweb /
networkd: split out vlan and macvlan handling
[elogind.git] / src / network / networkd-manager.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 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 <sys/socket.h>
23 #include <linux/if.h>
24
25 #include "conf-parser.h"
26 #include "path-util.h"
27 #include "networkd.h"
28 #include "network-internal.h"
29 #include "libudev-private.h"
30 #include "udev-util.h"
31 #include "rtnl-util.h"
32 #include "mkdir.h"
33 #include "virt.h"
34
35 #include "sd-rtnl.h"
36
37 const char* const network_dirs[] = {
38         "/etc/systemd/network",
39         "/run/systemd/network",
40         "/usr/lib/systemd/network",
41 #ifdef HAVE_SPLIT_USR
42         "/lib/systemd/network",
43 #endif
44         NULL};
45
46 static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
47         Manager *m = userdata;
48
49         assert(m);
50
51         log_received_signal(LOG_INFO, si);
52
53         sd_event_exit(m->event, 0);
54         return 0;
55 }
56
57 static int setup_signals(Manager *m) {
58         sigset_t mask;
59         int r;
60
61         assert(m);
62
63         assert_se(sigemptyset(&mask) == 0);
64         sigset_add_many(&mask, SIGINT, SIGTERM, -1);
65         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
66
67         r = sd_event_add_signal(m->event, &m->sigterm_event_source, SIGTERM, dispatch_sigterm, m);
68         if (r < 0)
69                 return r;
70
71         r = sd_event_add_signal(m->event, &m->sigint_event_source, SIGINT, dispatch_sigterm, m);
72         if (r < 0)
73                 return r;
74
75         return 0;
76 }
77
78 static int setup_default_address_pool(Manager *m) {
79         AddressPool *p;
80         int r;
81
82         assert(m);
83
84         /* Add in the well-known private address ranges. */
85
86         r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
87         if (r < 0)
88                 return r;
89
90         r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
91         if (r < 0)
92                 return r;
93
94         r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
95         if (r < 0)
96                 return r;
97
98         r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
99         if (r < 0)
100                 return r;
101
102         return 0;
103 }
104
105 int manager_new(Manager **ret) {
106         _cleanup_manager_free_ Manager *m = NULL;
107         int r;
108
109         m = new0(Manager, 1);
110         if (!m)
111                 return -ENOMEM;
112
113         m->state_file = strdup("/run/systemd/netif/state");
114         if (!m->state_file)
115                 return -ENOMEM;
116
117         r = sd_event_default(&m->event);
118         if (r < 0)
119                 return r;
120
121         sd_event_set_watchdog(m->event, true);
122
123         r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR,
124                          RTNLGRP_IPV6_IFADDR);
125         if (r < 0)
126                 return r;
127
128         r = sd_bus_default_system(&m->bus);
129         if (r < 0 && r != -ENOENT) /* TODO: drop when we can rely on kdbus */
130                 return r;
131
132         r = setup_signals(m);
133         if (r < 0)
134                 return r;
135
136         /* udev does not initialize devices inside containers,
137          * so we rely on them being already initialized before
138          * entering the container */
139         if (detect_container(NULL) <= 0) {
140                 m->udev = udev_new();
141                 if (!m->udev)
142                         return -ENOMEM;
143
144                 m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
145                 if (!m->udev_monitor)
146                         return -ENOMEM;
147         }
148
149         m->links = hashmap_new(uint64_hash_func, uint64_compare_func);
150         if (!m->links)
151                 return -ENOMEM;
152
153         m->netdevs = hashmap_new(string_hash_func, string_compare_func);
154         if (!m->netdevs)
155                 return -ENOMEM;
156
157         LIST_HEAD_INIT(m->networks);
158
159         r = setup_default_address_pool(m);
160         if (r < 0)
161                 return r;
162
163         *ret = m;
164         m = NULL;
165
166         return 0;
167 }
168
169 void manager_free(Manager *m) {
170         Network *network;
171         NetDev *netdev;
172         Link *link;
173         AddressPool *pool;
174
175         if (!m)
176                 return;
177
178         free(m->state_file);
179
180         udev_monitor_unref(m->udev_monitor);
181         udev_unref(m->udev);
182         sd_bus_unref(m->bus);
183         sd_event_source_unref(m->udev_event_source);
184         sd_event_source_unref(m->sigterm_event_source);
185         sd_event_source_unref(m->sigint_event_source);
186         sd_event_unref(m->event);
187
188         while ((link = hashmap_first(m->links)))
189                 link_unref(link);
190         hashmap_free(m->links);
191
192         while ((network = m->networks))
193                 network_free(network);
194
195         while ((netdev = hashmap_first(m->netdevs)))
196                 netdev_unref(netdev);
197         hashmap_free(m->netdevs);
198
199         while ((pool = m->address_pools))
200                 address_pool_free(pool);
201
202         sd_rtnl_unref(m->rtnl);
203
204         free(m);
205 }
206
207 int manager_load_config(Manager *m) {
208         int r;
209
210         /* update timestamp */
211         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
212
213         r = netdev_load(m);
214         if (r < 0)
215                 return r;
216
217         r = network_load(m);
218         if (r < 0)
219                 return r;
220
221         return 0;
222 }
223
224 bool manager_should_reload(Manager *m) {
225         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
226 }
227
228 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
229         Link *link = NULL;
230         int r, ifindex;
231
232         assert(m);
233         assert(device);
234
235         if (!streq_ptr(udev_device_get_action(device), "add"))
236                 return 0;
237
238         ifindex = udev_device_get_ifindex(device);
239         if (ifindex <= 0) {
240                 log_debug("ignoring udev ADD event for device with invalid ifindex");
241                 return 0;
242         }
243
244         r = link_get(m, ifindex, &link);
245         if (r == -ENODEV)
246                 return 0;
247         else if (r < 0)
248                 return r;
249
250         r = link_initialized(link, device);
251         if (r < 0)
252                 return r;
253
254         return 0;
255 }
256
257 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
258         Manager *m = userdata;
259         Link *link = NULL;
260         NetDev *netdev = NULL;
261         uint16_t type;
262         char *name;
263         int r, ifindex;
264
265         assert(rtnl);
266         assert(message);
267         assert(m);
268
269         r = sd_rtnl_message_get_type(message, &type);
270         if (r < 0) {
271                 log_warning("rtnl: could not get message type");
272                 return 0;
273         }
274
275         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
276         if (r < 0 || ifindex <= 0) {
277                 log_warning("rtnl: received link message without valid ifindex");
278                 return 0;
279         } else
280                 link_get(m, ifindex, &link);
281
282         r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
283         if (r < 0 || !name) {
284                 log_warning("rtnl: received link message without valid ifname");
285                 return 0;
286         } else
287                 netdev_get(m, name, &netdev);
288
289         switch (type) {
290         case RTM_NEWLINK:
291                 if (!link) {
292                         /* link is new, so add it */
293                         r = link_add(m, message, &link);
294                         if (r < 0) {
295                                 log_debug("could not add new link: %s",
296                                            strerror(-r));
297                                 return 0;
298                         }
299                 }
300
301                 if (netdev) {
302                         /* netdev exists, so make sure the ifindex matches */
303                         r = netdev_set_ifindex(netdev, message);
304                         if (r < 0) {
305                                 log_debug("could not set ifindex on netdev");
306                                 return 0;
307                         }
308                 }
309
310                 r = link_update(link, message);
311                 if (r < 0)
312                         return 0;
313
314                 break;
315
316         case RTM_DELLINK:
317                 link_drop(link);
318                 netdev_drop(netdev);
319
320                 break;
321
322         default:
323                 assert_not_reached("Received invalid RTNL message type.");
324         }
325
326         return 1;
327 }
328
329 int manager_rtnl_enumerate_links(Manager *m) {
330         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
331         sd_rtnl_message *link;
332         int r, k;
333
334         assert(m);
335         assert(m->rtnl);
336
337         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
338         if (r < 0)
339                 return r;
340
341         r = sd_rtnl_message_request_dump(req, true);
342         if (r < 0)
343                 return r;
344
345         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
346         if (r < 0)
347                 return r;
348
349         for (link = reply; link; link = sd_rtnl_message_next(link)) {
350                 uint16_t type;
351
352                 k = sd_rtnl_message_get_type(link, &type);
353                 if (k < 0)
354                         return k;
355
356                 if (type != RTM_NEWLINK)
357                         continue;
358
359                 k = manager_rtnl_process_link(m->rtnl, link, m);
360                 if (k < 0)
361                         r = k;
362         }
363
364         return r;
365 }
366
367 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
368         Manager *m = userdata;
369         struct udev_monitor *monitor = m->udev_monitor;
370         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
371
372         device = udev_monitor_receive_device(monitor);
373         if (!device)
374                 return -ENOMEM;
375
376         manager_udev_process_link(m, device);
377         return 0;
378 }
379
380 int manager_udev_listen(Manager *m) {
381         int r;
382
383         if (detect_container(NULL) > 0)
384                 return 0;
385
386         assert(m->udev_monitor);
387
388         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
389         if (r < 0) {
390                 log_error("Could not add udev monitor filter: %s", strerror(-r));
391                 return r;
392         }
393
394         r = udev_monitor_enable_receiving(m->udev_monitor);
395         if (r < 0) {
396                 log_error("Could not enable udev monitor");
397                 return r;
398         }
399
400         r = sd_event_add_io(m->event,
401                         &m->udev_event_source,
402                         udev_monitor_get_fd(m->udev_monitor),
403                         EPOLLIN, manager_dispatch_link_udev,
404                         m);
405         if (r < 0)
406                 return r;
407
408         return 0;
409 }
410
411 int manager_rtnl_listen(Manager *m) {
412         int r;
413
414         assert(m);
415
416         r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
417         if (r < 0)
418                 return r;
419
420         r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
421         if (r < 0)
422                 return r;
423
424         r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
425         if (r < 0)
426                 return r;
427
428         r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
429         if (r < 0)
430                 return r;
431
432         r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
433         if (r < 0)
434                 return r;
435
436         return 0;
437 }
438
439 int manager_bus_listen(Manager *m) {
440         int r;
441
442         assert(m->event);
443
444         if (!m->bus) /* TODO: drop when we can rely on kdbus */
445                 return 0;
446
447         r = sd_bus_attach_event(m->bus, m->event, 0);
448         if (r < 0)
449                 return r;
450
451         return 0;
452 }
453
454 int manager_save(Manager *m) {
455         Link *link;
456         Iterator i;
457         _cleanup_free_ char *temp_path = NULL;
458         _cleanup_fclose_ FILE *f = NULL;
459         LinkOperationalState operstate = LINK_OPERSTATE_UNKNOWN;
460         const char *operstate_str;
461         int r;
462
463         assert(m);
464         assert(m->state_file);
465
466         HASHMAP_FOREACH(link, m->links, i) {
467                 if (link->flags & IFF_LOOPBACK)
468                         continue;
469
470                 if (link->operstate > operstate)
471                         operstate = link->operstate;
472         }
473
474         operstate_str = link_operstate_to_string(operstate);
475         assert(operstate_str);
476
477         r = fopen_temporary(m->state_file, &f, &temp_path);
478         if (r < 0)
479                 goto finish;
480
481         fchmod(fileno(f), 0644);
482
483         fprintf(f,
484                 "# This is private data. Do not parse.\n"
485                 "OPER_STATE=%s\n", operstate_str);
486
487         fflush(f);
488
489         if (ferror(f) || rename(temp_path, m->state_file) < 0) {
490                 r = -errno;
491                 unlink(m->state_file);
492                 unlink(temp_path);
493         }
494
495 finish:
496         if (r < 0)
497                 log_error("Failed to save network state to %s: %s", m->state_file, strerror(-r));
498
499         return r;
500 }
501
502 int manager_address_pool_acquire(Manager *m, unsigned family, unsigned prefixlen, union in_addr_union *found) {
503         AddressPool *p;
504         int r;
505
506         assert(m);
507         assert(prefixlen > 0);
508         assert(found);
509
510         LIST_FOREACH(address_pools, p, m->address_pools) {
511                 if (p->family != family)
512                         continue;
513
514                 r = address_pool_acquire(p, prefixlen, found);
515                 if (r != 0)
516                         return r;
517         }
518
519         return 0;
520 }