Debian Codegraph @

src/network/generator/network-generator.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <net/if_arp.h>
4
5 #include "alloc-util.h"
6 #include "extract-word.h"
7 #include "hostname-util.h"
8 #include "log.h"
9 #include "memstream-util.h"
10 #include "netif-naming-scheme.h"
11 #include "network-generator.h"
12 #include "parse-util.h"
13 #include "proc-cmdline.h"
14 #include "socket-util.h"
15 #include "string-table.h"
16 #include "string-util.h"
17 #include "strv.h"
18 #include "vlan-util.h"
19
20 /*
21 # .network
22 ip={dhcp|on|any|dhcp6|auto6|either6|link6|link-local}
23 ip=<interface>:{dhcp|on|any|dhcp6|auto6|link6|link-local}[:[<mtu>][:<macaddr>]]
24 ip=<client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>:<interface>:{none|off|dhcp|on|any|dhcp6|auto6|link6|ibft|link-local}[:[<mtu>][:<macaddr>]]
25 ip=<client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>:<interface>:{none|off|dhcp|on|any|dhcp6|auto6|link6|ibft|link-local}[:[<dns1>][:[<dns2>][:[<ntp>]]]]
26 rd.route=<net>/<netmask>:<gateway>[:<interface>]
27 nameserver=<IP> [nameserver=<IP> ...]
28 rd.peerdns=0
29 BOOTIF=<MAC>
30 rd.bootif=0 # Causes BOOTIF= to be ignored.
31
32 # .link
33 ifname=<interface>:<MAC>
34 net.ifname_policy=policy1[,policy2,...][,<MAC>] # This is an original rule, not supported by other tools.
35
36 # .netdev
37 vlan=<vlanname>:<phydevice>
38 bond=<bondname>[:<bondslaves>:[:<options>[:<mtu>]]]
39 team=<teammaster>:<teamslaves> # not supported
40 bridge=<bridgename>:<ethnames>
41
42 # ignored
43 bootdev=<interface>
44 biosdevname=0
45 rd.neednet=1
46 */
47
48 static const char * const dracut_dhcp_type_table[_DHCP_TYPE_MAX] = {
49 [DHCP_TYPE_NONE] = "none",
50 [DHCP_TYPE_OFF] = "off",
51 [DHCP_TYPE_ON] = "on",
52 [DHCP_TYPE_ANY] = "any",
53 [DHCP_TYPE_DHCP] = "dhcp",
54 [DHCP_TYPE_DHCP6] = "dhcp6",
55 [DHCP_TYPE_AUTO6] = "auto6",
56 [DHCP_TYPE_EITHER6] = "either6",
57 [DHCP_TYPE_IBFT] = "ibft",
58 [DHCP_TYPE_LINK6] = "link6",
59 [DHCP_TYPE_LINK_LOCAL] = "link-local",
60 };
61
62 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(dracut_dhcp_type, DHCPType);
63
64 static const char * const networkd_dhcp_type_table[_DHCP_TYPE_MAX] = {
65 [DHCP_TYPE_NONE] = "no",
66 [DHCP_TYPE_OFF] = "no",
67 [DHCP_TYPE_ON] = "yes",
68 [DHCP_TYPE_ANY] = "yes",
69 [DHCP_TYPE_DHCP] = "ipv4",
70 [DHCP_TYPE_DHCP6] = "ipv6",
71 [DHCP_TYPE_AUTO6] = "no", /* TODO: enable other setting? */
72 [DHCP_TYPE_EITHER6] = "ipv6", /* TODO: enable other setting? */
73 [DHCP_TYPE_IBFT] = "no",
74 [DHCP_TYPE_LINK6] = "no",
75 [DHCP_TYPE_LINK_LOCAL] = "no",
76 };
77
78 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(networkd_dhcp_type, DHCPType);
79
80 static const char * const networkd_ipv6ra_type_table[_DHCP_TYPE_MAX] = {
81 [DHCP_TYPE_NONE] = "no",
82 [DHCP_TYPE_OFF] = "no",
83 [DHCP_TYPE_LINK6] = "no",
84 [DHCP_TYPE_LINK_LOCAL] = "no",
85 /* We omit the other entries, to leave the default in effect */
86 };
87
88 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(networkd_ipv6ra_type, DHCPType);
89
90 static const char * const networkd_link_local_type_table[_DHCP_TYPE_MAX] = {
91 [DHCP_TYPE_NONE] = "no",
92 [DHCP_TYPE_OFF] = "no",
93 [DHCP_TYPE_LINK6] = "ipv6",
94 [DHCP_TYPE_LINK_LOCAL] = "yes",
95 /* We omit the other entries, to leave the default in effect */
96 };
97
98 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(networkd_link_local_type, DHCPType);
99
100 static Address* address_free(Address *address) {
101 if (!address)
102 return NULL;
103
104 if (address->network)
105 LIST_REMOVE(addresses, address->network->addresses, address);
106
107 return mfree(address);
108 }
109
110 static int address_new(
111 Network *network,
112 int family,
113 unsigned char prefixlen,
114 union in_addr_union *addr,
115 union in_addr_union *peer,
116 Address **ret) {
117
118 Address *address;
119
120 assert(network);
121 assert(IN_SET(family, AF_INET, AF_INET6));
122 assert(addr);
123 POINTER_MAY_BE_NULL(peer);
124
125 address = new(Address, 1);
126 if (!address)
127 return -ENOMEM;
128
129 *address = (Address) {
130 .family = family,
131 .prefixlen = prefixlen,
132 .address = *addr,
133 .peer = peer ? *peer : IN_ADDR_NULL,
134 };
135
136 LIST_PREPEND(addresses, network->addresses, address);
137
138 address->network = network;
139
140 if (ret)
141 *ret = address;
142 return 0;
143 }
144
145 static Route* route_free(Route *route) {
146 if (!route)
147 return NULL;
148
149 if (route->network)
150 LIST_REMOVE(routes, route->network->routes, route);
151
152 return mfree(route);
153 }
154
155 static int route_new(
156 Network *network,
157 int family,
158 unsigned char prefixlen,
159 union in_addr_union *dest,
160 union in_addr_union *gateway,
161 Route **ret) {
162
163 Route *route;
164
165 assert(network);
166 assert(IN_SET(family, AF_INET, AF_INET6));
167 assert(dest || gateway);
168
169 route = new(Route, 1);
170 if (!route)
171 return -ENOMEM;
172
173 *route = (Route) {
174 .family = family,
175 .prefixlen = prefixlen,
176 .dest = dest ? *dest : IN_ADDR_NULL,
177 .gateway = gateway ? *gateway : IN_ADDR_NULL,
178 };
179
180 LIST_PREPEND(routes, network->routes, route);
181
182 route->network = network;
183
184 if (ret)
185 *ret = route;
186 return 0;
187 }
188
189 static Network* network_free(Network *network) {
190 Address *address;
191 Route *route;
192
193 if (!network)
194 return NULL;
195
196 free(network->ifname);
197 free(network->hostname);
198 strv_free(network->dns);
199 strv_free(network->vlan);
200 free(network->bridge);
201 free(network->bond);
202 free(network->ntp);
203
204 while ((address = network->addresses))
205 address_free(address);
206
207 while ((route = network->routes))
208 route_free(route);
209
210 return mfree(network);
211 }
212
213 DEFINE_TRIVIAL_CLEANUP_FUNC(Network*, network_free);
214
215 DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
216 network_hash_ops,
217 char, string_hash_func, string_compare_func,
218 Network, network_free);
219
220 static int network_new(Context *context, const char *name, Network **ret) {
221 _cleanup_(network_freep) Network *network = NULL;
222 _cleanup_free_ char *ifname = NULL;
223 int r;
224
225 assert(context);
226 assert(name);
227
228 if (!isempty(name) && !ifname_valid(name))
229 return -EINVAL;
230
231 ifname = strdup(name);
232 if (!ifname)
233 return -ENOMEM;
234
235 network = new(Network, 1);
236 if (!network)
237 return -ENOMEM;
238
239 *network = (Network) {
240 .ifname = TAKE_PTR(ifname),
241 .dhcp_type = _DHCP_TYPE_INVALID,
242 .dhcp_use_dns = -1,
243 };
244
245 r = hashmap_ensure_put(&context->networks_by_name, &network_hash_ops, network->ifname, network);
246 if (r < 0)
247 return r;
248
249 if (ret)
250 *ret = network;
251
252 TAKE_PTR(network);
253 return 0;
254 }
255
256 Network* network_get(Context *context, const char *ifname) {
257 assert(context);
258 assert(ifname);
259 return hashmap_get(context->networks_by_name, ifname);
260 }
261
262 static int network_acquire(Context *context, const char *ifname, Network **ret) {
263 Network *network;
264
265 assert(context);
266 assert(ifname);
267
268 network = network_get(context, ifname);
269 if (!network)
270 return network_new(context, ifname, ret);
271
272 if (ret)
273 *ret = network;
274 return 0;
275 }
276
277 static NetDev* netdev_free(NetDev *netdev) {
278 if (!netdev)
279 return NULL;
280
281 free(netdev->ifname);
282 free(netdev->kind);
283 return mfree(netdev);
284 }
285
286 DEFINE_TRIVIAL_CLEANUP_FUNC(NetDev*, netdev_free);
287
288 DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
289 netdev_hash_ops,
290 char, string_hash_func, string_compare_func,
291 NetDev, netdev_free);
292
293 static int netdev_new(Context *context, const char *_kind, const char *_ifname, NetDev **ret) {
294 _cleanup_(netdev_freep) NetDev *netdev = NULL;
295 _cleanup_free_ char *kind = NULL, *ifname = NULL;
296 int r;
297
298 assert(context);
299 assert(_kind);
300 assert(_ifname);
301
302 if (!ifname_valid(_ifname))
303 return -EINVAL;
304
305 kind = strdup(_kind);
306 if (!kind)
307 return -ENOMEM;
308
309 ifname = strdup(_ifname);
310 if (!ifname)
311 return -ENOMEM;
312
313 netdev = new(NetDev, 1);
314 if (!netdev)
315 return -ENOMEM;
316
317 *netdev = (NetDev) {
318 .kind = TAKE_PTR(kind),
319 .ifname = TAKE_PTR(ifname),
320 };
321
322 r = hashmap_ensure_put(&context->netdevs_by_name, &netdev_hash_ops, netdev->ifname, netdev);
323 if (r < 0)
324 return r;
325
326 if (ret)
327 *ret = netdev;
328
329 TAKE_PTR(netdev);
330 return 0;
331 }
332
333 NetDev* netdev_get(Context *context, const char *ifname) {
334 assert(context);
335 assert(ifname);
336 return hashmap_get(context->netdevs_by_name, ifname);
337 }
338
339 static int netdev_acquire(Context *context, const char *kind, const char *name, NetDev **ret) {
340 NetDev *netdev;
341
342 assert(context);
343 assert(kind);
344 assert(name);
345
346 netdev = netdev_get(context, name);
347 if (!netdev)
348 return netdev_new(context, kind, name, ret);
349
350 if (!streq_ptr(netdev->kind, kind))
351 return -EEXIST; /* conflicting netdev already exists. */
352
353 if (ret)
354 *ret = netdev;
355 return 0;
356 }
357
358 static Link* link_free(Link *link) {
359 if (!link)
360 return NULL;
361
362 free(link->filename);
363 free(link->ifname);
364 strv_free(link->policies);
365 strv_free(link->alt_policies);
366 return mfree(link);
367 }
368
369 DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_free);
370
371 DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
372 link_hash_ops,
373 char, string_hash_func, string_compare_func,
374 Link, link_free);
375
376 static int link_new(
377 Context *context,
378 const char *name,
379 const struct hw_addr_data *mac,
380 Link **ret) {
381
382 _cleanup_(link_freep) Link *link = NULL;
383 _cleanup_free_ char *ifname = NULL, *filename = NULL;
384 int r;
385
386 assert(context);
387 assert(mac);
388
389 if (name) {
390 if (!ifname_valid(name))
391 return -EINVAL;
392
393 ifname = strdup(name);
394 if (!ifname)
395 return -ENOMEM;
396
397 filename = strdup(name);
398 if (!filename)
399 return -ENOMEM;
400 }
401
402 if (!filename) {
403 filename = strdup(hw_addr_is_null(mac) ? "default" :
404 HW_ADDR_TO_STR_FULL(mac, HW_ADDR_TO_STRING_NO_COLON));
405 if (!filename)
406 return -ENOMEM;
407 }
408
409 link = new(Link, 1);
410 if (!link)
411 return -ENOMEM;
412
413 *link = (Link) {
414 .filename = TAKE_PTR(filename),
415 .ifname = TAKE_PTR(ifname),
416 .mac = *mac,
417 };
418
419 r = hashmap_ensure_put(&context->links_by_filename, &link_hash_ops, link->filename, link);
420 if (r < 0)
421 return r;
422
423 if (ret)
424 *ret = link;
425
426 TAKE_PTR(link);
427 return 0;
428 }
429
430 Link* link_get(Context *context, const char *filename) {
431 assert(context);
432 assert(filename);
433 return hashmap_get(context->links_by_filename, filename);
434 }
435
436 static int network_set_dhcp_type(Context *context, const char *ifname, const char *dhcp_type) {
437 Network *network;
438 DHCPType t;
439 int r;
440
441 assert(context);
442 assert(ifname);
443 assert(dhcp_type);
444
445 t = dracut_dhcp_type_from_string(dhcp_type);
446 if (t < 0)
447 return log_debug_errno(t, "Invalid DHCP type '%s'", dhcp_type);
448
449 r = network_acquire(context, ifname, &network);
450 if (r < 0)
451 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
452
453 network->dhcp_type = t;
454 return 0;
455 }
456
457 static int network_set_hostname(Context *context, const char *ifname, const char *hostname) {
458 Network *network;
459 int r;
460
461 assert(context);
462 assert(ifname);
463
464 if (isempty(hostname))
465 return 0;
466
467 if (!hostname_is_valid(hostname, 0))
468 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid hostname '%s'.", hostname);
469
470 r = network_acquire(context, ifname, &network);
471 if (r < 0)
472 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
473
474 return free_and_strdup(&network->hostname, hostname);
475 }
476
477 static int network_set_mtu(Context *context, const char *ifname, const char *mtu) {
478 Network *network;
479 int r;
480
481 assert(context);
482 assert(ifname);
483
484 if (isempty(mtu))
485 return 0;
486
487 r = network_acquire(context, ifname, &network);
488 if (r < 0)
489 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
490
491 r = parse_mtu(AF_UNSPEC, mtu, &network->mtu);
492 if (r < 0)
493 return log_debug_errno(r, "Invalid MTU '%s' for '%s': %m", mtu, ifname);
494
495 return r;
496 }
497
498 static int network_set_mac_address(Context *context, const char *ifname, const char *mac) {
499 Network *network;
500 int r;
501
502 assert(context);
503 assert(ifname);
504
505 if (isempty(mac))
506 return 0;
507
508 r = network_acquire(context, ifname, &network);
509 if (r < 0)
510 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
511
512 r = parse_ether_addr(mac, &network->mac);
513 if (r < 0)
514 return log_debug_errno(r, "Invalid MAC address '%s' for '%s'", mac, ifname);
515
516 return 0;
517 }
518
519 static int network_set_bootif_mac_address(Context *context, const char *mac) {
520 int r;
521
522 assert(context);
523
524 if (isempty(mac))
525 return 0;
526
527 /* "BOOTIF" is a special placeholder interface name, used to configure the
528 * interface referred to by BOOTIF=. I.e., ip=...:BOOTIF:... is valid if and
529 * only if BOOTIF= is also set. */
530 Network *network;
531 r = network_acquire(context, "BOOTIF", &network);
532 if (r < 0)
533 return log_debug_errno(r, "Failed to acquire network for BOOTIF: %m");
534
535 r = parse_hw_addr(mac, &network->match_mac);
536 if (r < 0) {
537 /* PXE bootloaders may provide the MAC with a "hardware type prefix", e.g.
538 * 01-12:34:56:78:90:ab, where 01 indicates ethernet. Technically, other
539 * hardware types are possible, but only ethernet is handled here. */
540 const char *p = startswith(mac, "01-");
541 if (p)
542 r = parse_hw_addr(p, &network->match_mac);
543 }
544 if (r < 0)
545 return log_debug_errno(r, "Invalid MAC address '%s' for BOOTIF", mac);
546
547 if (!hw_addr_is_valid(&network->match_mac, ARPHRD_ETHER))
548 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid MAC address '%s' for BOOTIF", mac);
549
550 return 0;
551 }
552
553 static int network_set_address(
554 Context *context,
555 const char *ifname,
556 int family,
557 unsigned char prefixlen,
558 union in_addr_union *addr,
559 union in_addr_union *peer) {
560
561 Network *network;
562 int r;
563
564 assert(context);
565 assert(ifname);
566 assert(IN_SET(family, AF_INET, AF_INET6));
567 assert(addr);
568
569 if (!in_addr_is_set(family, addr))
570 return 0;
571
572 r = network_acquire(context, ifname, &network);
573 if (r < 0)
574 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
575
576 return address_new(network, family, prefixlen, addr, peer, NULL);
577 }
578
579 static int network_set_route(
580 Context *context,
581 const char *ifname,
582 int family,
583 unsigned char prefixlen,
584 union in_addr_union *dest,
585 union in_addr_union *gateway) {
586
587 Network *network;
588 int r;
589
590 assert(context);
591 assert(ifname);
592 assert(IN_SET(family, AF_INET, AF_INET6));
593
594 if (!(dest && in_addr_is_set(family, dest)) &&
595 !(gateway && in_addr_is_set(family, gateway)))
596 return 0;
597
598 r = network_acquire(context, ifname, &network);
599 if (r < 0)
600 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
601
602 return route_new(network, family, prefixlen, dest, gateway, NULL);
603 }
604
605 static int network_set_dns(Context *context, const char *ifname, const char *dns) {
606 Network *network;
607 int r;
608
609 assert(context);
610 assert(ifname);
611
612 if (isempty(dns))
613 return 0;
614
615 r = in_addr_from_string_auto(dns, NULL, NULL);
616 if (r < 0)
617 return log_debug_errno(r, "Invalid DNS address '%s' for '%s'", dns, ifname);
618
619 r = network_acquire(context, ifname, &network);
620 if (r < 0)
621 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
622
623 return strv_extend(&network->dns, dns);
624 }
625
626 static int network_set_dhcp_use_dns(Context *context, const char *ifname, bool value) {
627 Network *network;
628 int r;
629
630 assert(context);
631 assert(ifname);
632
633 r = network_acquire(context, ifname, &network);
634 if (r < 0)
635 return log_debug_errno(r, "Failed to create network for '%s': %m", ifname);
636
637 network->dhcp_use_dns = value;
638
639 return 0;
640 }
641
642 static int network_set_vlan(Context *context, const char *ifname, const char *value) {
643 Network *network;
644 int r;
645
646 assert(context);
647
648 if (isempty(ifname))
649 return 0;
650
651 r = network_acquire(context, ifname, &network);
652 if (r < 0)
653 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
654
655 return strv_extend(&network->vlan, value);
656 }
657
658 static int network_set_bridge(Context *context, const char *ifname, const char *value) {
659 Network *network;
660 int r;
661
662 assert(context);
663
664 if (isempty(ifname))
665 return 0;
666
667 r = network_acquire(context, ifname, &network);
668 if (r < 0)
669 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
670
671 return free_and_strdup(&network->bridge, value);
672 }
673
674 static int network_set_bond(Context *context, const char *ifname, const char *value) {
675 Network *network;
676 int r;
677
678 assert(context);
679
680 if (isempty(ifname))
681 return 0;
682
683 r = network_acquire(context, ifname, &network);
684 if (r < 0)
685 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
686
687 return free_and_strdup(&network->bond, value);
688 }
689
690 static int network_set_ntp(Context *context, const char *ifname, const char *value) {
691 Network *network;
692 int r;
693
694 assert(context);
695 assert(ifname);
696
697 if (isempty(value))
698 return 0;
699
700 r = in_addr_from_string_auto(value, NULL, NULL);
701 if (r < 0)
702 return log_debug_errno(r, "Invalid NTP address '%s' for '%s'", value, ifname);
703
704 r = network_acquire(context, ifname, &network);
705 if (r < 0)
706 return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
707
708 return free_and_strdup(&network->ntp, value);
709 }
710
711 static int parse_cmdline_ip_mtu_mac(Context *context, const char *ifname, const char *value) {
712 _cleanup_free_ char *mtu = NULL;
713 int r;
714
715 assert(context);
716 assert(ifname);
717
718 /* [<mtu>][:<macaddr>] */
719
720 const char *p = value;
721 r = extract_first_word(&p, &mtu, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
722 if (r <= 0)
723 return r;
724
725 r = network_set_mtu(context, ifname, mtu);
726 if (r < 0)
727 return r;
728
729 return network_set_mac_address(context, ifname, p);
730 }
731
732 static int extract_ip_address_str(int family, const char **ptr, char **ret) {
733 _cleanup_free_ char *buf = NULL;
734 const char *p;
735 int r;
736
737 assert(IN_SET(family, AF_UNSPEC, AF_INET, AF_INET6));
738 assert(ptr);
739 assert(ret);
740
741 if (isempty(*ptr)) {
742 *ptr = NULL;
743 *ret = NULL;
744 return 0;
745 }
746
747 if (**ptr != '[')
748 return extract_first_word(ptr, ret, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
749
750 if (family == AF_INET)
751 return -EINVAL;
752
753 p = *ptr + 1;
754 r = extract_first_word(&p, &buf, "]", EXTRACT_DONT_COALESCE_SEPARATORS);
755 if (r < 0)
756 return r;
757 if (r == 0)
758 return -EINVAL; /* Missing "]". */
759
760 if (!isempty(p)) {
761 if (p[0] != ':')
762 return -EINVAL; /* Missing ":" after "]". */
763 p++;
764 }
765
766 *ptr = p;
767 *ret = TAKE_PTR(buf);
768 return 1;
769 }
770
771 static int extract_ip_address(int family, const char **ptr, union in_addr_union *ret) {
772 _cleanup_free_ char *buf = NULL;
773 const char *p;
774 int r, k;
775
776 assert(IN_SET(family, AF_INET, AF_INET6));
777 assert(ptr);
778 assert(ret);
779
780 p = *ptr;
781 r = extract_ip_address_str(family, &p, &buf);
782 if (r < 0)
783 return r;
784
785 if (isempty(buf)) {
786 *ret = IN_ADDR_NULL;
787 r = 0;
788 } else {
789 assert(r > 0);
790 k = in_addr_from_string(family, buf, ret);
791 if (k < 0)
792 return k;
793 }
794
795 *ptr = p;
796 return r;
797 }
798
799 static int extract_netmask_or_prefixlen(int family, const char **ptr, unsigned char *ret) {
800 _cleanup_free_ char *buf = NULL;
801 const char *p;
802 int r;
803
804 assert(IN_SET(family, AF_INET, AF_INET6));
805 assert(ptr);
806 assert(ret);
807
808 if (family == AF_INET) {
809 union in_addr_union netmask;
810
811 p = *ptr;
812 r = extract_ip_address(family, &p, &netmask);
813 if (r > 0) {
814 *ptr = p;
815 *ret = in4_addr_netmask_to_prefixlen(&netmask.in);
816 return 0;
817 }
818 }
819
820 p = *ptr;
821 r = extract_first_word(&p, &buf, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
822 if (r < 0)
823 return r;
824 if (isempty(buf))
825 *ret = family == AF_INET6 ? 128 : 32;
826 else {
827 r = safe_atou8(buf, ret);
828 if (r < 0)
829 return r;
830 }
831
832 *ptr = p;
833 return 0;
834 }
835
836 static int parse_cmdline_ip_address(Context *context, int family, const char *value) {
837 union in_addr_union addr, peer = {}, gateway = {};
838 unsigned char prefixlen;
839 int r;
840
841 assert(context);
842 assert(IN_SET(family, AF_INET, AF_INET6));
843 assert(value);
844
845 /* ip=<client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>:<interface>:{none|off|dhcp|on|any|dhcp6|auto6|ibft|link6}[:[<mtu>][:<macaddr>]]
846 * ip=<client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>:<interface>:{none|off|dhcp|on|any|dhcp6|auto6|ibft|link6}[:[<dns1>][:<dns2>]]
847 *
848 * Here, only DHCP type is mandatory. */
849
850 const char *p = value;
851 r = extract_ip_address(family, &p, &addr);
852 if (r < 0)
853 return log_debug_errno(r, "Failed to parse IP address in ip=%s: %m", value);
854 r = extract_ip_address(family, &p, &peer);
855 if (r < 0)
856 return log_debug_errno(r, "Failed to parse peer address in ip=%s: %m", value);
857 r = extract_ip_address(family, &p, &gateway);
858 if (r < 0)
859 return log_debug_errno(r, "Failed to parse gateway address in ip=%s: %m", value);
860 r = extract_netmask_or_prefixlen(family, &p, &prefixlen);
861 if (r < 0)
862 return log_debug_errno(r, "Failed to parse netmask in ip=%s: %m", value);
863
864 /* hostname */
865 _cleanup_free_ char *hostname = NULL;
866 r = extract_first_word(&p, &hostname, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
867 if (r < 0)
868 return log_debug_errno(r, "Failed to parse hostname in ip=%s: %m", value);
869
870 /* ifname */
871 _cleanup_free_ char *ifname = NULL;
872 r = extract_first_word(&p, &ifname, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
873 if (r <= 0)
874 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse interface name in ip=%s: %m", value);
875
876 /* dhcp_type */
877 _cleanup_free_ char *dhcp_type = NULL;
878 r = extract_first_word(&p, &dhcp_type, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
879 if (r <= 0)
880 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse DHCP type name in ip=%s: %m", value);
881
882 /* set values */
883 r = network_set_address(context, ifname, family, prefixlen, &addr, &peer);
884 if (r < 0)
885 return r;
886
887 r = network_set_route(context, ifname, family, 0, NULL, &gateway);
888 if (r < 0)
889 return r;
890
891 r = network_set_hostname(context, ifname, hostname);
892 if (r < 0)
893 return r;
894
895 r = network_set_dhcp_type(context, ifname, dhcp_type);
896 if (r < 0)
897 return r;
898
899 /* First, try [<mtu>][:<macaddr>] if an interface name is specified. */
900 if (!isempty(ifname) && parse_cmdline_ip_mtu_mac(context, ifname, p) >= 0)
901 return 0;
902
903 /* Next, try [<dns1>][:<dns2>] */
904 _cleanup_free_ char *dns = NULL;
905 r = extract_ip_address_str(AF_UNSPEC, &p, &dns);
906 if (r < 0)
907 return log_debug_errno(r, "Failed to parse DNS address in ip=%s: %m", value);
908 if (r == 0)
909 return 0;
910
911 r = network_set_dns(context, ifname, dns);
912 if (r < 0)
913 return r;
914
915 dns = mfree(dns);
916 r = extract_ip_address_str(AF_UNSPEC, &p, &dns);
917 if (r < 0)
918 return log_debug_errno(r, "Failed to parse DNS address in ip=%s: %m", value);
919 if (r == 0)
920 return 0;
921
922 r = network_set_dns(context, ifname, dns);
923 if (r < 0)
924 return r;
925
926 /* Next, try [:<ntp>] */
927 _cleanup_free_ char *ntp = NULL;
928 r = extract_ip_address_str(AF_UNSPEC, &p, &ntp);
929 if (r < 0)
930 return log_debug_errno(r, "Failed to parse NTP address in ip=%s: %m", value);
931 if (r == 0)
932 return 0;
933
934 r = network_set_ntp(context, ifname, ntp);
935 if (r < 0)
936 return r;
937
938 /* refuse unexpected trailing strings */
939 if (!isempty(p))
940 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unexpected trailing string in 'ip=%s'.", value);
941
942 return 0;
943 }
944
945 static int parse_cmdline_ip_interface(Context *context, const char *value) {
946 _cleanup_free_ char *ifname = NULL, *dhcp_type = NULL;
947 int r;
948
949 assert(context);
950 assert(value);
951
952 /* ip=<interface>:{dhcp|on|any|dhcp6|auto6|link6}[:[<mtu>][:<macaddr>]] */
953
954 const char *p = value;
955 r = extract_first_word(&p, &ifname, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
956 if (r <= 0)
957 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse interface name in ip=%s: %m", value);
958
959 if (isempty(ifname))
960 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Missing interface name in ip=%s.", value);
961
962 r = extract_first_word(&p, &dhcp_type, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
963 if (r <= 0)
964 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse DHCP type in ip=%s: %m", value);
965
966 r = network_set_dhcp_type(context, ifname, dhcp_type);
967 if (r < 0)
968 return r;
969
970 return parse_cmdline_ip_mtu_mac(context, ifname, p);
971 }
972
973 static int parse_cmdline_ip(Context *context, const char *key, const char *value) {
974 const char *p;
975 int r;
976
977 assert(context);
978 assert(key);
979
980 if (proc_cmdline_value_missing(key, value))
981 return 0;
982
983 p = strchr(value, ':');
984 if (!p)
985 /* ip={dhcp|on|any|dhcp6|auto6|either6|link6} */
986 return network_set_dhcp_type(context, "", value);
987
988 /* extract_first_word() eats the trailing separator, so check this earlier. */
989 if (endswith(value, ":"))
990 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unexpected trailing colon in 'ip=%s'.", value);
991
992 if (value[0] == '[')
993 return parse_cmdline_ip_address(context, AF_INET6, value);
994
995 r = parse_cmdline_ip_address(context, AF_INET, value);
996 if (r < 0)
997 return parse_cmdline_ip_interface(context, value);
998
999 return 0;
1000 }
1001
1002 static int parse_cmdline_rd_route(Context *context, const char *key, const char *value) {
1003 _cleanup_free_ char *buf = NULL;
1004 union in_addr_union dest, gateway;
1005 unsigned char prefixlen;
1006 int family, r;
1007
1008 assert(context);
1009 assert(key);
1010
1011 /* rd.route=<net>/<netmask>:<gateway>[:<interface>] */
1012
1013 if (proc_cmdline_value_missing(key, value))
1014 return 0;
1015
1016 const char *p = value;
1017 r = extract_ip_address_str(AF_UNSPEC, &p, &buf);
1018 if (r <= 0)
1019 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse destination address in %s=%s: %m", key, value);
1020
1021 r = in_addr_prefix_from_string_auto(buf, &family, &dest, &prefixlen);
1022 if (r < 0)
1023 return log_debug_errno(r, "Failed to parse route destination '%s': %m", buf);
1024
1025 buf = mfree(buf);
1026 r = extract_ip_address(family, &p, &gateway);
1027 if (r <= 0)
1028 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse gateway address in %s=%s: %m", key, value);
1029
1030 return network_set_route(context, strempty(p), family, prefixlen, &dest, &gateway);
1031 }
1032
1033 static int parse_cmdline_nameserver(Context *context, const char *key, const char *value) {
1034 assert(context);
1035 assert(key);
1036
1037 if (proc_cmdline_value_missing(key, value))
1038 return 0;
1039
1040 return network_set_dns(context, "", value);
1041 }
1042
1043 static int parse_cmdline_rd_peerdns(Context *context, const char *key, const char *value) {
1044 int r;
1045
1046 assert(context);
1047 assert(key);
1048
1049 r = value ? parse_boolean(value) : true;
1050 if (r < 0)
1051 return log_debug_errno(r, "Invalid boolean value '%s'", value);
1052
1053 return network_set_dhcp_use_dns(context, "", r);
1054 }
1055
1056 static int extract_vlan_id(const char *vlan_name, uint16_t *ret) {
1057 assert(!isempty(vlan_name));
1058 assert(ret);
1059
1060 /* From dracut.cmdline(7):
1061 * We support the four styles of vlan names:
1062 * VLAN_PLUS_VID (vlan0005),
1063 * VLAN_PLUS_VID_NO_PAD (vlan5),
1064 * DEV_PLUS_VID (eth0.0005), and
1065 * DEV_PLUS_VID_NO_PAD (eth0.5). */
1066
1067 for (const char *p = vlan_name + strlen(vlan_name) - 1; p > vlan_name; p--)
1068 if (!ascii_isdigit(*p))
1069 return parse_vlanid(p+1, ret);
1070
1071 return -EINVAL;
1072 }
1073
1074 static int parse_cmdline_vlan(Context *context, const char *key, const char *value) {
1075 _cleanup_free_ char *name = NULL;
1076 NetDev *netdev;
1077 int r;
1078
1079 assert(context);
1080 assert(key);
1081
1082 /* vlan=<vlanname>:<phydevice> */
1083
1084 if (proc_cmdline_value_missing(key, value))
1085 return 0;
1086
1087 const char *p = value;
1088 r = extract_first_word(&p, &name, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1089 if (r <= 0)
1090 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s=%s: %m", key, value);
1091
1092 r = netdev_acquire(context, "vlan", name, &netdev);
1093 if (r < 0)
1094 return log_debug_errno(r, "Failed to acquire VLAN device for '%s': %m", name);
1095
1096 r = extract_vlan_id(name, &netdev->vlan_id);
1097 if (r < 0)
1098 return log_debug_errno(r, "Failed to parse VLAN ID from VLAN device name '%s': %m", name);
1099
1100 return network_set_vlan(context, p, name);
1101 }
1102
1103 static int parse_cmdline_bridge(Context *context, const char *key, const char *value) {
1104 _cleanup_free_ char *name = NULL;
1105 NetDev *netdev;
1106 int r;
1107
1108 assert(context);
1109 assert(key);
1110
1111 /* bridge=<bridgename>:<ethnames> */
1112
1113 if (proc_cmdline_value_missing(key, value))
1114 return 0;
1115
1116 const char *p = value;
1117 r = extract_first_word(&p, &name, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1118 if (r <= 0)
1119 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s=%s: %m", key, value);
1120
1121 r = netdev_acquire(context, "bridge", name, &netdev);
1122 if (r < 0)
1123 return log_debug_errno(r, "Failed to acquire bridge device for '%s': %m", name);
1124
1125 for (;;) {
1126 _cleanup_free_ char *word = NULL;
1127
1128 r = extract_first_word(&p, &word, ",", 0);
1129 if (r < 0)
1130 return log_debug_errno(r, "Failed to parse slave interfaces for bridge '%s'", name);
1131 if (r == 0)
1132 return 0;
1133
1134 r = network_set_bridge(context, word, name);
1135 if (r < 0)
1136 return r;
1137 }
1138 }
1139
1140 static int parse_cmdline_bond(Context *context, const char *key, const char *value) {
1141 _cleanup_free_ char *name = NULL, *slaves = NULL, *options = NULL;
1142 NetDev *netdev;
1143 int r;
1144
1145 assert(context);
1146 assert(key);
1147
1148 /* bond=<bondname>[:<bondslaves>:[:<options>[:<mtu>]]] */
1149
1150 if (proc_cmdline_value_missing(key, value))
1151 return 0;
1152
1153 const char *p = value;
1154 r = extract_first_word(&p, &name, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1155 if (r <= 0)
1156 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s=%s: %m", key, value);
1157
1158 r = netdev_acquire(context, "bond", name, &netdev);
1159 if (r < 0)
1160 return log_debug_errno(r, "Failed to acquire bond device for '%s': %m", name);
1161
1162 r = extract_first_word(&p, &slaves, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1163 if (r < 0)
1164 return log_debug_errno(r, "Failed to parse %s=%s: %m", key, value);
1165
1166 for (const char *q = slaves; ; ) {
1167 _cleanup_free_ char *word = NULL;
1168
1169 r = extract_first_word(&q, &word, ",", 0);
1170 if (r == 0)
1171 break;
1172 if (r < 0)
1173 return log_debug_errno(r, "Failed to parse slave interfaces for bond '%s'", name);
1174
1175 r = network_set_bond(context, word, name);
1176 if (r < 0)
1177 return r;
1178 }
1179
1180 r = extract_first_word(&p, &options, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1181 if (r < 0)
1182 return log_debug_errno(r, "Failed to parse %s=%s: %m", key, value);
1183
1184 /* TODO: set bonding options */
1185
1186 if (!isempty(p)) {
1187 r = parse_mtu(AF_UNSPEC, p, &netdev->mtu);
1188 if (r < 0)
1189 return log_debug_errno(r, "Invalid MTU '%s' for '%s': %m", p, name);
1190 }
1191
1192 return 0;
1193 }
1194
1195 static int parse_cmdline_ifname(Context *context, const char *key, const char *value) {
1196 _cleanup_free_ char *name = NULL;
1197 struct hw_addr_data mac;
1198 int r;
1199
1200 assert(context);
1201 assert(key);
1202
1203 /* ifname=<interface>:<MAC> */
1204
1205 if (proc_cmdline_value_missing(key, value))
1206 return 0;
1207
1208 const char *p = value;
1209 r = extract_first_word(&p, &name, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1210 if (r <= 0)
1211 return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s=%s: %m", key, value);
1212
1213 if (isempty(p))
1214 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Missing MAC address for '%s'", name);
1215
1216 r = parse_hw_addr(p, &mac);
1217 if (r < 0)
1218 return log_debug_errno(r, "Invalid MAC address '%s' for '%s'", p, name);
1219
1220 r = link_new(context, name, &mac, NULL);
1221 if (r < 0)
1222 return log_debug_errno(r, "Failed to create link for '%s': %m", name);
1223
1224 return 0;
1225 }
1226
1227 static int parse_cmdline_ifname_policy(Context *context, const char *key, const char *value) {
1228 _cleanup_strv_free_ char **policies = NULL, **alt_policies = NULL;
1229 struct hw_addr_data mac = HW_ADDR_NULL;
1230 Link *link;
1231 int r;
1232
1233 assert(context);
1234 assert(key);
1235
1236 /* net.ifname_policy=policy1[,policy2,...][,<MAC>] */
1237
1238 if (proc_cmdline_value_missing(key, value))
1239 return 0;
1240
1241 for (const char *q = value; ; ) {
1242 _cleanup_free_ char *word = NULL;
1243 NamePolicy p;
1244
1245 r = extract_first_word(&q, &word, ",", 0);
1246 if (r == 0)
1247 break;
1248 if (r < 0)
1249 return log_debug_errno(r, "Failed to parse ifname policy '%s'", value);
1250
1251 p = name_policy_from_string(word);
1252 if (p < 0) {
1253 r = parse_hw_addr(word, &mac);
1254 if (r < 0)
1255 return log_debug_errno(r, "Invalid MAC address '%s'", word);
1256
1257 if (hw_addr_is_null(&mac))
1258 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "MAC address is not set");
1259
1260 if (!isempty(q))
1261 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unexpected trailing string '%s' in ifname policy '%s'", q, value);
1262
1263 break;
1264 }
1265
1266 if (alternative_names_policy_from_string(word) >= 0) {
1267 r = strv_extend(&alt_policies, word);
1268 if (r < 0)
1269 return log_oom_debug();
1270 }
1271
1272 r = strv_consume(&policies, TAKE_PTR(word));
1273 if (r < 0)
1274 return log_oom_debug();
1275 }
1276
1277 if (strv_isempty(policies))
1278 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "No ifname policy specified");
1279
1280 r = link_new(context, NULL, &mac, &link);
1281 if (r < 0)
1282 return log_debug_errno(r, "Failed to create link: %m");
1283
1284 link->policies = TAKE_PTR(policies);
1285 link->alt_policies = TAKE_PTR(alt_policies);
1286 return 0;
1287 }
1288
1289 static int parse_cmdline_rd_bootif(Context *context, const char *key, const char *value) {
1290 int r;
1291
1292 assert(context);
1293 assert(key);
1294
1295 /* rd.bootif=<bool> */
1296
1297 if (proc_cmdline_value_missing(key, value))
1298 return 0;
1299
1300 r = value ? parse_boolean(value) : true;
1301 if (r < 0)
1302 return log_debug_errno(r, "Invalid boolean value '%s'", value);
1303
1304 /* rd.bootif=0 => skip BOOTIF= parsing */
1305 context->skip_bootif = !r;
1306 return 0;
1307 }
1308
1309 static int parse_cmdline_bootif_mac(Context *context, const char *key, const char *value) {
1310 assert(context);
1311 assert(key);
1312
1313 /* BOOTIF=<MAC> */
1314
1315 if (proc_cmdline_value_missing(key, value))
1316 return 0;
1317
1318 return network_set_bootif_mac_address(context, value);
1319 }
1320
1321 int parse_cmdline_item(const char *key, const char *value, void *data) {
1322 Context *context = ASSERT_PTR(data);
1323
1324 assert(key);
1325
1326 if (proc_cmdline_key_streq(key, "ip"))
1327 return parse_cmdline_ip(context, key, value);
1328 if (proc_cmdline_key_streq(key, "rd.route"))
1329 return parse_cmdline_rd_route(context, key, value);
1330 if (proc_cmdline_key_streq(key, "nameserver"))
1331 return parse_cmdline_nameserver(context, key, value);
1332 if (proc_cmdline_key_streq(key, "rd.peerdns"))
1333 return parse_cmdline_rd_peerdns(context, key, value);
1334 if (proc_cmdline_key_streq(key, "vlan"))
1335 return parse_cmdline_vlan(context, key, value);
1336 if (proc_cmdline_key_streq(key, "bridge"))
1337 return parse_cmdline_bridge(context, key, value);
1338 if (proc_cmdline_key_streq(key, "bond"))
1339 return parse_cmdline_bond(context, key, value);
1340 if (proc_cmdline_key_streq(key, "ifname"))
1341 return parse_cmdline_ifname(context, key, value);
1342 if (proc_cmdline_key_streq(key, "net.ifname_policy"))
1343 return parse_cmdline_ifname_policy(context, key, value);
1344 if (proc_cmdline_key_streq(key, "rd.bootif"))
1345 return parse_cmdline_rd_bootif(context, key, value);
1346 if (proc_cmdline_key_streq(key, "BOOTIF"))
1347 return parse_cmdline_bootif_mac(context, key, value);
1348
1349 return 0;
1350 }
1351
1352 void context_finalize_bootif(Context *context) {
1353 assert(context);
1354
1355 Network *network = hashmap_get(context->networks_by_name, "BOOTIF");
1356 if (!network)
1357 return;
1358
1359 /* rd.bootif=0 disables BOOTIF= handling */
1360 if (context->skip_bootif) {
1361 network_free(hashmap_remove_value(context->networks_by_name, "BOOTIF", network));
1362 return;
1363 }
1364
1365 if (hw_addr_is_null(&network->match_mac)) {
1366 log_debug("Expected MAC address for BOOTIF, but BOOTIF= is unset.");
1367 network_free(hashmap_remove_value(context->networks_by_name, "BOOTIF", network));
1368 return;
1369 }
1370 }
1371
1372 int context_merge_networks(Context *context) {
1373 Network *all, *network;
1374 int r;
1375
1376 assert(context);
1377
1378 /* Copy settings about the following options
1379 rd.route=<net>/<netmask>:<gateway>[:<interface>]
1380 nameserver=<IP> [nameserver=<IP> ...]
1381 rd.peerdns=0 */
1382
1383 all = network_get(context, "");
1384 if (!all)
1385 return 0;
1386
1387 if (hashmap_size(context->networks_by_name) <= 1)
1388 return 0;
1389
1390 HASHMAP_FOREACH(network, context->networks_by_name) {
1391 if (network == all)
1392 continue;
1393
1394 network->dhcp_use_dns = all->dhcp_use_dns;
1395
1396 r = strv_extend_strv(&network->dns, all->dns, false);
1397 if (r < 0)
1398 return log_oom_debug();
1399
1400 LIST_FOREACH(routes, route, all->routes) {
1401 r = route_new(network, route->family, route->prefixlen, &route->dest, &route->gateway, NULL);
1402 if (r < 0)
1403 return log_debug_errno(r, "Failed to copy route: %m");
1404 }
1405 }
1406
1407 assert_se(hashmap_remove(context->networks_by_name, "") == all);
1408 network_free(all);
1409 return 0;
1410 }
1411
1412 void context_clear(Context *context) {
1413 if (!context)
1414 return;
1415
1416 hashmap_free(context->networks_by_name);
1417 hashmap_free(context->netdevs_by_name);
1418 hashmap_free(context->links_by_filename);
1419 }
1420
1421 static int address_dump(Address *address, FILE *f) {
1422 assert(address);
1423 assert(f);
1424
1425 fprintf(f,
1426 "\n[Address]\n"
1427 "Address=%s\n",
1428 IN_ADDR_PREFIX_TO_STRING(address->family, &address->address, address->prefixlen));
1429 if (in_addr_is_set(address->family, &address->peer))
1430 fprintf(f, "Peer=%s\n",
1431 IN_ADDR_TO_STRING(address->family, &address->peer));
1432 return 0;
1433 }
1434
1435 static int route_dump(Route *route, FILE *f) {
1436 assert(route);
1437 assert(f);
1438
1439 fputs("\n[Route]\n", f);
1440 if (in_addr_is_set(route->family, &route->dest))
1441 fprintf(f, "Destination=%s\n",
1442 IN_ADDR_PREFIX_TO_STRING(route->family, &route->dest, route->prefixlen));
1443 if (in_addr_is_set(route->family, &route->gateway))
1444 fprintf(f, "Gateway=%s\n",
1445 IN_ADDR_TO_STRING(route->family, &route->gateway));
1446
1447 return 0;
1448 }
1449
1450 void network_dump(Network *network, FILE *f) {
1451 const char *dhcp;
1452
1453 assert(network);
1454 assert(f);
1455
1456 fputs("[Match]\n", f);
1457
1458 if (isempty(network->ifname))
1459 /* If the interface name is not specified, then let's make the .network file match the all
1460 * physical interfaces. */
1461 fputs("Kind=!*\n"
1462 "Type=!loopback\n", f);
1463 else if (streq(network->ifname, "BOOTIF"))
1464 fprintf(f, "MACAddress=%s\n", HW_ADDR_TO_STR(&network->match_mac));
1465 else
1466 fprintf(f, "Name=%s\n", network->ifname);
1467
1468 fputs("\n[Link]\n", f);
1469
1470 if (!ether_addr_is_null(&network->mac))
1471 fprintf(f, "MACAddress=%s\n", ETHER_ADDR_TO_STR(&network->mac));
1472 if (network->mtu > 0)
1473 fprintf(f, "MTUBytes=%" PRIu32 "\n", network->mtu);
1474
1475 fputs("\n[Network]\n", f);
1476
1477 dhcp = networkd_dhcp_type_to_string(network->dhcp_type);
1478 if (dhcp)
1479 fprintf(f, "DHCP=%s\n", dhcp);
1480
1481 const char *ll;
1482 ll = networkd_link_local_type_to_string(network->dhcp_type);
1483 if (ll)
1484 fprintf(f, "LinkLocalAddressing=%s\n", ll);
1485
1486 const char *ra;
1487 ra = networkd_ipv6ra_type_to_string(network->dhcp_type);
1488 if (ra)
1489 fprintf(f, "IPv6AcceptRA=%s\n", ra);
1490
1491 if (!strv_isempty(network->dns))
1492 STRV_FOREACH(dns, network->dns)
1493 fprintf(f, "DNS=%s\n", *dns);
1494
1495 STRV_FOREACH(v, network->vlan)
1496 fprintf(f, "VLAN=%s\n", *v);
1497
1498 if (network->bridge)
1499 fprintf(f, "Bridge=%s\n", network->bridge);
1500
1501 if (network->bond)
1502 fprintf(f, "Bond=%s\n", network->bond);
1503
1504 if (network->ntp)
1505 fprintf(f, "NTP=%s\n", network->ntp);
1506
1507 fputs("\n[DHCP]\n", f);
1508
1509 if (!isempty(network->hostname))
1510 fprintf(f, "Hostname=%s\n", network->hostname);
1511
1512 if (network->dhcp_use_dns >= 0)
1513 fprintf(f, "UseDNS=%s\n", yes_no(network->dhcp_use_dns));
1514
1515 LIST_FOREACH(addresses, address, network->addresses)
1516 (void) address_dump(address, f);
1517
1518 LIST_FOREACH(routes, route, network->routes)
1519 (void) route_dump(route, f);
1520 }
1521
1522 void netdev_dump(NetDev *netdev, FILE *f) {
1523 assert(netdev);
1524 assert(f);
1525
1526 fprintf(f,
1527 "[NetDev]\n"
1528 "Kind=%s\n"
1529 "Name=%s\n",
1530 netdev->kind,
1531 netdev->ifname);
1532
1533 if (netdev->mtu > 0)
1534 fprintf(f, "MTUBytes=%" PRIu32 "\n", netdev->mtu);
1535
1536 if (streq(netdev->kind, "vlan"))
1537 fprintf(f,
1538 "\n[VLAN]\n"
1539 "Id=%u\n",
1540 netdev->vlan_id);
1541 }
1542
1543 void link_dump(Link *link, FILE *f) {
1544 assert(link);
1545 assert(f);
1546
1547 fputs("[Match]\n", f);
1548
1549 if (!hw_addr_is_null(&link->mac))
1550 fprintf(f, "MACAddress=%s\n", HW_ADDR_TO_STR(&link->mac));
1551 else
1552 fputs("OriginalName=*\n", f);
1553
1554 fputs("\n[Link]\n", f);
1555
1556 if (!isempty(link->ifname))
1557 fprintf(f, "Name=%s\n", link->ifname);
1558
1559 if (!strv_isempty(link->policies)) {
1560 fputs("NamePolicy=", f);
1561 fputstrv(f, link->policies, " ", NULL);
1562 fputc('\n', f);
1563 }
1564
1565 if (!strv_isempty(link->alt_policies)) {
1566 fputs("AlternativeNamesPolicy=", f);
1567 fputstrv(f, link->alt_policies, " ", NULL);
1568 fputc('\n', f);
1569 }
1570 }
1571
1572 int network_format(Network *network, char **ret) {
1573 _cleanup_(memstream_done) MemStream m = {};
1574 FILE *f;
1575
1576 assert(network);
1577 assert(ret);
1578
1579 f = memstream_init(&m);
1580 if (!f)
1581 return log_oom_debug();
1582
1583 network_dump(network, f);
1584
1585 return memstream_finalize(&m, ret, NULL);
1586 }
1587
1588 int netdev_format(NetDev *netdev, char **ret) {
1589 _cleanup_(memstream_done) MemStream m = {};
1590 FILE *f;
1591
1592 assert(netdev);
1593 assert(ret);
1594
1595 f = memstream_init(&m);
1596 if (!f)
1597 return log_oom_debug();
1598
1599 netdev_dump(netdev, f);
1600
1601 return memstream_finalize(&m, ret, NULL);
1602 }
1603
1604 int link_format(Link *link, char **ret) {
1605 _cleanup_(memstream_done) MemStream m = {};
1606 FILE *f;
1607
1608 assert(link);
1609 assert(ret);
1610
1611 f = memstream_init(&m);
1612 if (!f)
1613 return log_oom_debug();
1614
1615 link_dump(link, f);
1616
1617 return memstream_finalize(&m, ret, NULL);
1618 }