Debian Codegraph @

src/network/networkd-state-file.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <net/if.h>
4 #include <netinet/in.h>
5 #include <sys/stat.h>
6 #include <unistd.h>
7
8 #include "sd-dhcp6-lease.h"
9
10 #include "alloc-util.h"
11 #include "dns-domain.h"
12 #include "dns-resolver-internal.h"
13 #include "errno-util.h"
14 #include "escape.h"
15 #include "fd-util.h"
16 #include "fileio.h"
17 #include "fs-util.h"
18 #include "network-internal.h"
19 #include "networkd-dhcp-common.h"
20 #include "networkd-link.h"
21 #include "networkd-manager.h"
22 #include "networkd-manager-bus.h"
23 #include "networkd-network.h"
24 #include "networkd-ntp.h"
25 #include "networkd-state-file.h"
26 #include "networkd-wwan.h"
27 #include "ordered-set.h"
28 #include "set.h"
29 #include "string-util.h"
30 #include "strv.h"
31 #include "tmpfile-util.h"
32
33 static int ordered_set_put_dns_servers(OrderedSet **s, int ifindex, struct in_addr_full **dns, unsigned n) {
34 int r;
35
36 assert(s);
37 assert(dns || n == 0);
38
39 FOREACH_ARRAY(a, dns, n) {
40 const char *p;
41
42 if ((*a)->ifindex != 0 && (*a)->ifindex != ifindex)
43 return 0;
44
45 p = in_addr_full_to_string(*a);
46 if (!p)
47 return 0;
48
49 r = ordered_set_put_strdup(s, p);
50 if (r < 0)
51 return r;
52 }
53
54 return 0;
55 }
56
57 static int ordered_set_put_in4_addrv(
58 OrderedSet **s,
59 const struct in_addr *addresses,
60 size_t n,
61 bool (*predicate)(const struct in_addr *addr)) {
62
63 int r;
64
65 assert(s);
66 assert(n == 0 || addresses);
67
68 FOREACH_ARRAY(a, addresses, n) {
69 if (predicate && !predicate(a))
70 continue;
71
72 r = ordered_set_put_strdup(s, IN4_ADDR_TO_STRING(a));
73 if (r < 0)
74 return r;
75 }
76
77 return 0;
78 }
79
80 static int ordered_set_put_in6_addrv(
81 OrderedSet **s,
82 const struct in6_addr *addresses,
83 size_t n) {
84
85 int r;
86
87 assert(s);
88 assert(n == 0 || addresses);
89
90 FOREACH_ARRAY(a, addresses, n) {
91 r = ordered_set_put_strdup(s, IN6_ADDR_TO_STRING(a));
92 if (r < 0)
93 return r;
94 }
95
96 return 0;
97 }
98
99 static int link_put_dns(Link *link, OrderedSet **s) {
100 int r;
101
102 assert(link);
103 assert(link->network);
104 assert(s);
105
106 if (link->n_dns != UINT_MAX)
107 return ordered_set_put_dns_servers(s, link->ifindex, link->dns, link->n_dns);
108
109 r = ordered_set_put_dns_servers(s, link->ifindex, link->network->dns, link->network->n_dns);
110 if (r < 0)
111 return r;
112
113 Bearer *b;
114
115 if (link_get_bearer(link, &b) >= 0) {
116 r = ordered_set_put_dns_servers(s, link->ifindex, b->dns, b->n_dns);
117 if (r < 0)
118 return r;
119 }
120
121 if (link->dhcp_lease && link_get_use_dns(link, NETWORK_CONFIG_SOURCE_DHCP4)) {
122 const struct in_addr *addresses;
123
124 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
125 if (r >= 0) {
126 r = ordered_set_put_in4_addrv(s, addresses, r, in4_addr_is_non_local);
127 if (r < 0)
128 return r;
129 }
130 }
131
132 if (link->dhcp_lease && link_get_use_dnr(link, NETWORK_CONFIG_SOURCE_DHCP4)) {
133 sd_dns_resolver *resolvers;
134
135 r = sd_dhcp_lease_get_dnr(link->dhcp_lease, &resolvers);
136 if (r >= 0) {
137 struct in_addr_full **dot_servers;
138 size_t n = 0;
139 CLEANUP_ARRAY(dot_servers, n, in_addr_full_free_array);
140
141 r = dns_resolvers_to_dot_addrs(resolvers, r, &dot_servers, &n);
142 if (r < 0)
143 return r;
144 r = ordered_set_put_dns_servers(s, link->ifindex, dot_servers, n);
145 if (r < 0)
146 return r;
147 }
148 }
149
150 if (link->dhcp6_lease && link_get_use_dns(link, NETWORK_CONFIG_SOURCE_DHCP6)) {
151 const struct in6_addr *addresses;
152
153 r = sd_dhcp6_lease_get_dns(link->dhcp6_lease, &addresses);
154 if (r >= 0) {
155 r = ordered_set_put_in6_addrv(s, addresses, r);
156 if (r < 0)
157 return r;
158 }
159 }
160
161 if (link->dhcp6_lease && link_get_use_dnr(link, NETWORK_CONFIG_SOURCE_DHCP6)) {
162 sd_dns_resolver *resolvers;
163
164 r = sd_dhcp6_lease_get_dnr(link->dhcp6_lease, &resolvers);
165 if (r >= 0) {
166 struct in_addr_full **dot_servers;
167 size_t n = 0;
168 CLEANUP_ARRAY(dot_servers, n, in_addr_full_free_array);
169
170 r = dns_resolvers_to_dot_addrs(resolvers, r, &dot_servers, &n);
171 if (r < 0)
172 return r;
173
174 r = ordered_set_put_dns_servers(s, link->ifindex, dot_servers, n);
175 if (r < 0)
176 return r;
177 }
178 }
179
180 if (link_get_use_dns(link, NETWORK_CONFIG_SOURCE_NDISC)) {
181 NDiscRDNSS *a;
182
183 SET_FOREACH(a, link->ndisc_rdnss) {
184 r = ordered_set_put_in6_addrv(s, &a->address, 1);
185 if (r < 0)
186 return r;
187 }
188 }
189
190 if (link_get_use_dnr(link, NETWORK_CONFIG_SOURCE_NDISC)) {
191 NDiscDNR *a;
192
193 SET_FOREACH(a, link->ndisc_dnr) {
194 struct in_addr_full **dot_servers = NULL;
195 size_t n = 0;
196 CLEANUP_ARRAY(dot_servers, n, in_addr_full_free_array);
197
198 r = dns_resolvers_to_dot_addrs(&a->resolver, 1, &dot_servers, &n);
199 if (r < 0)
200 return r;
201
202 r = ordered_set_put_dns_servers(s, link->ifindex, dot_servers, n);
203 if (r < 0)
204 return r;
205 }
206 }
207
208 return 0;
209 }
210
211 static int link_put_ntp(Link *link, OrderedSet **s) {
212 int r;
213
214 assert(link);
215 assert(link->network);
216 assert(s);
217
218 if (link->ntp)
219 return ordered_set_put_strdupv(s, link->ntp);
220
221 r = ordered_set_put_strdupv(s, link->network->ntp);
222 if (r < 0)
223 return r;
224
225 if (link->dhcp_lease && link_get_use_ntp(link, NETWORK_CONFIG_SOURCE_DHCP4)) {
226 const struct in_addr *addresses;
227
228 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
229 if (r >= 0) {
230 r = ordered_set_put_in4_addrv(s, addresses, r, in4_addr_is_non_local);
231 if (r < 0)
232 return r;
233 }
234 }
235
236 if (link->dhcp6_lease && link_get_use_ntp(link, NETWORK_CONFIG_SOURCE_DHCP6)) {
237 const struct in6_addr *addresses;
238 char **fqdn;
239
240 r = sd_dhcp6_lease_get_ntp_addrs(link->dhcp6_lease, &addresses);
241 if (r >= 0) {
242 r = ordered_set_put_in6_addrv(s, addresses, r);
243 if (r < 0)
244 return r;
245 }
246
247 r = sd_dhcp6_lease_get_ntp_fqdn(link->dhcp6_lease, &fqdn);
248 if (r >= 0) {
249 r = ordered_set_put_strdupv(s, fqdn);
250 if (r < 0)
251 return r;
252 }
253 }
254
255 return 0;
256 }
257
258 static int link_put_sip(Link *link, OrderedSet **s) {
259 int r;
260
261 assert(link);
262 assert(link->network);
263 assert(s);
264
265 if (link->dhcp_lease && link->network->dhcp_use_sip) {
266 const struct in_addr *addresses;
267
268 r = sd_dhcp_lease_get_sip(link->dhcp_lease, &addresses);
269 if (r >= 0) {
270 r = ordered_set_put_in4_addrv(s, addresses, r, in4_addr_is_non_local);
271 if (r < 0)
272 return r;
273 }
274 }
275
276 if (link->dhcp6_lease && link->network->dhcp6_use_sip) {
277 const struct in6_addr *addresses;
278 char **domains;
279
280 r = sd_dhcp6_lease_get_sip_addrs(link->dhcp6_lease, &addresses);
281 if (r >= 0) {
282 r = ordered_set_put_in6_addrv(s, addresses, r);
283 if (r < 0)
284 return r;
285 }
286
287 r = sd_dhcp6_lease_get_sip_domains(link->dhcp6_lease, &domains);
288 if (r >= 0) {
289 r = ordered_set_put_strdupv_full(s, &dns_name_hash_ops_free, domains);
290 if (r < 0)
291 return r;
292 }
293 }
294
295 return 0;
296 }
297
298 static int link_put_domains(Link *link, bool is_route, OrderedSet **s) {
299 OrderedSet *link_domains, *network_domains;
300 UseDomains use_domains;
301 int r;
302
303 assert(link);
304 assert(link->network);
305 assert(s);
306
307 link_domains = is_route ? link->route_domains : link->search_domains;
308 network_domains = is_route ? link->network->route_domains : link->network->search_domains;
309 use_domains = is_route ? USE_DOMAINS_ROUTE : USE_DOMAINS_YES;
310
311 if (link_domains)
312 return ordered_set_put_string_set_full(s, &dns_name_hash_ops_free, link_domains);
313
314 r = ordered_set_put_string_set_full(s, &dns_name_hash_ops_free, network_domains);
315 if (r < 0)
316 return r;
317
318 if (link->dhcp_lease && link_get_use_domains(link, NETWORK_CONFIG_SOURCE_DHCP4) == use_domains) {
319 const char *domainname;
320 char **domains;
321
322 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
323 if (r >= 0) {
324 r = ordered_set_put_strdup_full(s, &dns_name_hash_ops_free, domainname);
325 if (r < 0)
326 return r;
327 }
328
329 r = sd_dhcp_lease_get_search_domains(link->dhcp_lease, &domains);
330 if (r >= 0) {
331 r = ordered_set_put_strdupv_full(s, &dns_name_hash_ops_free, domains);
332 if (r < 0)
333 return r;
334 }
335 }
336
337 if (link->dhcp6_lease && link_get_use_domains(link, NETWORK_CONFIG_SOURCE_DHCP6) == use_domains) {
338 char **domains;
339
340 r = sd_dhcp6_lease_get_domains(link->dhcp6_lease, &domains);
341 if (r >= 0) {
342 r = ordered_set_put_strdupv_full(s, &dns_name_hash_ops_free, domains);
343 if (r < 0)
344 return r;
345 }
346 }
347
348 if (link_get_use_domains(link, NETWORK_CONFIG_SOURCE_NDISC) == use_domains) {
349 NDiscDNSSL *a;
350
351 SET_FOREACH(a, link->ndisc_dnssl) {
352 r = ordered_set_put_strdup_full(s, &dns_name_hash_ops_free, ndisc_dnssl_domain(a));
353 if (r < 0)
354 return r;
355 }
356 }
357
358 return 0;
359 }
360
361 int manager_save(Manager *m) {
362 _cleanup_ordered_set_free_ OrderedSet *dns = NULL, *ntp = NULL, *sip = NULL, *search_domains = NULL, *route_domains = NULL;
363 const char *operstate_str, *carrier_state_str, *address_state_str, *ipv4_address_state_str, *ipv6_address_state_str, *online_state_str;
364 LinkOperationalState operstate = LINK_OPERSTATE_OFF;
365 LinkCarrierState carrier_state = LINK_CARRIER_STATE_OFF;
366 LinkAddressState ipv4_address_state = LINK_ADDRESS_STATE_OFF, ipv6_address_state = LINK_ADDRESS_STATE_OFF,
367 address_state = LINK_ADDRESS_STATE_OFF;
368 LinkOnlineState online_state;
369 size_t links_offline = 0, links_online = 0;
370 int r;
371
372 assert(m);
373
374 if (isempty(m->state_file))
375 return 0; /* Do not update state file when running in test mode. */
376
377 Link *link;
378 HASHMAP_FOREACH(link, m->links_by_index) {
379 if (link->flags & IFF_LOOPBACK)
380 continue;
381
382 operstate = MAX(operstate, link->operstate);
383 carrier_state = MAX(carrier_state, link->carrier_state);
384 address_state = MAX(address_state, link->address_state);
385 ipv4_address_state = MAX(ipv4_address_state, link->ipv4_address_state);
386 ipv6_address_state = MAX(ipv6_address_state, link->ipv6_address_state);
387
388 if (!link->network)
389 continue;
390
391 if (link->network->required_for_online) {
392 if (link->online_state == LINK_ONLINE_STATE_OFFLINE)
393 links_offline++;
394 else if (link->online_state == LINK_ONLINE_STATE_ONLINE)
395 links_online++;
396 }
397
398 r = link_put_dns(link, &dns);
399 if (r < 0)
400 return r;
401
402 r = link_put_ntp(link, &ntp);
403 if (r < 0)
404 return r;
405
406 r = link_put_sip(link, &sip);
407 if (r < 0)
408 return r;
409
410 r = link_put_domains(link, /* is_route= */ false, &search_domains);
411 if (r < 0)
412 return r;
413
414 r = link_put_domains(link, /* is_route= */ true, &route_domains);
415 if (r < 0)
416 return r;
417 }
418
419 if (carrier_state >= LINK_CARRIER_STATE_ENSLAVED)
420 carrier_state = LINK_CARRIER_STATE_CARRIER;
421
422 online_state = links_online > 0 ?
423 (links_offline > 0 ? LINK_ONLINE_STATE_PARTIAL : LINK_ONLINE_STATE_ONLINE) :
424 (links_offline > 0 ? LINK_ONLINE_STATE_OFFLINE : _LINK_ONLINE_STATE_INVALID);
425
426 operstate_str = ASSERT_PTR(link_operstate_to_string(operstate));
427 carrier_state_str = ASSERT_PTR(link_carrier_state_to_string(carrier_state));
428 address_state_str = ASSERT_PTR(link_address_state_to_string(address_state));
429 ipv4_address_state_str = ASSERT_PTR(link_address_state_to_string(ipv4_address_state));
430 ipv6_address_state_str = ASSERT_PTR(link_address_state_to_string(ipv6_address_state));
431
432 _cleanup_(unlink_and_freep) char *temp_path = NULL;
433 _cleanup_fclose_ FILE *f = NULL;
434
435 r = fopen_temporary(m->state_file, &f, &temp_path);
436 if (r < 0)
437 return r;
438
439 (void) fchmod(fileno(f), 0644);
440
441 fprintf(f,
442 "# This is private data. Do not parse.\n"
443 "OPER_STATE=%s\n"
444 "CARRIER_STATE=%s\n"
445 "ADDRESS_STATE=%s\n"
446 "IPV4_ADDRESS_STATE=%s\n"
447 "IPV6_ADDRESS_STATE=%s\n",
448 operstate_str, carrier_state_str, address_state_str, ipv4_address_state_str, ipv6_address_state_str);
449
450 online_state_str = link_online_state_to_string(online_state);
451 if (online_state_str)
452 fprintf(f, "ONLINE_STATE=%s\n", online_state_str);
453
454 ordered_set_print(f, "DNS=", dns);
455 ordered_set_print(f, "NTP=", ntp);
456 ordered_set_print(f, "SIP=", sip);
457 ordered_set_print(f, "DOMAINS=", search_domains);
458 ordered_set_print(f, "ROUTE_DOMAINS=", route_domains);
459
460 r = fflush_and_check(f);
461 if (r < 0)
462 return r;
463
464 r = conservative_rename(temp_path, m->state_file);
465 if (r < 0)
466 return r;
467
468 temp_path = mfree(temp_path);
469
470 _cleanup_strv_free_ char **p = NULL;
471
472 if (m->operational_state != operstate) {
473 m->operational_state = operstate;
474 if (strv_extend(&p, "OperationalState") < 0)
475 log_oom();
476 }
477
478 if (m->carrier_state != carrier_state) {
479 m->carrier_state = carrier_state;
480 if (strv_extend(&p, "CarrierState") < 0)
481 log_oom();
482 }
483
484 if (m->address_state != address_state) {
485 m->address_state = address_state;
486 if (strv_extend(&p, "AddressState") < 0)
487 log_oom();
488 }
489
490 if (m->ipv4_address_state != ipv4_address_state) {
491 m->ipv4_address_state = ipv4_address_state;
492 if (strv_extend(&p, "IPv4AddressState") < 0)
493 log_oom();
494 }
495
496 if (m->ipv6_address_state != ipv6_address_state) {
497 m->ipv6_address_state = ipv6_address_state;
498 if (strv_extend(&p, "IPv6AddressState") < 0)
499 log_oom();
500 }
501
502 if (m->online_state != online_state) {
503 m->online_state = online_state;
504 if (strv_extend(&p, "OnlineState") < 0)
505 log_oom();
506 }
507
508 if (p) {
509 r = manager_send_changed_strv(m, p);
510 if (r < 0)
511 log_warning_errno(r, "Could not emit changed properties, ignoring: %m");
512 }
513
514 m->dirty = false;
515
516 return 0;
517 }
518
519 static void print_link_hashmap(FILE *f, const char *prefix, Hashmap* h) {
520 bool space = false;
521 Link *link;
522
523 assert(f);
524 assert(prefix);
525
526 if (hashmap_isempty(h))
527 return;
528
529 fputs(prefix, f);
530 HASHMAP_FOREACH(link, h) {
531 if (space)
532 fputc(' ', f);
533
534 fprintf(f, "%i", link->ifindex);
535 space = true;
536 }
537
538 fputc('\n', f);
539 }
540
541 static void link_save_dns(Link *link, FILE *f, struct in_addr_full **dns, unsigned n_dns, bool *space) {
542 bool _space = false;
543
544 if (!space)
545 space = &_space;
546
547 for (unsigned j = 0; j < n_dns; j++) {
548 const char *str;
549
550 if (dns[j]->ifindex != 0 && dns[j]->ifindex != link->ifindex)
551 continue;
552
553 str = in_addr_full_to_string(dns[j]);
554 if (!str)
555 continue;
556
557 if (*space)
558 fputc(' ', f);
559 fputs(str, f);
560 *space = true;
561 }
562 }
563
564 static void serialize_addresses(
565 FILE *f,
566 const char *lvalue,
567 bool *space,
568 char **addresses,
569 sd_dhcp_lease *lease,
570 bool conditional,
571 sd_dhcp_lease_server_type_t what,
572 sd_dhcp6_lease *lease6,
573 bool conditional6,
574 int (*lease6_get_addr)(sd_dhcp6_lease*, const struct in6_addr**),
575 int (*lease6_get_fqdn)(sd_dhcp6_lease*, char ***)) {
576
577 bool _space = false;
578 int r;
579
580 if (!space)
581 space = &_space;
582
583 if (lvalue)
584 fprintf(f, "%s=", lvalue);
585 fputstrv(f, addresses, NULL, space);
586
587 if (lease && conditional) {
588 const struct in_addr *lease_addresses;
589
590 r = sd_dhcp_lease_get_servers(lease, what, &lease_addresses);
591 if (r > 0)
592 serialize_in_addrs(f, lease_addresses, r, space, in4_addr_is_non_local);
593 }
594
595 if (lease6 && conditional6 && lease6_get_addr) {
596 const struct in6_addr *in6_addrs;
597
598 r = lease6_get_addr(lease6, &in6_addrs);
599 if (r > 0)
600 serialize_in6_addrs(f, in6_addrs, r, space);
601 }
602
603 if (lease6 && conditional6 && lease6_get_fqdn) {
604 char **in6_hosts;
605
606 r = lease6_get_fqdn(lease6, &in6_hosts);
607 if (r > 0)
608 fputstrv(f, in6_hosts, NULL, space);
609 }
610
611 if (lvalue)
612 fputc('\n', f);
613 }
614
615 static void serialize_resolvers(
616 FILE *f,
617 const char *lvalue,
618 bool *space,
619 sd_dhcp_lease *lease,
620 bool conditional,
621 sd_dhcp6_lease *lease6,
622 bool conditional6) {
623
624 bool _space = false;
625 if (!space)
626 space = &_space;
627
628 if (lvalue)
629 fprintf(f, "%s=", lvalue);
630
631 if (lease && conditional) {
632 sd_dns_resolver *resolvers;
633 _cleanup_strv_free_ char **names = NULL;
634 int r;
635
636 r = sd_dhcp_lease_get_dnr(lease, &resolvers);
637 if (r < 0 && r != -ENODATA)
638 log_warning_errno(r, "Failed to get DNR from DHCP lease, ignoring: %m");
639
640 if (r > 0) {
641 r = dns_resolvers_to_dot_strv(resolvers, r, &names);
642 if (r < 0)
643 return (void) log_warning_errno(r, "Failed to get DoT servers from DHCP DNR, ignoring: %m");
644 if (r > 0)
645 fputstrv(f, names, NULL, space);
646 }
647 }
648
649 if (lease6 && conditional6) {
650 sd_dns_resolver *resolvers;
651 _cleanup_strv_free_ char **names = NULL;
652 int r;
653
654 r = sd_dhcp6_lease_get_dnr(lease6, &resolvers);
655 if (r >= 0) {
656 r = dns_resolvers_to_dot_strv(resolvers, r, &names);
657 if (r < 0)
658 return (void) log_warning_errno(r, "Failed to get DoT servers from DHCPv6 DNR, ignoring: %m");
659 if (r > 0)
660 fputstrv(f, names, NULL, space);
661 }
662 }
663
664 if (lvalue)
665 fputc('\n', f);
666
667 return;
668 }
669
670 static void link_save_domains(Link *link, FILE *f, OrderedSet *static_domains, UseDomains use_domains) {
671 bool space = false;
672 const char *p;
673
674 assert(link);
675 assert(link->network);
676 assert(f);
677
678 ORDERED_SET_FOREACH(p, static_domains)
679 fputs_with_separator(f, p, NULL, &space);
680
681 if (use_domains == USE_DOMAINS_NO)
682 return;
683
684 if (link->dhcp_lease && link_get_use_domains(link, NETWORK_CONFIG_SOURCE_DHCP4) == use_domains) {
685 const char *domainname;
686 char **domains;
687
688 if (sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname) >= 0)
689 fputs_with_separator(f, domainname, NULL, &space);
690 if (sd_dhcp_lease_get_search_domains(link->dhcp_lease, &domains) >= 0)
691 fputstrv(f, domains, NULL, &space);
692 }
693
694 if (link->dhcp6_lease && link_get_use_domains(link, NETWORK_CONFIG_SOURCE_DHCP6) == use_domains) {
695 char **domains;
696
697 if (sd_dhcp6_lease_get_domains(link->dhcp6_lease, &domains) >= 0)
698 fputstrv(f, domains, NULL, &space);
699 }
700
701 if (link_get_use_domains(link, NETWORK_CONFIG_SOURCE_NDISC) == use_domains) {
702 NDiscDNSSL *dd;
703
704 SET_FOREACH(dd, link->ndisc_dnssl)
705 fputs_with_separator(f, ndisc_dnssl_domain(dd), NULL, &space);
706 }
707 }
708
709 static int serialize_config_files(FILE *f, const char *prefix, const char *main_config, char * const *dropins) {
710 assert(f);
711 assert(prefix);
712 assert(main_config);
713
714 fprintf(f, "%s_FILE=%s\n", prefix, main_config);
715
716 bool space = false;
717
718 fprintf(f, "%s_FILE_DROPINS=\"", prefix);
719 STRV_FOREACH(d, dropins) {
720 _cleanup_free_ char *escaped = NULL;
721
722 escaped = xescape(*d, ":");
723 if (!escaped)
724 return -ENOMEM;
725
726 fputs_with_separator(f, escaped, ":", &space);
727 }
728 fputs("\"\n", f);
729
730 return 0;
731 }
732
733 static int link_save(Link *link) {
734 const char *admin_state, *oper_state, *carrier_state, *address_state, *ipv4_address_state, *ipv6_address_state;
735 _cleanup_(unlink_and_freep) char *temp_path = NULL;
736 _cleanup_fclose_ FILE *f = NULL;
737 int r;
738
739 assert(link);
740 assert(link->manager);
741
742 if (isempty(link->state_file))
743 return 0; /* Do not update state files when running in test mode. */
744
745 if (link->state == LINK_STATE_LINGER)
746 return 0;
747
748 admin_state = ASSERT_PTR(link_state_to_string(link->state));
749 oper_state = ASSERT_PTR(link_operstate_to_string(link->operstate));
750 carrier_state = ASSERT_PTR(link_carrier_state_to_string(link->carrier_state));
751 address_state = ASSERT_PTR(link_address_state_to_string(link->address_state));
752 ipv4_address_state = ASSERT_PTR(link_address_state_to_string(link->ipv4_address_state));
753 ipv6_address_state = ASSERT_PTR(link_address_state_to_string(link->ipv6_address_state));
754
755 r = fopen_temporary(link->state_file, &f, &temp_path);
756 if (r < 0)
757 return r;
758
759 (void) fchmod(fileno(f), 0644);
760
761 fprintf(f,
762 "# This is private data. Do not parse.\n"
763 "ADMIN_STATE=%s\n"
764 "OPER_STATE=%s\n"
765 "CARRIER_STATE=%s\n"
766 "ADDRESS_STATE=%s\n"
767 "IPV4_ADDRESS_STATE=%s\n"
768 "IPV6_ADDRESS_STATE=%s\n",
769 admin_state, oper_state, carrier_state, address_state, ipv4_address_state, ipv6_address_state);
770
771 if (link->netdev) {
772 r = serialize_config_files(f, "NETDEV", link->netdev->filename, link->netdev->dropins);
773 if (r < 0)
774 return r;
775 }
776
777 if (link->network) {
778 const char *online_state, *captive_portal;
779 bool space = false;
780
781 online_state = link_online_state_to_string(link->online_state);
782 if (online_state)
783 fprintf(f, "ONLINE_STATE=%s\n", online_state);
784
785 fprintf(f, "REQUIRED_FOR_ONLINE=%s\n",
786 yes_no(link->network->required_for_online));
787
788 LinkOperationalStateRange st;
789 link_required_operstate_for_online(link, &st);
790
791 fprintf(f, "REQUIRED_OPER_STATE_FOR_ONLINE=%s:%s\n",
792 link_operstate_to_string(st.min), link_operstate_to_string(st.max));
793
794 fprintf(f, "REQUIRED_FAMILY_FOR_ONLINE=%s\n",
795 link_required_address_family_to_string(link_required_family_for_online(link)));
796
797 fprintf(f, "ACTIVATION_POLICY=%s\n",
798 activation_policy_to_string(link->network->activation_policy));
799
800 r = serialize_config_files(f, "NETWORK", link->network->filename, link->network->dropins);
801 if (r < 0)
802 return r;
803
804 /************************************************************/
805
806 fputs("DNS=", f);
807 if (link->n_dns != UINT_MAX)
808 link_save_dns(link, f, link->dns, link->n_dns, NULL);
809 else {
810 space = false;
811 link_save_dns(link, f, link->network->dns, link->network->n_dns, &space);
812
813 Bearer *b;
814
815 if (link_get_bearer(link, &b) >= 0)
816 link_save_dns(link, f, b->dns, b->n_dns, &space);
817
818 /* DNR resolvers are not required to provide Do53 service, however resolved doesn't
819 * know how to handle such a server so for now Do53 service is required, and
820 * assumed. */
821 serialize_resolvers(f, NULL, &space,
822 link->dhcp_lease,
823 link_get_use_dnr(link, NETWORK_CONFIG_SOURCE_DHCP4),
824 link->dhcp6_lease,
825 link_get_use_dnr(link, NETWORK_CONFIG_SOURCE_DHCP6));
826
827 if (link_get_use_dnr(link, NETWORK_CONFIG_SOURCE_NDISC)) {
828 NDiscDNR *dnr;
829 SET_FOREACH(dnr, link->ndisc_dnr)
830 serialize_dnr(f, &dnr->resolver, 1, &space);
831 }
832
833 serialize_addresses(f, NULL, &space,
834 NULL,
835 link->dhcp_lease,
836 link_get_use_dns(link, NETWORK_CONFIG_SOURCE_DHCP4),
837 SD_DHCP_LEASE_DNS,
838 link->dhcp6_lease,
839 link_get_use_dns(link, NETWORK_CONFIG_SOURCE_DHCP6),
840 sd_dhcp6_lease_get_dns,
841 NULL);
842
843 if (link_get_use_dns(link, NETWORK_CONFIG_SOURCE_NDISC)) {
844 NDiscRDNSS *dd;
845
846 SET_FOREACH(dd, link->ndisc_rdnss)
847 serialize_in6_addrs(f, &dd->address, 1, &space);
848 }
849 }
850
851 fputc('\n', f);
852
853 /************************************************************/
854
855 if (link->ntp) {
856 fputs("NTP=", f);
857 fputstrv(f, link->ntp, NULL, NULL);
858 fputc('\n', f);
859 } else
860 serialize_addresses(f, "NTP", NULL,
861 link->network->ntp,
862 link->dhcp_lease,
863 link_get_use_ntp(link, NETWORK_CONFIG_SOURCE_DHCP4),
864 SD_DHCP_LEASE_NTP,
865 link->dhcp6_lease,
866 link_get_use_ntp(link, NETWORK_CONFIG_SOURCE_DHCP6),
867 sd_dhcp6_lease_get_ntp_addrs,
868 sd_dhcp6_lease_get_ntp_fqdn);
869
870 serialize_addresses(f, "SIP", NULL,
871 NULL,
872 link->dhcp_lease,
873 link->network->dhcp_use_sip,
874 SD_DHCP_LEASE_SIP,
875 link->dhcp6_lease,
876 link->network->dhcp6_use_sip,
877 sd_dhcp6_lease_get_sip_addrs,
878 sd_dhcp6_lease_get_sip_domains);
879
880 /************************************************************/
881
882 r = link_get_captive_portal(link, &captive_portal);
883 if (r < 0)
884 return r;
885
886 if (captive_portal)
887 fprintf(f, "CAPTIVE_PORTAL=%s\n", captive_portal);
888
889 /************************************************************/
890
891 fputs("DOMAINS=", f);
892 if (link->search_domains)
893 link_save_domains(link, f, link->search_domains, USE_DOMAINS_NO);
894 else
895 link_save_domains(link, f, link->network->search_domains, USE_DOMAINS_YES);
896 fputc('\n', f);
897
898 /************************************************************/
899
900 fputs("ROUTE_DOMAINS=", f);
901 if (link->route_domains)
902 link_save_domains(link, f, link->route_domains, USE_DOMAINS_NO);
903 else
904 link_save_domains(link, f, link->network->route_domains, USE_DOMAINS_ROUTE);
905 fputc('\n', f);
906
907 /************************************************************/
908
909 fprintf(f, "LLMNR=%s\n",
910 resolve_support_to_string(link->llmnr >= 0 ? link->llmnr : link->network->llmnr));
911
912 /************************************************************/
913
914 fprintf(f, "MDNS=%s\n",
915 resolve_support_to_string(link->mdns >= 0 ? link->mdns : link->network->mdns));
916
917 /************************************************************/
918
919 int dns_default_route =
920 link->dns_default_route >= 0 ? link->dns_default_route :
921 link->network->dns_default_route;
922 if (dns_default_route >= 0)
923 fprintf(f, "DNS_DEFAULT_ROUTE=%s\n", yes_no(dns_default_route));
924
925 /************************************************************/
926
927 DnsOverTlsMode dns_over_tls_mode =
928 link->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID ? link->dns_over_tls_mode :
929 link->network->dns_over_tls_mode;
930 if (dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
931 fprintf(f, "DNS_OVER_TLS=%s\n", dns_over_tls_mode_to_string(dns_over_tls_mode));
932
933 /************************************************************/
934
935 DnssecMode dnssec_mode =
936 link->dnssec_mode != _DNSSEC_MODE_INVALID ? link->dnssec_mode :
937 link->network->dnssec_mode;
938 if (dnssec_mode != _DNSSEC_MODE_INVALID)
939 fprintf(f, "DNSSEC=%s\n", dnssec_mode_to_string(dnssec_mode));
940
941 /************************************************************/
942
943 Set *nta_anchors = link->dnssec_negative_trust_anchors;
944 if (set_isempty(nta_anchors))
945 nta_anchors = link->network->dnssec_negative_trust_anchors;
946
947 if (!set_isempty(nta_anchors)) {
948 const char *n;
949
950 space = false;
951
952 fputs("DNSSEC_NTA=", f);
953 SET_FOREACH(n, nta_anchors)
954 fputs_with_separator(f, n, NULL, &space);
955 fputc('\n', f);
956 }
957 }
958
959 print_link_hashmap(f, "CARRIER_BOUND_TO=", link->bound_to_links);
960 print_link_hashmap(f, "CARRIER_BOUND_BY=", link->bound_by_links);
961
962 r = link_serialize_dhcp6_client(link, f);
963 if (r < 0)
964 return r;
965
966 r = fflush_and_check(f);
967 if (r < 0)
968 return r;
969
970 r = conservative_rename(temp_path, link->state_file);
971 if (r < 0)
972 return r;
973
974 temp_path = mfree(temp_path);
975
976 return 0;
977 }
978
979 void link_dirty(Link *link) {
980 assert(link);
981 assert(link->manager);
982
983 /* When the manager is in MANAGER_STOPPED, it is not necessary to update state files anymore, as they
984 * will be removed soon anyway. Moreover, we cannot call link_ref() in that case. */
985 if (link->manager->state == MANAGER_STOPPED)
986 return;
987
988 /* The serialized state in /run is no longer up-to-date. */
989
990 /* Also mark manager dirty as link is dirty */
991 link->manager->dirty = true;
992
993 /* The interface has been already removed, and the state file for the interface has been or will be
994 * removed. The file should not be recreated. Note, even in that case, we may need to recreate the
995 * manager state file. Hence the dirty flag for the manager should be set in the above. */
996 if (link->state == LINK_STATE_LINGER)
997 return;
998
999 if (set_ensure_put(&link->manager->dirty_links, &link_hash_ops, link) <= 0)
1000 return; /* Ignore allocation errors and don't take another ref if the link was already dirty */
1001
1002 link_ref(link);
1003 }
1004
1005 void link_clean(Link *link) {
1006 assert(link);
1007 assert(link->manager);
1008
1009 /* The serialized state in /run is up-to-date */
1010
1011 link_unref(set_remove(link->manager->dirty_links, link));
1012 }
1013
1014 int link_save_and_clean_full(Link *link, bool also_save_manager) {
1015 int r, k = 0;
1016
1017 assert(link);
1018 assert(link->manager);
1019
1020 if (also_save_manager)
1021 k = manager_save(link->manager);
1022
1023 r = link_save(link);
1024 if (r < 0)
1025 return r;
1026
1027 link_clean(link);
1028 return k;
1029 }
1030
1031 int manager_clean_all(Manager *manager) {
1032 int r, ret = 0;
1033
1034 assert(manager);
1035
1036 if (manager->dirty) {
1037 r = manager_save(manager);
1038 if (r < 0)
1039 log_warning_errno(r, "Failed to update state file %s, ignoring: %m", manager->state_file);
1040 RET_GATHER(ret, r);
1041 }
1042
1043 Link *link;
1044 SET_FOREACH(link, manager->dirty_links) {
1045 r = link_save_and_clean(link);
1046 if (r < 0)
1047 log_link_warning_errno(link, r, "Failed to update link state file %s, ignoring: %m", link->state_file);
1048 RET_GATHER(ret, r);
1049 }
1050
1051 return ret;
1052 }