src/network/networkd-state-file.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <netinet/in.h>
   4 #include <linux/if.h>
   5
   6 #include "alloc-util.h"
   7 #include "dns-domain.h"
   8 #include "fd-util.h"
   9 #include "fileio.h"
  10 #include "fs-util.h"
  11 #include "network-internal.h"
  12 #include "networkd-link.h"
  13 #include "networkd-manager-bus.h"
  14 #include "networkd-manager.h"
  15 #include "networkd-network.h"
  16 #include "networkd-state-file.h"
  17 #include "ordered-set.h"
  18 #include "set.h"
  19 #include "strv.h"
  20 #include "tmpfile-util.h"
  21
  22 static int ordered_set_put_dns_server(OrderedSet *s, int ifindex, struct in_addr_full *dns) {
  23         const char *p;
  24         int r;
  25
  26         assert(s);
  27         assert(dns);
  28
  29         if (dns->ifindex != 0 && dns->ifindex != ifindex)
  30                 return 0;
  31
  32         p = in_addr_full_to_string(dns);
  33         if (!p)
  34                 return 0;
  35
  36         r = ordered_set_put_strdup(s, p);
  37         if (r == -EEXIST)
  38                 return 0;
  39
  40         return r;
  41 }
  42
  43 static int ordered_set_put_dns_servers(OrderedSet *s, int ifindex, struct in_addr_full **dns, unsigned n) {
  44         int r, c = 0;
  45
  46         assert(s);
  47         assert(dns || n == 0);
  48
  49         for (unsigned i = 0; i < n; i++) {
  50                 r = ordered_set_put_dns_server(s, ifindex, dns[i]);
  51                 if (r < 0)
  52                         return r;
  53
  54                 c += r;
  55         }
  56
  57         return c;
  58 }
  59
  60 static int ordered_set_put_in4_addr(OrderedSet *s, const struct in_addr *address) {
  61         char *p;
  62         int r;
  63
  64         assert(s);
  65         assert(address);
  66
  67         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
  68         if (r < 0)
  69                 return r;
  70
  71         r = ordered_set_consume(s, p);
  72         if (r == -EEXIST)
  73                 return 0;
  74
  75         return r;
  76 }
  77
  78 static int ordered_set_put_in4_addrv(
  79                 OrderedSet *s,
  80                 const struct in_addr *addresses,
  81                 size_t n,
  82                 bool (*predicate)(const struct in_addr *addr)) {
  83
  84         int r, c = 0;
  85
  86         assert(s);
  87         assert(n == 0 || addresses);
  88
  89         for (size_t i = 0; i < n; i++) {
  90                 if (predicate && !predicate(&addresses[i]))
  91                         continue;
  92                 r = ordered_set_put_in4_addr(s, addresses+i);
  93                 if (r < 0)
  94                         return r;
  95
  96                 c += r;
  97         }
  98
  99         return c;
 100 }
 101
 102 int manager_save(Manager *m) {
 103         _cleanup_ordered_set_free_free_ OrderedSet *dns = NULL, *ntp = NULL, *sip = NULL, *search_domains = NULL, *route_domains = NULL;
 104         const char *operstate_str, *carrier_state_str, *address_state_str;
 105         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 106         LinkCarrierState carrier_state = LINK_CARRIER_STATE_OFF;
 107         LinkAddressState address_state = LINK_ADDRESS_STATE_OFF;
 108         _cleanup_(unlink_and_freep) char *temp_path = NULL;
 109         _cleanup_strv_free_ char **p = NULL;
 110         _cleanup_fclose_ FILE *f = NULL;
 111         Link *link;
 112         int r;
 113
 114         assert(m);
 115         assert(m->state_file);
 116
 117         /* We add all NTP and DNS server to a set, to filter out duplicates */
 118         dns = ordered_set_new(&string_hash_ops);
 119         if (!dns)
 120                 return -ENOMEM;
 121
 122         ntp = ordered_set_new(&string_hash_ops);
 123         if (!ntp)
 124                 return -ENOMEM;
 125
 126         sip = ordered_set_new(&string_hash_ops);
 127         if (!sip)
 128                 return -ENOMEM;
 129
 130         search_domains = ordered_set_new(&dns_name_hash_ops);
 131         if (!search_domains)
 132                 return -ENOMEM;
 133
 134         route_domains = ordered_set_new(&dns_name_hash_ops);
 135         if (!route_domains)
 136                 return -ENOMEM;
 137
 138         HASHMAP_FOREACH(link, m->links) {
 139                 const struct in_addr *addresses;
 140
 141                 if (link->flags & IFF_LOOPBACK)
 142                         continue;
 143
 144                 if (link->operstate > operstate)
 145                         operstate = link->operstate;
 146
 147                 if (link->carrier_state > carrier_state)
 148                         carrier_state = link->carrier_state;
 149
 150                 if (link->address_state > address_state)
 151                         address_state = link->address_state;
 152
 153                 if (!link->network)
 154                         continue;
 155
 156                 /* First add the static configured entries */
 157                 if (link->n_dns != UINT_MAX)
 158                         r = ordered_set_put_dns_servers(dns, link->ifindex, link->dns, link->n_dns);
 159                 else
 160                         r = ordered_set_put_dns_servers(dns, link->ifindex, link->network->dns, link->network->n_dns);
 161                 if (r < 0)
 162                         return r;
 163
 164                 r = ordered_set_put_strdupv(ntp, link->ntp ?: link->network->ntp);
 165                 if (r < 0)
 166                         return r;
 167
 168                 r = ordered_set_put_string_set(search_domains, link->search_domains ?: link->network->search_domains);
 169                 if (r < 0)
 170                         return r;
 171
 172                 r = ordered_set_put_string_set(route_domains, link->route_domains ?: link->network->route_domains);
 173                 if (r < 0)
 174                         return r;
 175
 176                 if (!link->dhcp_lease)
 177                         continue;
 178
 179                 /* Secondly, add the entries acquired via DHCP */
 180                 if (link->network->dhcp_use_dns) {
 181                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 182                         if (r > 0) {
 183                                 r = ordered_set_put_in4_addrv(dns, addresses, r, in4_addr_is_non_local);
 184                                 if (r < 0)
 185                                         return r;
 186                         } else if (r < 0 && r != -ENODATA)
 187                                 return r;
 188                 }
 189
 190                 if (link->network->dhcp_use_ntp) {
 191                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 192                         if (r > 0) {
 193                                 r = ordered_set_put_in4_addrv(ntp, addresses, r, in4_addr_is_non_local);
 194                                 if (r < 0)
 195                                         return r;
 196                         } else if (r < 0 && r != -ENODATA)
 197                                 return r;
 198                 }
 199
 200                 if (link->network->dhcp_use_sip) {
 201                         r = sd_dhcp_lease_get_sip(link->dhcp_lease, &addresses);
 202                         if (r > 0) {
 203                                 r = ordered_set_put_in4_addrv(sip, addresses, r, in4_addr_is_non_local);
 204                                 if (r < 0)
 205                                         return r;
 206                         } else if (r < 0 && r != -ENODATA)
 207                                 return r;
 208                 }
 209
 210                 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
 211                         const char *domainname;
 212                         char **domains = NULL;
 213
 214                         OrderedSet *target_domains = (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES) ? search_domains : route_domains;
 215                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 216                         if (r >= 0) {
 217                                 r = ordered_set_put_strdup(target_domains, domainname);
 218                                 if (r < 0)
 219                                         return r;
 220                         } else if (r != -ENODATA)
 221                                 return r;
 222
 223                         r = sd_dhcp_lease_get_search_domains(link->dhcp_lease, &domains);
 224                         if (r >= 0) {
 225                                 r = ordered_set_put_strdupv(target_domains, domains);
 226                                 if (r < 0)
 227                                         return r;
 228                         } else if (r != -ENODATA)
 229                                 return r;
 230                 }
 231         }
 232
 233         if (carrier_state >= LINK_CARRIER_STATE_ENSLAVED)
 234                 carrier_state = LINK_CARRIER_STATE_CARRIER;
 235
 236         operstate_str = link_operstate_to_string(operstate);
 237         assert(operstate_str);
 238
 239         carrier_state_str = link_carrier_state_to_string(carrier_state);
 240         assert(carrier_state_str);
 241
 242         address_state_str = link_address_state_to_string(address_state);
 243         assert(address_state_str);
 244
 245         r = fopen_temporary(m->state_file, &f, &temp_path);
 246         if (r < 0)
 247                 return r;
 248
 249         (void) fchmod(fileno(f), 0644);
 250
 251         fprintf(f,
 252                 "# This is private data. Do not parse.\n"
 253                 "OPER_STATE=%s\n"
 254                 "CARRIER_STATE=%s\n"
 255                 "ADDRESS_STATE=%s\n",
 256                 operstate_str, carrier_state_str, address_state_str);
 257
 258         ordered_set_print(f, "DNS=", dns);
 259         ordered_set_print(f, "NTP=", ntp);
 260         ordered_set_print(f, "SIP=", sip);
 261         ordered_set_print(f, "DOMAINS=", search_domains);
 262         ordered_set_print(f, "ROUTE_DOMAINS=", route_domains);
 263
 264         r = fflush_and_check(f);
 265         if (r < 0)
 266                 return r;
 267
 268         r = conservative_rename(temp_path, m->state_file);
 269         if (r < 0)
 270                 return r;
 271
 272         temp_path = mfree(temp_path);
 273
 274         if (m->operational_state != operstate) {
 275                 m->operational_state = operstate;
 276                 if (strv_extend(&p, "OperationalState") < 0)
 277                         log_oom();
 278         }
 279
 280         if (m->carrier_state != carrier_state) {
 281                 m->carrier_state = carrier_state;
 282                 if (strv_extend(&p, "CarrierState") < 0)
 283                         log_oom();
 284         }
 285
 286         if (m->address_state != address_state) {
 287                 m->address_state = address_state;
 288                 if (strv_extend(&p, "AddressState") < 0)
 289                         log_oom();
 290         }
 291
 292         if (p) {
 293                 r = manager_send_changed_strv(m, p);
 294                 if (r < 0)
 295                         log_warning_errno(r, "Could not emit changed properties, ignoring: %m");
 296         }
 297
 298         m->dirty = false;
 299
 300         return 0;
 301 }
 302
 303 static void print_link_hashmap(FILE *f, const char *prefix, Hashmap* h) {
 304         bool space = false;
 305         Link *link;
 306
 307         assert(f);
 308         assert(prefix);
 309
 310         if (hashmap_isempty(h))
 311                 return;
 312
 313         fputs(prefix, f);
 314         HASHMAP_FOREACH(link, h) {
 315                 if (space)
 316                         fputc(' ', f);
 317
 318                 fprintf(f, "%i", link->ifindex);
 319                 space = true;
 320         }
 321
 322         fputc('\n', f);
 323 }
 324
 325 static void link_save_dns(Link *link, FILE *f, struct in_addr_full **dns, unsigned n_dns, bool *space) {
 326         for (unsigned j = 0; j < n_dns; j++) {
 327                 const char *str;
 328
 329                 if (dns[j]->ifindex != 0 && dns[j]->ifindex != link->ifindex)
 330                         continue;
 331
 332                 str = in_addr_full_to_string(dns[j]);
 333                 if (!str)
 334                         continue;
 335
 336                 if (*space)
 337                         fputc(' ', f);
 338                 fputs(str, f);
 339                 *space = true;
 340         }
 341 }
 342
 343 static void serialize_addresses(
 344                 FILE *f,
 345                 const char *lvalue,
 346                 bool *space,
 347                 char **addresses,
 348                 sd_dhcp_lease *lease,
 349                 bool conditional,
 350                 sd_dhcp_lease_server_type_t what,
 351                 sd_dhcp6_lease *lease6,
 352                 bool conditional6,
 353                 int (*lease6_get_addr)(sd_dhcp6_lease*, const struct in6_addr**),
 354                 int (*lease6_get_fqdn)(sd_dhcp6_lease*, char ***)) {
 355
 356         bool _space = false;
 357         int r;
 358
 359         if (!space)
 360                 space = &_space;
 361
 362         if (lvalue)
 363                 fprintf(f, "%s=", lvalue);
 364         fputstrv(f, addresses, NULL, space);
 365
 366         if (lease && conditional) {
 367                 const struct in_addr *lease_addresses;
 368
 369                 r = sd_dhcp_lease_get_servers(lease, what, &lease_addresses);
 370                 if (r > 0)
 371                         serialize_in_addrs(f, lease_addresses, r, space, in4_addr_is_non_local);
 372         }
 373
 374         if (lease6 && conditional6 && lease6_get_addr) {
 375                 const struct in6_addr *in6_addrs;
 376
 377                 r = lease6_get_addr(lease6, &in6_addrs);
 378                 if (r > 0)
 379                         serialize_in6_addrs(f, in6_addrs, r, space);
 380         }
 381
 382         if (lease6 && conditional6 && lease6_get_fqdn) {
 383                 char **in6_hosts;
 384
 385                 r = lease6_get_fqdn(lease6, &in6_hosts);
 386                 if (r > 0)
 387                         fputstrv(f, in6_hosts, NULL, space);
 388         }
 389
 390         if (lvalue)
 391                 fputc('\n', f);
 392 }
 393
 394 int link_save(Link *link) {
 395         const char *admin_state, *oper_state, *carrier_state, *address_state;
 396         _cleanup_(unlink_and_freep) char *temp_path = NULL;
 397         _cleanup_fclose_ FILE *f = NULL;
 398         int r;
 399
 400         assert(link);
 401         assert(link->state_file);
 402         assert(link->lease_file);
 403         assert(link->manager);
 404
 405         if (link->state == LINK_STATE_LINGER)
 406                 return 0;
 407
 408         link_lldp_save(link);
 409
 410         admin_state = link_state_to_string(link->state);
 411         assert(admin_state);
 412
 413         oper_state = link_operstate_to_string(link->operstate);
 414         assert(oper_state);
 415
 416         carrier_state = link_carrier_state_to_string(link->carrier_state);
 417         assert(carrier_state);
 418
 419         address_state = link_address_state_to_string(link->address_state);
 420         assert(address_state);
 421
 422         r = fopen_temporary(link->state_file, &f, &temp_path);
 423         if (r < 0)
 424                 return r;
 425
 426         (void) fchmod(fileno(f), 0644);
 427
 428         fprintf(f,
 429                 "# This is private data. Do not parse.\n"
 430                 "ADMIN_STATE=%s\n"
 431                 "OPER_STATE=%s\n"
 432                 "CARRIER_STATE=%s\n"
 433                 "ADDRESS_STATE=%s\n",
 434                 admin_state, oper_state, carrier_state, address_state);
 435
 436         if (link->network) {
 437                 char **dhcp6_domains = NULL, **dhcp_domains = NULL;
 438                 const char *dhcp_domainname = NULL, *p;
 439                 bool space;
 440
 441                 fprintf(f, "REQUIRED_FOR_ONLINE=%s\n",
 442                         yes_no(link->network->required_for_online));
 443
 444                 LinkOperationalStateRange st = link->network->required_operstate_for_online;
 445                 fprintf(f, "REQUIRED_OPER_STATE_FOR_ONLINE=%s%s%s\n",
 446                         strempty(link_operstate_to_string(st.min)),
 447                         st.max != LINK_OPERSTATE_RANGE_DEFAULT.max ? ":" : "",
 448                         st.max != LINK_OPERSTATE_RANGE_DEFAULT.max ? strempty(link_operstate_to_string(st.max)) : "");
 449
 450                 fprintf(f, "ACTIVATION_POLICY=%s\n",
 451                         activation_policy_to_string(link->network->activation_policy));
 452
 453                 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
 454
 455                 /************************************************************/
 456
 457                 fputs("DNS=", f);
 458                 space = false;
 459                 if (link->n_dns != UINT_MAX)
 460                         link_save_dns(link, f, link->dns, link->n_dns, &space);
 461                 else
 462                         link_save_dns(link, f, link->network->dns, link->network->n_dns, &space);
 463
 464                 serialize_addresses(f, NULL, &space,
 465                                     NULL,
 466                                     link->dhcp_lease,
 467                                     link->network->dhcp_use_dns,
 468                                     SD_DHCP_LEASE_DNS,
 469                                     link->dhcp6_lease,
 470                                     link->network->dhcp6_use_dns,
 471                                     sd_dhcp6_lease_get_dns,
 472                                     NULL);
 473
 474                 /* Make sure to flush out old entries before we use the NDisc data */
 475                 ndisc_vacuum(link);
 476
 477                 if (link->network->ipv6_accept_ra_use_dns && link->ndisc_rdnss) {
 478                         NDiscRDNSS *dd;
 479
 480                         SET_FOREACH(dd, link->ndisc_rdnss)
 481                                 serialize_in6_addrs(f, &dd->address, 1, &space);
 482                 }
 483
 484                 fputc('\n', f);
 485
 486                 /************************************************************/
 487
 488                 serialize_addresses(f, "NTP", NULL,
 489                                     link->ntp ?: link->network->ntp,
 490                                     link->dhcp_lease,
 491                                     link->network->dhcp_use_ntp,
 492                                     SD_DHCP_LEASE_NTP,
 493                                     link->dhcp6_lease,
 494                                     link->network->dhcp6_use_ntp,
 495                                     sd_dhcp6_lease_get_ntp_addrs,
 496                                     sd_dhcp6_lease_get_ntp_fqdn);
 497
 498                 serialize_addresses(f, "SIP", NULL,
 499                                     NULL,
 500                                     link->dhcp_lease,
 501                                     link->network->dhcp_use_sip,
 502                                     SD_DHCP_LEASE_SIP,
 503                                     NULL, false, NULL, NULL);
 504
 505                 /************************************************************/
 506
 507                 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO && link->dhcp_lease) {
 508                         (void) sd_dhcp_lease_get_domainname(link->dhcp_lease, &dhcp_domainname);
 509                         (void) sd_dhcp_lease_get_search_domains(link->dhcp_lease, &dhcp_domains);
 510                 }
 511                 if (link->network->dhcp6_use_domains != DHCP_USE_DOMAINS_NO && link->dhcp6_lease)
 512                         (void) sd_dhcp6_lease_get_domains(link->dhcp6_lease, &dhcp6_domains);
 513
 514                 fputs("DOMAINS=", f);
 515                 space = false;
 516                 ORDERED_SET_FOREACH(p, link->search_domains ?: link->network->search_domains)
 517                         fputs_with_space(f, p, NULL, &space);
 518
 519                 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES) {
 520                         if (dhcp_domainname)
 521                                 fputs_with_space(f, dhcp_domainname, NULL, &space);
 522                         if (dhcp_domains)
 523                                 fputstrv(f, dhcp_domains, NULL, &space);
 524                         if (dhcp6_domains)
 525                                 fputstrv(f, dhcp6_domains, NULL, &space);
 526                 }
 527
 528                 if (link->network->ipv6_accept_ra_use_domains == DHCP_USE_DOMAINS_YES) {
 529                         NDiscDNSSL *dd;
 530
 531                         SET_FOREACH(dd, link->ndisc_dnssl)
 532                                 fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
 533                 }
 534
 535                 fputc('\n', f);
 536
 537                 /************************************************************/
 538
 539                 fputs("ROUTE_DOMAINS=", f);
 540                 space = false;
 541                 ORDERED_SET_FOREACH(p, link->route_domains ?: link->network->route_domains)
 542                         fputs_with_space(f, p, NULL, &space);
 543
 544                 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_ROUTE) {
 545                         if (dhcp_domainname)
 546                                 fputs_with_space(f, dhcp_domainname, NULL, &space);
 547                         if (dhcp_domains)
 548                                 fputstrv(f, dhcp_domains, NULL, &space);
 549                         if (dhcp6_domains)
 550                                 fputstrv(f, dhcp6_domains, NULL, &space);
 551                 }
 552
 553                 if (link->network->ipv6_accept_ra_use_domains == DHCP_USE_DOMAINS_ROUTE) {
 554                         NDiscDNSSL *dd;
 555
 556                         SET_FOREACH(dd, link->ndisc_dnssl)
 557                                 fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
 558                 }
 559
 560                 fputc('\n', f);
 561
 562                 /************************************************************/
 563
 564                 fprintf(f, "LLMNR=%s\n",
 565                         resolve_support_to_string(link->llmnr >= 0 ? link->llmnr : link->network->llmnr));
 566
 567                 /************************************************************/
 568
 569                 fprintf(f, "MDNS=%s\n",
 570                         resolve_support_to_string(link->mdns >= 0 ? link->mdns : link->network->mdns));
 571
 572                 /************************************************************/
 573
 574                 int dns_default_route =
 575                         link->dns_default_route >= 0 ? link->dns_default_route :
 576                         link->network->dns_default_route;
 577                 if (dns_default_route >= 0)
 578                         fprintf(f, "DNS_DEFAULT_ROUTE=%s\n", yes_no(dns_default_route));
 579
 580                 /************************************************************/
 581
 582                 DnsOverTlsMode dns_over_tls_mode =
 583                         link->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID ? link->dns_over_tls_mode :
 584                         link->network->dns_over_tls_mode;
 585                 if (dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
 586                         fprintf(f, "DNS_OVER_TLS=%s\n", dns_over_tls_mode_to_string(dns_over_tls_mode));
 587
 588                 /************************************************************/
 589
 590                 DnssecMode dnssec_mode =
 591                         link->dnssec_mode != _DNSSEC_MODE_INVALID ? link->dnssec_mode :
 592                         link->network->dnssec_mode;
 593                 if (dnssec_mode != _DNSSEC_MODE_INVALID)
 594                         fprintf(f, "DNSSEC=%s\n", dnssec_mode_to_string(dnssec_mode));
 595
 596                 /************************************************************/
 597
 598                 Set *nta_anchors = link->dnssec_negative_trust_anchors;
 599                 if (set_isempty(nta_anchors))
 600                         nta_anchors = link->network->dnssec_negative_trust_anchors;
 601
 602                 if (!set_isempty(nta_anchors)) {
 603                         const char *n;
 604
 605                         fputs("DNSSEC_NTA=", f);
 606                         space = false;
 607                         SET_FOREACH(n, nta_anchors)
 608                                 fputs_with_space(f, n, NULL, &space);
 609                         fputc('\n', f);
 610                 }
 611         }
 612
 613         print_link_hashmap(f, "CARRIER_BOUND_TO=", link->bound_to_links);
 614         print_link_hashmap(f, "CARRIER_BOUND_BY=", link->bound_by_links);
 615
 616         if (link->dhcp_lease) {
 617                 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
 618                 if (r < 0)
 619                         return r;
 620
 621                 fprintf(f,
 622                         "DHCP_LEASE=%s\n",
 623                         link->lease_file);
 624         } else
 625                 (void) unlink(link->lease_file);
 626
 627         r = link_serialize_dhcp6_client(link, f);
 628         if (r < 0)
 629                 return r;
 630
 631         r = fflush_and_check(f);
 632         if (r < 0)
 633                 return r;
 634
 635         r = conservative_rename(temp_path, link->state_file);
 636         if (r < 0)
 637                 return r;
 638
 639         temp_path = mfree(temp_path);
 640
 641         return 0;
 642 }
 643
 644 void link_dirty(Link *link) {
 645         int r;
 646
 647         assert(link);
 648         assert(link->manager);
 649
 650         /* The serialized state in /run is no longer up-to-date. */
 651
 652         /* Also mark manager dirty as link is dirty */
 653         link->manager->dirty = true;
 654
 655         r = set_ensure_put(&link->manager->dirty_links, NULL, link);
 656         if (r <= 0)
 657                 /* Ignore allocation errors and don't take another ref if the link was already dirty */
 658                 return;
 659         link_ref(link);
 660 }
 661
 662 void link_clean(Link *link) {
 663         assert(link);
 664         assert(link->manager);
 665
 666         /* The serialized state in /run is up-to-date */
 667
 668         link_unref(set_remove(link->manager->dirty_links, link));
 669 }
 670
 671 int link_save_and_clean(Link *link) {
 672         int r;
 673
 674         r = link_save(link);
 675         if (r < 0)
 676                 return r;
 677
 678         link_clean(link);
 679         return 0;
 680 }