Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <net/if.h>
4 : : #include <netinet/in.h>
5 : :
6 : : #include "alloc-util.h"
7 : : #include "conf-files.h"
8 : : #include "conf-parser.h"
9 : : #include "fd-util.h"
10 : : #include "list.h"
11 : : #include "netdev/bond.h"
12 : : #include "netdev/bridge.h"
13 : : #include "netdev/dummy.h"
14 : : #include "netdev/fou-tunnel.h"
15 : : #include "netdev/geneve.h"
16 : : #include "netdev/ipvlan.h"
17 : : #include "netdev/l2tp-tunnel.h"
18 : : #include "netdev/macsec.h"
19 : : #include "netdev/macvlan.h"
20 : : #include "netdev/netdev.h"
21 : : #include "netdev/netdevsim.h"
22 : : #include "netdev/nlmon.h"
23 : : #include "netdev/tunnel.h"
24 : : #include "netdev/tuntap.h"
25 : : #include "netdev/vcan.h"
26 : : #include "netdev/veth.h"
27 : : #include "netdev/vlan.h"
28 : : #include "netdev/vrf.h"
29 : : #include "netdev/vxcan.h"
30 : : #include "netdev/vxlan.h"
31 : : #include "netdev/wireguard.h"
32 : : #include "netdev/xfrm.h"
33 : : #include "netlink-util.h"
34 : : #include "network-internal.h"
35 : : #include "networkd-link.h"
36 : : #include "networkd-manager.h"
37 : : #include "siphash24.h"
38 : : #include "stat-util.h"
39 : : #include "string-table.h"
40 : : #include "string-util.h"
41 : : #include "strv.h"
42 : :
43 : : const NetDevVTable * const netdev_vtable[_NETDEV_KIND_MAX] = {
44 : : [NETDEV_KIND_BRIDGE] = &bridge_vtable,
45 : : [NETDEV_KIND_BOND] = &bond_vtable,
46 : : [NETDEV_KIND_VLAN] = &vlan_vtable,
47 : : [NETDEV_KIND_MACVLAN] = &macvlan_vtable,
48 : : [NETDEV_KIND_MACVTAP] = &macvtap_vtable,
49 : : [NETDEV_KIND_IPVLAN] = &ipvlan_vtable,
50 : : [NETDEV_KIND_IPVTAP] = &ipvtap_vtable,
51 : : [NETDEV_KIND_VXLAN] = &vxlan_vtable,
52 : : [NETDEV_KIND_IPIP] = &ipip_vtable,
53 : : [NETDEV_KIND_GRE] = &gre_vtable,
54 : : [NETDEV_KIND_GRETAP] = &gretap_vtable,
55 : : [NETDEV_KIND_IP6GRE] = &ip6gre_vtable,
56 : : [NETDEV_KIND_IP6GRETAP] = &ip6gretap_vtable,
57 : : [NETDEV_KIND_SIT] = &sit_vtable,
58 : : [NETDEV_KIND_VTI] = &vti_vtable,
59 : : [NETDEV_KIND_VTI6] = &vti6_vtable,
60 : : [NETDEV_KIND_VETH] = &veth_vtable,
61 : : [NETDEV_KIND_DUMMY] = &dummy_vtable,
62 : : [NETDEV_KIND_TUN] = &tun_vtable,
63 : : [NETDEV_KIND_TAP] = &tap_vtable,
64 : : [NETDEV_KIND_IP6TNL] = &ip6tnl_vtable,
65 : : [NETDEV_KIND_VRF] = &vrf_vtable,
66 : : [NETDEV_KIND_VCAN] = &vcan_vtable,
67 : : [NETDEV_KIND_GENEVE] = &geneve_vtable,
68 : : [NETDEV_KIND_VXCAN] = &vxcan_vtable,
69 : : [NETDEV_KIND_WIREGUARD] = &wireguard_vtable,
70 : : [NETDEV_KIND_NETDEVSIM] = &netdevsim_vtable,
71 : : [NETDEV_KIND_FOU] = &foutnl_vtable,
72 : : [NETDEV_KIND_ERSPAN] = &erspan_vtable,
73 : : [NETDEV_KIND_L2TP] = &l2tptnl_vtable,
74 : : [NETDEV_KIND_MACSEC] = &macsec_vtable,
75 : : [NETDEV_KIND_NLMON] = &nlmon_vtable,
76 : : [NETDEV_KIND_XFRM] = &xfrm_vtable,
77 : : };
78 : :
79 : : static const char* const netdev_kind_table[_NETDEV_KIND_MAX] = {
80 : : [NETDEV_KIND_BRIDGE] = "bridge",
81 : : [NETDEV_KIND_BOND] = "bond",
82 : : [NETDEV_KIND_VLAN] = "vlan",
83 : : [NETDEV_KIND_MACVLAN] = "macvlan",
84 : : [NETDEV_KIND_MACVTAP] = "macvtap",
85 : : [NETDEV_KIND_IPVLAN] = "ipvlan",
86 : : [NETDEV_KIND_IPVTAP] = "ipvtap",
87 : : [NETDEV_KIND_VXLAN] = "vxlan",
88 : : [NETDEV_KIND_IPIP] = "ipip",
89 : : [NETDEV_KIND_GRE] = "gre",
90 : : [NETDEV_KIND_GRETAP] = "gretap",
91 : : [NETDEV_KIND_IP6GRE] = "ip6gre",
92 : : [NETDEV_KIND_IP6GRETAP] = "ip6gretap",
93 : : [NETDEV_KIND_SIT] = "sit",
94 : : [NETDEV_KIND_VETH] = "veth",
95 : : [NETDEV_KIND_VTI] = "vti",
96 : : [NETDEV_KIND_VTI6] = "vti6",
97 : : [NETDEV_KIND_DUMMY] = "dummy",
98 : : [NETDEV_KIND_TUN] = "tun",
99 : : [NETDEV_KIND_TAP] = "tap",
100 : : [NETDEV_KIND_IP6TNL] = "ip6tnl",
101 : : [NETDEV_KIND_VRF] = "vrf",
102 : : [NETDEV_KIND_VCAN] = "vcan",
103 : : [NETDEV_KIND_GENEVE] = "geneve",
104 : : [NETDEV_KIND_VXCAN] = "vxcan",
105 : : [NETDEV_KIND_WIREGUARD] = "wireguard",
106 : : [NETDEV_KIND_NETDEVSIM] = "netdevsim",
107 : : [NETDEV_KIND_FOU] = "fou",
108 : : [NETDEV_KIND_ERSPAN] = "erspan",
109 : : [NETDEV_KIND_L2TP] = "l2tp",
110 : : [NETDEV_KIND_MACSEC] = "macsec",
111 : : [NETDEV_KIND_NLMON] = "nlmon",
112 : : [NETDEV_KIND_XFRM] = "xfrm",
113 : : };
114 : :
115 [ + + + + ]: 280 : DEFINE_STRING_TABLE_LOOKUP(netdev_kind, NetDevKind);
116 : :
117 : 0 : int config_parse_netdev_kind(
118 : : const char *unit,
119 : : const char *filename,
120 : : unsigned line,
121 : : const char *section,
122 : : unsigned section_line,
123 : : const char *lvalue,
124 : : int ltype,
125 : : const char *rvalue,
126 : : void *data,
127 : : void *userdata) {
128 : :
129 : 0 : NetDevKind k, *kind = data;
130 : :
131 [ # # ]: 0 : assert(rvalue);
132 [ # # ]: 0 : assert(data);
133 : :
134 : 0 : k = netdev_kind_from_string(rvalue);
135 [ # # ]: 0 : if (k < 0) {
136 [ # # ]: 0 : log_syntax(unit, LOG_ERR, filename, line, 0, "Failed to parse netdev kind, ignoring assignment: %s", rvalue);
137 : 0 : return 0;
138 : : }
139 : :
140 [ # # # # ]: 0 : if (*kind != _NETDEV_KIND_INVALID && *kind != k) {
141 [ # # ]: 0 : log_syntax(unit, LOG_ERR, filename, line, 0,
142 : : "Specified netdev kind is different from the previous value '%s', ignoring assignment: %s",
143 : : netdev_kind_to_string(*kind), rvalue);
144 : 0 : return 0;
145 : : }
146 : :
147 : 0 : *kind = k;
148 : :
149 : 0 : return 0;
150 : : }
151 : :
152 : 0 : static void netdev_callbacks_clear(NetDev *netdev) {
153 : : netdev_join_callback *callback;
154 : :
155 [ # # ]: 0 : if (!netdev)
156 : 0 : return;
157 : :
158 [ # # ]: 0 : while ((callback = netdev->callbacks)) {
159 [ # # # # : 0 : LIST_REMOVE(callbacks, netdev->callbacks, callback);
# # # # ]
160 : 0 : link_unref(callback->link);
161 : 0 : free(callback);
162 : : }
163 : : }
164 : :
165 : 0 : bool netdev_is_managed(NetDev *netdev) {
166 [ # # # # : 0 : if (!netdev || !netdev->manager || !netdev->ifname)
# # ]
167 : 0 : return false;
168 : :
169 : 0 : return hashmap_get(netdev->manager->netdevs, netdev->ifname) == netdev;
170 : : }
171 : :
172 : 0 : static void netdev_detach_from_manager(NetDev *netdev) {
173 [ # # # # ]: 0 : if (netdev->ifname && netdev->manager)
174 : 0 : hashmap_remove(netdev->manager->netdevs, netdev->ifname);
175 : 0 : }
176 : :
177 : 0 : static NetDev *netdev_free(NetDev *netdev) {
178 [ # # ]: 0 : assert(netdev);
179 : :
180 : 0 : netdev_callbacks_clear(netdev);
181 : :
182 : 0 : netdev_detach_from_manager(netdev);
183 : :
184 : 0 : free(netdev->filename);
185 : :
186 : 0 : free(netdev->description);
187 : 0 : free(netdev->ifname);
188 : 0 : free(netdev->mac);
189 : 0 : condition_free_list(netdev->conditions);
190 : :
191 : : /* Invoke the per-kind done() destructor, but only if the state field is initialized. We conditionalize that
192 : : * because we parse .netdev files twice: once to determine the kind (with a short, minimal NetDev structure
193 : : * allocation, with no room for per-kind fields), and once to read the kind's properties (with a full,
194 : : * comprehensive NetDev structure allocation with enough space for whatever the specific kind needs). Now, in
195 : : * the first case we shouldn't try to destruct the per-kind NetDev fields on destruction, in the second case we
196 : : * should. We use the state field to discern the two cases: it's _NETDEV_STATE_INVALID on the first "raw"
197 : : * call. */
198 [ # # ]: 0 : if (netdev->state != _NETDEV_STATE_INVALID &&
199 [ # # # # ]: 0 : NETDEV_VTABLE(netdev) &&
200 [ # # # # ]: 0 : NETDEV_VTABLE(netdev)->done)
201 [ # # ]: 0 : NETDEV_VTABLE(netdev)->done(netdev);
202 : :
203 : 0 : return mfree(netdev);
204 : : }
205 : :
206 [ + - # # : 312 : DEFINE_TRIVIAL_REF_UNREF_FUNC(NetDev, netdev, netdev_free);
# # ]
207 : :
208 : 0 : void netdev_drop(NetDev *netdev) {
209 [ # # # # ]: 0 : if (!netdev || netdev->state == NETDEV_STATE_LINGER)
210 : 0 : return;
211 : :
212 : 0 : netdev->state = NETDEV_STATE_LINGER;
213 : :
214 [ # # ]: 0 : log_netdev_debug(netdev, "netdev removed");
215 : :
216 : 0 : netdev_callbacks_clear(netdev);
217 : :
218 : 0 : netdev_detach_from_manager(netdev);
219 : :
220 : 0 : netdev_unref(netdev);
221 : :
222 : 0 : return;
223 : : }
224 : :
225 : 28 : int netdev_get(Manager *manager, const char *name, NetDev **ret) {
226 : : NetDev *netdev;
227 : :
228 [ - + ]: 28 : assert(manager);
229 [ - + ]: 28 : assert(name);
230 [ - + ]: 28 : assert(ret);
231 : :
232 : 28 : netdev = hashmap_get(manager->netdevs, name);
233 [ + - ]: 28 : if (!netdev) {
234 : 28 : *ret = NULL;
235 : 28 : return -ENOENT;
236 : : }
237 : :
238 : 0 : *ret = netdev;
239 : :
240 : 0 : return 0;
241 : : }
242 : :
243 : 0 : static int netdev_enter_failed(NetDev *netdev) {
244 : 0 : netdev->state = NETDEV_STATE_FAILED;
245 : :
246 : 0 : netdev_callbacks_clear(netdev);
247 : :
248 : 0 : return 0;
249 : : }
250 : :
251 : 0 : static int netdev_enslave_ready(NetDev *netdev, Link* link, link_netlink_message_handler_t callback) {
252 : 0 : _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
253 : : int r;
254 : :
255 [ # # ]: 0 : assert(netdev);
256 [ # # ]: 0 : assert(netdev->state == NETDEV_STATE_READY);
257 [ # # ]: 0 : assert(netdev->manager);
258 [ # # ]: 0 : assert(netdev->manager->rtnl);
259 [ # # # # ]: 0 : assert(IN_SET(netdev->kind, NETDEV_KIND_BRIDGE, NETDEV_KIND_BOND, NETDEV_KIND_VRF));
260 [ # # ]: 0 : assert(link);
261 [ # # ]: 0 : assert(callback);
262 : :
263 [ # # # # ]: 0 : if (link->flags & IFF_UP && netdev->kind == NETDEV_KIND_BOND) {
264 [ # # ]: 0 : log_netdev_debug(netdev, "Link '%s' was up when attempting to enslave it. Bringing link down.", link->ifname);
265 : 0 : r = link_down(link, NULL);
266 [ # # ]: 0 : if (r < 0)
267 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not bring link down: %m");
268 : : }
269 : :
270 : 0 : r = sd_rtnl_message_new_link(netdev->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
271 [ # # ]: 0 : if (r < 0)
272 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not allocate RTM_SETLINK message: %m");
273 : :
274 : 0 : r = sd_netlink_message_append_u32(req, IFLA_MASTER, netdev->ifindex);
275 [ # # ]: 0 : if (r < 0)
276 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_MASTER attribute: %m");
277 : :
278 : 0 : r = netlink_call_async(netdev->manager->rtnl, NULL, req, callback,
279 : : link_netlink_destroy_callback, link);
280 [ # # ]: 0 : if (r < 0)
281 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not send rtnetlink message: %m");
282 : :
283 : 0 : link_ref(link);
284 : :
285 [ # # ]: 0 : log_netdev_debug(netdev, "Enslaving link '%s'", link->ifname);
286 : :
287 : 0 : return 0;
288 : : }
289 : :
290 : 0 : static int netdev_enter_ready(NetDev *netdev) {
291 : : netdev_join_callback *callback, *callback_next;
292 : : int r;
293 : :
294 [ # # ]: 0 : assert(netdev);
295 [ # # ]: 0 : assert(netdev->ifname);
296 : :
297 [ # # ]: 0 : if (netdev->state != NETDEV_STATE_CREATING)
298 : 0 : return 0;
299 : :
300 : 0 : netdev->state = NETDEV_STATE_READY;
301 : :
302 [ # # ]: 0 : log_netdev_info(netdev, "netdev ready");
303 : :
304 [ # # ]: 0 : LIST_FOREACH_SAFE(callbacks, callback, callback_next, netdev->callbacks) {
305 : : /* enslave the links that were attempted to be enslaved before the
306 : : * link was ready */
307 : 0 : r = netdev_enslave_ready(netdev, callback->link, callback->callback);
308 [ # # ]: 0 : if (r < 0)
309 : 0 : return r;
310 : :
311 [ # # # # : 0 : LIST_REMOVE(callbacks, netdev->callbacks, callback);
# # # # ]
312 : 0 : link_unref(callback->link);
313 : 0 : free(callback);
314 : : }
315 : :
316 [ # # # # ]: 0 : if (NETDEV_VTABLE(netdev)->post_create)
317 [ # # ]: 0 : NETDEV_VTABLE(netdev)->post_create(netdev, NULL, NULL);
318 : :
319 : 0 : return 0;
320 : : }
321 : :
322 : : /* callback for netdev's created without a backing Link */
323 : 0 : static int netdev_create_handler(sd_netlink *rtnl, sd_netlink_message *m, NetDev *netdev) {
324 : : int r;
325 : :
326 [ # # ]: 0 : assert(netdev);
327 [ # # ]: 0 : assert(netdev->state != _NETDEV_STATE_INVALID);
328 : :
329 : 0 : r = sd_netlink_message_get_errno(m);
330 [ # # ]: 0 : if (r == -EEXIST)
331 [ # # ]: 0 : log_netdev_info(netdev, "netdev exists, using existing without changing its parameters");
332 [ # # ]: 0 : else if (r < 0) {
333 [ # # ]: 0 : log_netdev_warning_errno(netdev, r, "netdev could not be created: %m");
334 : 0 : netdev_drop(netdev);
335 : :
336 : 0 : return 1;
337 : : }
338 : :
339 [ # # ]: 0 : log_netdev_debug(netdev, "Created");
340 : :
341 : 0 : return 1;
342 : : }
343 : :
344 : 0 : static int netdev_enslave(NetDev *netdev, Link *link, link_netlink_message_handler_t callback) {
345 : : int r;
346 : :
347 [ # # ]: 0 : assert(netdev);
348 [ # # ]: 0 : assert(netdev->manager);
349 [ # # ]: 0 : assert(netdev->manager->rtnl);
350 [ # # # # ]: 0 : assert(IN_SET(netdev->kind, NETDEV_KIND_BRIDGE, NETDEV_KIND_BOND, NETDEV_KIND_VRF));
351 : :
352 [ # # ]: 0 : if (netdev->state == NETDEV_STATE_READY) {
353 : 0 : r = netdev_enslave_ready(netdev, link, callback);
354 [ # # ]: 0 : if (r < 0)
355 : 0 : return r;
356 [ # # # # ]: 0 : } else if (IN_SET(netdev->state, NETDEV_STATE_LINGER, NETDEV_STATE_FAILED)) {
357 : 0 : _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
358 : :
359 : 0 : r = rtnl_message_new_synthetic_error(netdev->manager->rtnl, -ENODEV, 0, &m);
360 [ # # ]: 0 : if (r >= 0)
361 : 0 : callback(netdev->manager->rtnl, m, link);
362 : : } else {
363 : : /* the netdev is not yet read, save this request for when it is */
364 : : netdev_join_callback *cb;
365 : :
366 : 0 : cb = new(netdev_join_callback, 1);
367 [ # # ]: 0 : if (!cb)
368 : 0 : return log_oom();
369 : :
370 : 0 : *cb = (netdev_join_callback) {
371 : : .callback = callback,
372 : 0 : .link = link_ref(link),
373 : : };
374 : :
375 [ # # # # ]: 0 : LIST_PREPEND(callbacks, netdev->callbacks, cb);
376 : :
377 [ # # ]: 0 : log_netdev_debug(netdev, "Will enslave '%s', when ready", link->ifname);
378 : : }
379 : :
380 : 0 : return 0;
381 : : }
382 : :
383 : 0 : int netdev_set_ifindex(NetDev *netdev, sd_netlink_message *message) {
384 : : uint16_t type;
385 : : const char *kind;
386 : : const char *received_kind;
387 : : const char *received_name;
388 : : int r, ifindex;
389 : :
390 [ # # ]: 0 : assert(netdev);
391 [ # # ]: 0 : assert(message);
392 : :
393 : 0 : r = sd_netlink_message_get_type(message, &type);
394 [ # # ]: 0 : if (r < 0)
395 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not get rtnl message type: %m");
396 : :
397 [ # # ]: 0 : if (type != RTM_NEWLINK) {
398 [ # # ]: 0 : log_netdev_error(netdev, "Cannot set ifindex from unexpected rtnl message type.");
399 : 0 : return -EINVAL;
400 : : }
401 : :
402 : 0 : r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
403 [ # # ]: 0 : if (r < 0) {
404 [ # # ]: 0 : log_netdev_error_errno(netdev, r, "Could not get ifindex: %m");
405 : 0 : netdev_enter_failed(netdev);
406 : 0 : return r;
407 [ # # ]: 0 : } else if (ifindex <= 0) {
408 [ # # ]: 0 : log_netdev_error(netdev, "Got invalid ifindex: %d", ifindex);
409 : 0 : netdev_enter_failed(netdev);
410 : 0 : return -EINVAL;
411 : : }
412 : :
413 [ # # ]: 0 : if (netdev->ifindex > 0) {
414 [ # # ]: 0 : if (netdev->ifindex != ifindex) {
415 [ # # ]: 0 : log_netdev_error(netdev, "Could not set ifindex to %d, already set to %d",
416 : : ifindex, netdev->ifindex);
417 : 0 : netdev_enter_failed(netdev);
418 : 0 : return -EEXIST;
419 : : } else
420 : : /* ifindex already set to the same for this netdev */
421 : 0 : return 0;
422 : : }
423 : :
424 : 0 : r = sd_netlink_message_read_string(message, IFLA_IFNAME, &received_name);
425 [ # # ]: 0 : if (r < 0)
426 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not get IFNAME: %m");
427 : :
428 [ # # ]: 0 : if (!streq(netdev->ifname, received_name)) {
429 [ # # ]: 0 : log_netdev_error(netdev, "Received newlink with wrong IFNAME %s", received_name);
430 : 0 : netdev_enter_failed(netdev);
431 : 0 : return r;
432 : : }
433 : :
434 : 0 : r = sd_netlink_message_enter_container(message, IFLA_LINKINFO);
435 [ # # ]: 0 : if (r < 0)
436 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not get LINKINFO: %m");
437 : :
438 : 0 : r = sd_netlink_message_read_string(message, IFLA_INFO_KIND, &received_kind);
439 [ # # ]: 0 : if (r < 0)
440 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not get KIND: %m");
441 : :
442 : 0 : r = sd_netlink_message_exit_container(message);
443 [ # # ]: 0 : if (r < 0)
444 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not exit container: %m");
445 : :
446 [ # # ]: 0 : if (netdev->kind == NETDEV_KIND_TAP)
447 : : /* the kernel does not distinguish between tun and tap */
448 : 0 : kind = "tun";
449 : : else {
450 : 0 : kind = netdev_kind_to_string(netdev->kind);
451 [ # # ]: 0 : if (!kind) {
452 [ # # ]: 0 : log_netdev_error(netdev, "Could not get kind");
453 : 0 : netdev_enter_failed(netdev);
454 : 0 : return -EINVAL;
455 : : }
456 : : }
457 : :
458 [ # # ]: 0 : if (!streq(kind, received_kind)) {
459 [ # # ]: 0 : log_netdev_error(netdev,
460 : : "Received newlink with wrong KIND %s, "
461 : : "expected %s", received_kind, kind);
462 : 0 : netdev_enter_failed(netdev);
463 : 0 : return r;
464 : : }
465 : :
466 : 0 : netdev->ifindex = ifindex;
467 : :
468 [ # # ]: 0 : log_netdev_debug(netdev, "netdev has index %d", netdev->ifindex);
469 : :
470 : 0 : netdev_enter_ready(netdev);
471 : :
472 : 0 : return 0;
473 : : }
474 : :
475 : : #define HASH_KEY SD_ID128_MAKE(52,e1,45,bd,00,6f,29,96,21,c6,30,6d,83,71,04,48)
476 : :
477 : 0 : int netdev_get_mac(const char *ifname, struct ether_addr **ret) {
478 : 0 : _cleanup_free_ struct ether_addr *mac = NULL;
479 : : uint64_t result;
480 : : size_t l, sz;
481 : : uint8_t *v;
482 : : int r;
483 : :
484 [ # # ]: 0 : assert(ifname);
485 [ # # ]: 0 : assert(ret);
486 : :
487 : 0 : mac = new0(struct ether_addr, 1);
488 [ # # ]: 0 : if (!mac)
489 : 0 : return -ENOMEM;
490 : :
491 : 0 : l = strlen(ifname);
492 : 0 : sz = sizeof(sd_id128_t) + l;
493 [ # # # # ]: 0 : v = newa(uint8_t, sz);
494 : :
495 : : /* fetch some persistent data unique to the machine */
496 : 0 : r = sd_id128_get_machine((sd_id128_t*) v);
497 [ # # ]: 0 : if (r < 0)
498 : 0 : return r;
499 : :
500 : : /* combine with some data unique (on this machine) to this
501 : : * netdev */
502 : 0 : memcpy(v + sizeof(sd_id128_t), ifname, l);
503 : :
504 : : /* Let's hash the host machine ID plus the container name. We
505 : : * use a fixed, but originally randomly created hash key here. */
506 : 0 : result = siphash24(v, sz, HASH_KEY.bytes);
507 : :
508 : : assert_cc(ETH_ALEN <= sizeof(result));
509 : 0 : memcpy(mac->ether_addr_octet, &result, ETH_ALEN);
510 : :
511 : : /* see eth_random_addr in the kernel */
512 : 0 : mac->ether_addr_octet[0] &= 0xfe; /* clear multicast bit */
513 : 0 : mac->ether_addr_octet[0] |= 0x02; /* set local assignment bit (IEEE802) */
514 : :
515 : 0 : *ret = TAKE_PTR(mac);
516 : :
517 : 0 : return 0;
518 : : }
519 : :
520 : 0 : static int netdev_create(NetDev *netdev, Link *link, link_netlink_message_handler_t callback) {
521 : : int r;
522 : :
523 [ # # ]: 0 : assert(netdev);
524 [ # # # # ]: 0 : assert(!link || callback);
525 : :
526 : : /* create netdev */
527 [ # # # # ]: 0 : if (NETDEV_VTABLE(netdev)->create) {
528 [ # # ]: 0 : assert(!link);
529 : :
530 [ # # ]: 0 : r = NETDEV_VTABLE(netdev)->create(netdev);
531 [ # # ]: 0 : if (r < 0)
532 : 0 : return r;
533 : :
534 [ # # ]: 0 : log_netdev_debug(netdev, "Created");
535 : : } else {
536 [ # # ]: 0 : _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
537 : :
538 : 0 : r = sd_rtnl_message_new_link(netdev->manager->rtnl, &m, RTM_NEWLINK, 0);
539 [ # # ]: 0 : if (r < 0)
540 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not allocate RTM_NEWLINK message: %m");
541 : :
542 : 0 : r = sd_netlink_message_append_string(m, IFLA_IFNAME, netdev->ifname);
543 [ # # ]: 0 : if (r < 0)
544 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_IFNAME, attribute: %m");
545 : :
546 [ # # ]: 0 : if (netdev->mac) {
547 : 0 : r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, netdev->mac);
548 [ # # ]: 0 : if (r < 0)
549 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_ADDRESS attribute: %m");
550 : : }
551 : :
552 [ # # ]: 0 : if (netdev->mtu) {
553 : 0 : r = sd_netlink_message_append_u32(m, IFLA_MTU, netdev->mtu);
554 [ # # ]: 0 : if (r < 0)
555 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_MTU attribute: %m");
556 : : }
557 : :
558 [ # # ]: 0 : if (link) {
559 : 0 : r = sd_netlink_message_append_u32(m, IFLA_LINK, link->ifindex);
560 [ # # ]: 0 : if (r < 0)
561 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINK attribute: %m");
562 : : }
563 : :
564 : 0 : r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
565 [ # # ]: 0 : if (r < 0)
566 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
567 : :
568 : 0 : r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, netdev_kind_to_string(netdev->kind));
569 [ # # ]: 0 : if (r < 0)
570 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
571 : :
572 [ # # # # ]: 0 : if (NETDEV_VTABLE(netdev)->fill_message_create) {
573 [ # # ]: 0 : r = NETDEV_VTABLE(netdev)->fill_message_create(netdev, link, m);
574 [ # # ]: 0 : if (r < 0)
575 : 0 : return r;
576 : : }
577 : :
578 : 0 : r = sd_netlink_message_close_container(m);
579 [ # # ]: 0 : if (r < 0)
580 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
581 : :
582 : 0 : r = sd_netlink_message_close_container(m);
583 [ # # ]: 0 : if (r < 0)
584 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
585 : :
586 [ # # ]: 0 : if (link) {
587 : 0 : r = netlink_call_async(netdev->manager->rtnl, NULL, m, callback,
588 : : link_netlink_destroy_callback, link);
589 [ # # ]: 0 : if (r < 0)
590 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not send rtnetlink message: %m");
591 : :
592 : 0 : link_ref(link);
593 : : } else {
594 : 0 : r = netlink_call_async(netdev->manager->rtnl, NULL, m, netdev_create_handler,
595 : : netdev_destroy_callback, netdev);
596 [ # # ]: 0 : if (r < 0)
597 [ # # ]: 0 : return log_netdev_error_errno(netdev, r, "Could not send rtnetlink message: %m");
598 : :
599 : 0 : netdev_ref(netdev);
600 : : }
601 : :
602 : 0 : netdev->state = NETDEV_STATE_CREATING;
603 : :
604 [ # # ]: 0 : log_netdev_debug(netdev, "Creating");
605 : : }
606 : :
607 : 0 : return 0;
608 : : }
609 : :
610 : 0 : static int netdev_create_after_configured(NetDev *netdev, Link *link) {
611 [ # # ]: 0 : assert(netdev);
612 [ # # ]: 0 : assert(link);
613 [ # # # # ]: 0 : assert(NETDEV_VTABLE(netdev)->create_after_configured);
614 : :
615 [ # # ]: 0 : return NETDEV_VTABLE(netdev)->create_after_configured(netdev, link);
616 : : }
617 : :
618 : : /* the callback must be called, possibly after a timeout, as otherwise the Link will hang */
619 : 0 : int netdev_join(NetDev *netdev, Link *link, link_netlink_message_handler_t callback) {
620 : : int r;
621 : :
622 [ # # ]: 0 : assert(netdev);
623 [ # # ]: 0 : assert(netdev->manager);
624 [ # # ]: 0 : assert(netdev->manager->rtnl);
625 : :
626 [ # # # # ]: 0 : switch (netdev_get_create_type(netdev)) {
627 : 0 : case NETDEV_CREATE_MASTER:
628 : 0 : r = netdev_enslave(netdev, link, callback);
629 [ # # ]: 0 : if (r < 0)
630 : 0 : return r;
631 : :
632 : 0 : break;
633 : 0 : case NETDEV_CREATE_STACKED:
634 : 0 : r = netdev_create(netdev, link, callback);
635 [ # # ]: 0 : if (r < 0)
636 : 0 : return r;
637 : :
638 : 0 : break;
639 : 0 : case NETDEV_CREATE_AFTER_CONFIGURED:
640 : 0 : r = netdev_create_after_configured(netdev, link);
641 [ # # ]: 0 : if (r < 0)
642 : 0 : return r;
643 : 0 : break;
644 : 0 : default:
645 : 0 : assert_not_reached("Can not join independent netdev");
646 : : }
647 : :
648 : 0 : return 0;
649 : : }
650 : :
651 : 0 : int netdev_load_one(Manager *manager, const char *filename) {
652 : 0 : _cleanup_(netdev_unrefp) NetDev *netdev_raw = NULL, *netdev = NULL;
653 : 0 : _cleanup_fclose_ FILE *file = NULL;
654 : : const char *dropin_dirname;
655 : 0 : bool independent = false;
656 : : int r;
657 : :
658 [ # # ]: 0 : assert(manager);
659 [ # # ]: 0 : assert(filename);
660 : :
661 : 0 : file = fopen(filename, "re");
662 [ # # ]: 0 : if (!file) {
663 [ # # ]: 0 : if (errno == ENOENT)
664 : 0 : return 0;
665 : :
666 : 0 : return -errno;
667 : : }
668 : :
669 [ # # ]: 0 : if (null_or_empty_fd(fileno(file))) {
670 [ # # ]: 0 : log_debug("Skipping empty file: %s", filename);
671 : 0 : return 0;
672 : : }
673 : :
674 : 0 : netdev_raw = new(NetDev, 1);
675 [ # # ]: 0 : if (!netdev_raw)
676 : 0 : return log_oom();
677 : :
678 : 0 : *netdev_raw = (NetDev) {
679 : : .n_ref = 1,
680 : : .kind = _NETDEV_KIND_INVALID,
681 : : .state = _NETDEV_STATE_INVALID, /* an invalid state means done() of the implementation won't be called on destruction */
682 : : };
683 : :
684 [ # # # # : 0 : dropin_dirname = strjoina(basename(filename), ".d");
# # # # #
# # # ]
685 : 0 : r = config_parse_many(filename, NETWORK_DIRS, dropin_dirname,
686 : : "Match\0NetDev\0",
687 : : config_item_perf_lookup, network_netdev_gperf_lookup,
688 : : CONFIG_PARSE_WARN|CONFIG_PARSE_RELAXED, netdev_raw);
689 [ # # ]: 0 : if (r < 0)
690 : 0 : return r;
691 : :
692 : : /* skip out early if configuration does not match the environment */
693 [ # # ]: 0 : if (!condition_test_list(netdev_raw->conditions, NULL, NULL, NULL)) {
694 [ # # ]: 0 : log_debug("%s: Conditions in the file do not match the system environment, skipping.", filename);
695 : 0 : return 0;
696 : : }
697 : :
698 [ # # ]: 0 : if (netdev_raw->kind == _NETDEV_KIND_INVALID) {
699 [ # # ]: 0 : log_warning("NetDev has no Kind= configured in %s. Ignoring", filename);
700 : 0 : return 0;
701 : : }
702 : :
703 [ # # ]: 0 : if (!netdev_raw->ifname) {
704 [ # # ]: 0 : log_warning("NetDev without Name= configured in %s. Ignoring", filename);
705 : 0 : return 0;
706 : : }
707 : :
708 : 0 : r = fseek(file, 0, SEEK_SET);
709 [ # # ]: 0 : if (r < 0)
710 : 0 : return -errno;
711 : :
712 [ # # ]: 0 : netdev = malloc0(NETDEV_VTABLE(netdev_raw)->object_size);
713 [ # # ]: 0 : if (!netdev)
714 : 0 : return log_oom();
715 : :
716 : 0 : netdev->n_ref = 1;
717 : 0 : netdev->manager = manager;
718 : 0 : netdev->kind = netdev_raw->kind;
719 : 0 : netdev->state = NETDEV_STATE_LOADING; /* we initialize the state here for the first time,
720 : : so that done() will be called on destruction */
721 : :
722 [ # # # # ]: 0 : if (NETDEV_VTABLE(netdev)->init)
723 [ # # ]: 0 : NETDEV_VTABLE(netdev)->init(netdev);
724 : :
725 : 0 : r = config_parse_many(filename, NETWORK_DIRS, dropin_dirname,
726 [ # # ]: 0 : NETDEV_VTABLE(netdev)->sections,
727 : : config_item_perf_lookup, network_netdev_gperf_lookup,
728 : : CONFIG_PARSE_WARN, netdev);
729 [ # # ]: 0 : if (r < 0)
730 : 0 : return r;
731 : :
732 : : /* verify configuration */
733 [ # # # # ]: 0 : if (NETDEV_VTABLE(netdev)->config_verify) {
734 [ # # ]: 0 : r = NETDEV_VTABLE(netdev)->config_verify(netdev, filename);
735 [ # # ]: 0 : if (r < 0)
736 : 0 : return 0;
737 : : }
738 : :
739 : 0 : netdev->filename = strdup(filename);
740 [ # # ]: 0 : if (!netdev->filename)
741 : 0 : return log_oom();
742 : :
743 [ # # # # : 0 : if (!netdev->mac && NETDEV_VTABLE(netdev)->generate_mac) {
# # ]
744 : 0 : r = netdev_get_mac(netdev->ifname, &netdev->mac);
745 [ # # ]: 0 : if (r < 0)
746 [ # # ]: 0 : return log_netdev_error_errno(netdev, r,
747 : : "Failed to generate predictable MAC address for %s: %m",
748 : : netdev->ifname);
749 : : }
750 : :
751 : 0 : r = hashmap_ensure_allocated(&netdev->manager->netdevs, &string_hash_ops);
752 [ # # ]: 0 : if (r < 0)
753 : 0 : return r;
754 : :
755 : 0 : r = hashmap_put(netdev->manager->netdevs, netdev->ifname, netdev);
756 [ # # ]: 0 : if (r == -EEXIST) {
757 : 0 : NetDev *n = hashmap_get(netdev->manager->netdevs, netdev->ifname);
758 : :
759 [ # # ]: 0 : assert(n);
760 [ # # ]: 0 : log_netdev_warning_errno(netdev, r,
761 : : "The setting Name=%s in %s conflicts with the one in %s, ignoring",
762 : : netdev->ifname, netdev->filename, n->filename);
763 : :
764 : : /* Clear ifname before netdev_free() is called. Otherwise, the NetDev object 'n' is
765 : : * removed from the hashmap 'manager->netdevs'. */
766 : 0 : netdev->ifname = mfree(netdev->ifname);
767 : 0 : return 0;
768 : : }
769 [ # # ]: 0 : if (r < 0)
770 : 0 : return r;
771 : :
772 : 0 : LIST_HEAD_INIT(netdev->callbacks);
773 : :
774 [ # # ]: 0 : log_netdev_debug(netdev, "loaded %s", netdev_kind_to_string(netdev->kind));
775 : :
776 [ # # # # ]: 0 : if (IN_SET(netdev_get_create_type(netdev), NETDEV_CREATE_MASTER, NETDEV_CREATE_INDEPENDENT)) {
777 : 0 : r = netdev_create(netdev, NULL, NULL);
778 [ # # ]: 0 : if (r < 0)
779 : 0 : return r;
780 : : }
781 : :
782 [ # # # # : 0 : switch (netdev->kind) {
# # # # #
# # # ]
783 : 0 : case NETDEV_KIND_IPIP:
784 : 0 : independent = IPIP(netdev)->independent;
785 : 0 : break;
786 : 0 : case NETDEV_KIND_GRE:
787 : 0 : independent = GRE(netdev)->independent;
788 : 0 : break;
789 : 0 : case NETDEV_KIND_GRETAP:
790 : 0 : independent = GRETAP(netdev)->independent;
791 : 0 : break;
792 : 0 : case NETDEV_KIND_IP6GRE:
793 : 0 : independent = IP6GRE(netdev)->independent;
794 : 0 : break;
795 : 0 : case NETDEV_KIND_IP6GRETAP:
796 : 0 : independent = IP6GRETAP(netdev)->independent;
797 : 0 : break;
798 : 0 : case NETDEV_KIND_SIT:
799 : 0 : independent = SIT(netdev)->independent;
800 : 0 : break;
801 : 0 : case NETDEV_KIND_VTI:
802 : 0 : independent = VTI(netdev)->independent;
803 : 0 : break;
804 : 0 : case NETDEV_KIND_VTI6:
805 : 0 : independent = VTI6(netdev)->independent;
806 : 0 : break;
807 : 0 : case NETDEV_KIND_IP6TNL:
808 : 0 : independent = IP6TNL(netdev)->independent;
809 : 0 : break;
810 : 0 : case NETDEV_KIND_ERSPAN:
811 : 0 : independent = ERSPAN(netdev)->independent;
812 : 0 : break;
813 : 0 : case NETDEV_KIND_XFRM:
814 : 0 : independent = XFRM(netdev)->independent;
815 : 0 : break;
816 : 0 : default:
817 : 0 : break;
818 : : }
819 : :
820 [ # # ]: 0 : if (independent) {
821 : 0 : r = netdev_create(netdev, NULL, NULL);
822 [ # # ]: 0 : if (r < 0)
823 : 0 : return r;
824 : : }
825 : :
826 : 0 : netdev = NULL;
827 : :
828 : 0 : return 0;
829 : : }
830 : :
831 : 4 : int netdev_load(Manager *manager) {
832 : 4 : _cleanup_strv_free_ char **files = NULL;
833 : : char **f;
834 : : int r;
835 : :
836 [ - + ]: 4 : assert(manager);
837 : :
838 [ - + ]: 4 : hashmap_clear_with_destructor(manager->netdevs, netdev_unref);
839 : :
840 : 4 : r = conf_files_list_strv(&files, ".netdev", NULL, 0, NETWORK_DIRS);
841 [ - + ]: 4 : if (r < 0)
842 [ # # ]: 0 : return log_error_errno(r, "Failed to enumerate netdev files: %m");
843 : :
844 [ + - - + ]: 4 : STRV_FOREACH(f, files) {
845 : 0 : r = netdev_load_one(manager, *f);
846 [ # # ]: 0 : if (r < 0)
847 : 0 : return r;
848 : : }
849 : :
850 : 4 : return 0;
851 : : }
|
