X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fresolve%2Fresolved-manager.c;h=2edfb9f7fdee20b50f071e94d9bc19d85e7f53cb;hp=1e86c1003b84c6cb2e547e7ce3656dfdc5f9e2fc;hb=36a03ca2a8952ca1acb29fbe796210c27ff71aff;hpb=39d8db043b599a7382f94bfc904d5e108af438bd diff --git a/src/resolve/resolved-manager.c b/src/resolve/resolved-manager.c index 1e86c1003..2edfb9f7f 100644 --- a/src/resolve/resolved-manager.c +++ b/src/resolve/resolved-manager.c @@ -34,6 +34,7 @@ #include "socket-util.h" #include "af-list.h" #include "utf8.h" +#include "fileio-label.h" #include "resolved-dns-domain.h" #include "resolved-conf.h" @@ -77,6 +78,10 @@ static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userda if (r < 0) goto fail; + r = link_update_monitor(l); + if (r < 0) + goto fail; + if (is_new) log_debug("Found new link %i/%s", ifindex, l->name); @@ -95,7 +100,7 @@ static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userda return 0; fail: - log_warning("Failed to process RTNL link message: %s", strerror(-r)); + log_warning_errno(r, "Failed to process RTNL link message: %m"); return 0; } @@ -180,11 +185,10 @@ static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *use return 0; fail: - log_warning("Failed to process RTNL address message: %s", strerror(-r)); + log_warning_errno(r, "Failed to process RTNL address message: %m"); return 0; } - static int manager_rtnl_listen(Manager *m) { _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL; sd_rtnl_message *i; @@ -274,12 +278,12 @@ static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void * HASHMAP_FOREACH(l, m->links, i) { r = link_update_monitor(l); if (r < 0) - log_warning("Failed to update monitor information for %i: %s", l->ifindex, strerror(-r)); + log_warning_errno(r, "Failed to update monitor information for %i: %m", l->ifindex); } r = manager_write_resolv_conf(m); if (r < 0) - log_warning("Could not update resolv.conf: %s", strerror(-r)); + log_warning_errno(r, "Could not update resolv.conf: %m"); return 0; } @@ -360,14 +364,13 @@ static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, voi } static int manager_watch_hostname(Manager *m) { - _cleanup_free_ char *h = NULL; int r; assert(m); m->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NDELAY|O_NOCTTY); if (m->hostname_fd < 0) { - log_warning("Failed to watch hostname: %m"); + log_warning_errno(errno, "Failed to watch hostname: %m"); return 0; } @@ -376,10 +379,8 @@ static int manager_watch_hostname(Manager *m) { if (r == -EPERM) /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */ m->hostname_fd = safe_close(m->hostname_fd); - else { - log_error("Failed to add hostname event source: %s", strerror(-r)); - return r; - } + else + return log_error_errno(r, "Failed to add hostname event source: %m"); } r = determine_hostname(&m->hostname); @@ -394,6 +395,66 @@ static int manager_watch_hostname(Manager *m) { return 0; } +static void manager_llmnr_stop(Manager *m) { + assert(m); + + m->llmnr_ipv4_udp_event_source = sd_event_source_unref(m->llmnr_ipv4_udp_event_source); + m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd); + + m->llmnr_ipv6_udp_event_source = sd_event_source_unref(m->llmnr_ipv6_udp_event_source); + m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd); + + m->llmnr_ipv4_tcp_event_source = sd_event_source_unref(m->llmnr_ipv4_tcp_event_source); + m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd); + + m->llmnr_ipv6_tcp_event_source = sd_event_source_unref(m->llmnr_ipv6_tcp_event_source); + m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd); +} + +static int manager_llmnr_start(Manager *m) { + int r; + + assert(m); + + if (m->llmnr_support == SUPPORT_NO) + return 0; + + r = manager_llmnr_ipv4_udp_fd(m); + if (r == -EADDRINUSE) + goto eaddrinuse; + if (r < 0) + return r; + + r = manager_llmnr_ipv4_tcp_fd(m); + if (r == -EADDRINUSE) + goto eaddrinuse; + if (r < 0) + return r; + + if (socket_ipv6_is_supported()) { + r = manager_llmnr_ipv6_udp_fd(m); + if (r == -EADDRINUSE) + goto eaddrinuse; + if (r < 0) + return r; + + r = manager_llmnr_ipv6_tcp_fd(m); + if (r == -EADDRINUSE) + goto eaddrinuse; + if (r < 0) + return r; + } + + return 0; + +eaddrinuse: + log_warning("There appears to be another LLMNR responder running. Turning off LLMNR support."); + m->llmnr_support = SUPPORT_NO; + manager_llmnr_stop(m); + + return 0; +} + int manager_new(Manager **ret) { _cleanup_(manager_freep) Manager *m = NULL; int r; @@ -410,6 +471,7 @@ int manager_new(Manager **ret) { m->hostname_fd = -1; m->llmnr_support = SUPPORT_YES; + m->read_resolv_conf = true; r = manager_parse_dns_server(m, DNS_SERVER_FALLBACK, DNS_SERVERS); if (r < 0) @@ -444,46 +506,43 @@ int manager_new(Manager **ret) { if (r < 0) return r; - r = manager_llmnr_ipv4_udp_fd(m); - if (r < 0) - return r; - r = manager_llmnr_ipv6_udp_fd(m); - if (r < 0) - return r; - r = manager_llmnr_ipv4_tcp_fd(m); - if (r < 0) - return r; - r = manager_llmnr_ipv6_tcp_fd(m); - if (r < 0) - return r; - *ret = m; m = NULL; return 0; } +int manager_start(Manager *m) { + int r; + + assert(m); + + r = manager_llmnr_start(m); + if (r < 0) + return r; + + return 0; +} + Manager *manager_free(Manager *m) { Link *l; if (!m) return NULL; - while (m->dns_queries) - dns_query_free(m->dns_queries); - - hashmap_free(m->dns_transactions); - while ((l = hashmap_first(m->links))) link_free(l); - hashmap_free(m->links); + + while (m->dns_queries) + dns_query_free(m->dns_queries); dns_scope_free(m->unicast_scope); - while (m->dns_servers) - dns_server_free(m->dns_servers); - while (m->fallback_dns_servers) - dns_server_free(m->fallback_dns_servers); + manager_flush_dns_servers(m, DNS_SERVER_SYSTEM); + manager_flush_dns_servers(m, DNS_SERVER_FALLBACK); + + hashmap_free(m->links); + hashmap_free(m->dns_transactions); sd_event_source_unref(m->network_event_source); sd_network_monitor_unref(m->network_monitor); @@ -493,16 +552,9 @@ Manager *manager_free(Manager *m) { safe_close(m->dns_ipv4_fd); safe_close(m->dns_ipv6_fd); - sd_event_source_unref(m->llmnr_ipv4_udp_event_source); - sd_event_source_unref(m->llmnr_ipv6_udp_event_source); - safe_close(m->llmnr_ipv4_udp_fd); - safe_close(m->llmnr_ipv6_udp_fd); - - sd_event_source_unref(m->llmnr_ipv4_tcp_event_source); - sd_event_source_unref(m->llmnr_ipv6_tcp_event_source); - safe_close(m->llmnr_ipv4_tcp_fd); - safe_close(m->llmnr_ipv6_tcp_fd); + manager_llmnr_stop(m); + sd_bus_slot_unref(m->prepare_for_sleep_slot); sd_event_source_unref(m->bus_retry_event_source); sd_bus_unref(m->bus); @@ -520,7 +572,121 @@ Manager *manager_free(Manager *m) { return NULL; } -static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) { +int manager_read_resolv_conf(Manager *m) { + _cleanup_fclose_ FILE *f = NULL; + struct stat st, own; + char line[LINE_MAX]; + DnsServer *s, *nx; + usec_t t; + int r; + + assert(m); + + /* Reads the system /etc/resolv.conf, if it exists and is not + * symlinked to our own resolv.conf instance */ + + if (!m->read_resolv_conf) + return 0; + + r = stat("/etc/resolv.conf", &st); + if (r < 0) { + if (errno != ENOENT) + log_warning_errno(errno, "Failed to open /etc/resolv.conf: %m"); + r = -errno; + goto clear; + } + + /* Have we already seen the file? */ + t = timespec_load(&st.st_mtim); + if (t == m->resolv_conf_mtime) + return 0; + + m->resolv_conf_mtime = t; + + /* Is it symlinked to our own file? */ + if (stat("/run/systemd/resolve/resolv.conf", &own) >= 0 && + st.st_dev == own.st_dev && + st.st_ino == own.st_ino) { + r = 0; + goto clear; + } + + f = fopen("/etc/resolv.conf", "re"); + if (!f) { + if (errno != ENOENT) + log_warning_errno(errno, "Failed to open /etc/resolv.conf: %m"); + r = -errno; + goto clear; + } + + if (fstat(fileno(f), &st) < 0) { + log_error_errno(errno, "Failed to stat open file: %m"); + r = -errno; + goto clear; + } + + LIST_FOREACH(servers, s, m->dns_servers) + s->marked = true; + + FOREACH_LINE(line, f, r = -errno; goto clear) { + union in_addr_union address; + int family; + char *l; + const char *a; + + truncate_nl(line); + + l = strstrip(line); + if (*l == '#' || *l == ';') + continue; + + a = first_word(l, "nameserver"); + if (!a) + continue; + + r = in_addr_from_string_auto(a, &family, &address); + if (r < 0) { + log_warning("Failed to parse name server %s.", a); + continue; + } + + LIST_FOREACH(servers, s, m->dns_servers) + if (s->family == family && in_addr_equal(family, &s->address, &address) > 0) + break; + + if (s) + s->marked = false; + else { + r = dns_server_new(m, NULL, DNS_SERVER_SYSTEM, NULL, family, &address); + if (r < 0) + goto clear; + } + } + + LIST_FOREACH_SAFE(servers, s, nx, m->dns_servers) + if (s->marked) + dns_server_free(s); + + /* Whenever /etc/resolv.conf changes, start using the first + * DNS server of it. This is useful to deal with broken + * network managing implementations (like NetworkManager), + * that when connecting to a VPN place both the VPN DNS + * servers and the local ones in /etc/resolv.conf. Without + * resetting the DNS server to use back to the first entry we + * will continue to use the local one thus being unable to + * resolve VPN domains. */ + manager_set_dns_server(m, m->dns_servers); + + return 0; + +clear: + while (m->dns_servers) + dns_server_free(m->dns_servers); + + return r; +} + +static void write_resolv_conf_server(DnsServer *s, FILE *f, unsigned *count) { _cleanup_free_ char *t = NULL; int r; @@ -530,22 +696,77 @@ static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) { r = in_addr_to_string(s->family, &s->address, &t); if (r < 0) { - log_warning("Invalid DNS address. Ignoring: %s", strerror(-r)); + log_warning_errno(r, "Invalid DNS address. Ignoring: %m"); return; } if (*count == MAXNS) - fputs("# Too many DNS servers configured, the following entries may be ignored\n", f); + fputs("# Too many DNS servers configured, the following entries may be ignored.\n", f); fprintf(f, "nameserver %s\n", t); (*count) ++; } +static void write_resolv_conf_search(const char *domain, FILE *f, + unsigned *count, unsigned *length) { + assert(domain); + assert(f); + assert(length); + + if (*count >= MAXDNSRCH || + *length + strlen(domain) > 256) { + if (*count == MAXDNSRCH) + fputs(" # Too many search domains configured, remaining ones ignored.", f); + if (*length <= 256) + fputs(" # Total length of all search domains is too long, remaining ones ignored.", f); + + return; + } + + fprintf(f, " %s", domain); + + (*length) += strlen(domain); + (*count) ++; +} + +static int write_resolv_conf_contents(FILE *f, Set *dns, Set *domains) { + Iterator i; + + fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n" + "# Third party programs must not access this file directly, but\n" + "# only through the symlink at /etc/resolv.conf. To manage\n" + "# resolv.conf(5) in a different way, replace the symlink by a\n" + "# static file or a different symlink.\n\n", f); + + if (set_isempty(dns)) + fputs("# No DNS servers known.\n", f); + else { + DnsServer *s; + unsigned count = 0; + + SET_FOREACH(s, dns, i) + write_resolv_conf_server(s, f, &count); + } + + if (!set_isempty(domains)) { + unsigned length = 0, count = 0; + char *domain; + + fputs("search", f); + SET_FOREACH(domain, domains, i) + write_resolv_conf_search(domain, f, &count, &length); + fputs("\n", f); + } + + return fflush_and_check(f); +} + + int manager_write_resolv_conf(Manager *m) { static const char path[] = "/run/systemd/resolve/resolv.conf"; _cleanup_free_ char *temp_path = NULL; _cleanup_fclose_ FILE *f = NULL; - unsigned count = 0; + _cleanup_set_free_ Set *dns = NULL, *domains = NULL; DnsServer *s; Iterator i; Link *l; @@ -553,31 +774,69 @@ int manager_write_resolv_conf(Manager *m) { assert(m); - r = fopen_temporary(path, &f, &temp_path); - if (r < 0) - return r; + /* Read the system /etc/resolv.conf first */ + manager_read_resolv_conf(m); - fchmod(fileno(f), 0644); + /* Add the full list to a set, to filter out duplicates */ + dns = set_new(&dns_server_hash_ops); + if (!dns) + return -ENOMEM; - fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n" - "# Third party programs must not access this file directly, but\n" - "# only through the symlink at /etc/resolv.conf. To manage\n" - "# resolv.conf(5) in a different way, replace the symlink by a\n" - "# static file or a different symlink.\n\n", f); + domains = set_new(&dns_name_hash_ops); + if (!domains) + return -ENOMEM; - LIST_FOREACH(servers, s, m->dns_servers) - write_resolve_conf_server(s, f, &count); + /* First add the system-wide servers */ + LIST_FOREACH(servers, s, m->dns_servers) { + r = set_put(dns, s); + if (r == -EEXIST) + continue; + if (r < 0) + return r; + } + + /* Then, add the per-link servers and domains */ + HASHMAP_FOREACH(l, m->links, i) { + char **domain; + + LIST_FOREACH(servers, s, l->dns_servers) { + r = set_put(dns, s); + if (r == -EEXIST) + continue; + if (r < 0) + return r; + } + + if (!l->unicast_scope) + continue; - HASHMAP_FOREACH(l, m->links, i) - LIST_FOREACH(servers, s, l->dns_servers) - write_resolve_conf_server(s, f, &count); + STRV_FOREACH(domain, l->unicast_scope->domains) { + r = set_put(domains, *domain); + if (r == -EEXIST) + continue; + if (r < 0) + return r; + } + } - if (count == 0) { - LIST_FOREACH(servers, s, m->fallback_dns_servers) - write_resolve_conf_server(s, f, &count); + /* If we found nothing, add the fallback servers */ + if (set_isempty(dns)) { + LIST_FOREACH(servers, s, m->fallback_dns_servers) { + r = set_put(dns, s); + if (r == -EEXIST) + continue; + if (r < 0) + return r; + } } - r = fflush_and_check(f); + r = fopen_temporary_label(path, path, &f, &temp_path); + if (r < 0) + return r; + + fchmod(fileno(f), 0644); + + r = write_resolv_conf_contents(f, dns, domains); if (r < 0) goto fail; @@ -598,7 +857,7 @@ int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) { _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL; union { struct cmsghdr header; /* For alignment */ - uint8_t buffer[CMSG_SPACE(MAX(sizeof(struct in_pktinfo), sizeof(struct in6_pktinfo))) + uint8_t buffer[CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo)) + CMSG_SPACE(int) /* ttl/hoplimit */ + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */]; } control; @@ -709,7 +968,7 @@ int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) { * device if the packet came from the local host since it * avoids the routing table in such a case. Let's unset the * interface index in such a case. */ - if (p->ifindex > 0 && manager_ifindex_is_loopback(m, p->ifindex) != 0) + if (p->ifindex == LOOPBACK_IFINDEX) p->ifindex = 0; /* If we don't know the interface index still, we look for the @@ -946,24 +1205,24 @@ int manager_send(Manager *m, int fd, int ifindex, int family, const union in_add return -EAFNOSUPPORT; } -bool manager_known_dns_server(Manager *m, int family, const union in_addr_union *in_addr) { +DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) { DnsServer *s; assert(m); assert(in_addr); LIST_FOREACH(servers, s, m->dns_servers) - if (s->family == family && in_addr_equal(family, &s->address, in_addr)) - return true; + if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0) + return s; LIST_FOREACH(servers, s, m->fallback_dns_servers) - if (s->family == family && in_addr_equal(family, &s->address, in_addr)) - return true; + if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0) + return s; - return false; + return NULL; } -static DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) { +DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) { assert(m); if (m->current_dns_server == s) @@ -974,10 +1233,13 @@ static DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) { in_addr_to_string(s->family, &s->address, &ip); log_info("Switching to system DNS server %s.", strna(ip)); - } else - log_info("No system DNS server set."); + } m->current_dns_server = s; + + if (m->unicast_scope) + dns_cache_flush(&m->unicast_scope->cache); + return s; } @@ -985,6 +1247,9 @@ DnsServer *manager_get_dns_server(Manager *m) { Link *l; assert(m); + /* Try to read updates resolv.conf */ + manager_read_resolv_conf(m); + if (!m->current_dns_server) manager_set_dns_server(m, m->dns_servers); @@ -1055,38 +1320,34 @@ static int on_llmnr_packet(sd_event_source *s, int fd, uint32_t revents, void *u _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL; DnsTransaction *t = NULL; Manager *m = userdata; + DnsScope *scope; int r; r = manager_recv(m, fd, DNS_PROTOCOL_LLMNR, &p); if (r <= 0) return r; + scope = manager_find_scope(m, p); + if (!scope) { + log_warning("Got LLMNR UDP packet on unknown scope. Ignoring."); + return 0; + } + if (dns_packet_validate_reply(p) > 0) { log_debug("Got reply packet for id %u", DNS_PACKET_ID(p)); - t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p))); - if (!t) - return 0; - - dns_transaction_process_reply(t, p); - - } else if (dns_packet_validate_query(p) > 0) { - Link *l; + dns_scope_check_conflicts(scope, p); - l = hashmap_get(m->links, INT_TO_PTR(p->ifindex)); - if (l) { - DnsScope *scope = NULL; + t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p))); + if (t) + dns_transaction_process_reply(t, p); - if (p->family == AF_INET) - scope = l->llmnr_ipv4_scope; - else if (p->family == AF_INET6) - scope = l->llmnr_ipv6_scope; + } else if (dns_packet_validate_query(p) > 0) { + log_debug("Got query packet for id %u", DNS_PACKET_ID(p)); - if (scope) - dns_scope_process_query(scope, NULL, p); - } + dns_scope_process_query(scope, NULL, p); } else - log_debug("Invalid LLMNR packet."); + log_debug("Invalid LLMNR UDP packet."); return 0; } @@ -1249,29 +1510,26 @@ fail: } static int on_llmnr_stream_packet(DnsStream *s) { - assert(s); + DnsScope *scope; - if (dns_packet_validate_query(s->read_packet) > 0) { - Link *l; + assert(s); - l = hashmap_get(s->manager->links, INT_TO_PTR(s->read_packet->ifindex)); - if (l) { - DnsScope *scope = NULL; + scope = manager_find_scope(s->manager, s->read_packet); + if (!scope) { + log_warning("Got LLMNR TCP packet on unknown scope. Ignroing."); + return 0; + } - if (s->read_packet->family == AF_INET) - scope = l->llmnr_ipv4_scope; - else if (s->read_packet->family == AF_INET6) - scope = l->llmnr_ipv6_scope; + if (dns_packet_validate_query(s->read_packet) > 0) { + log_debug("Got query packet for id %u", DNS_PACKET_ID(s->read_packet)); - if (scope) { - dns_scope_process_query(scope, s, s->read_packet); + dns_scope_process_query(scope, s, s->read_packet); - /* If no reply packet was set, we free the stream */ - if (s->write_packet) - return 0; - } - } - } + /* If no reply packet was set, we free the stream */ + if (s->write_packet) + return 0; + } else + log_debug("Invalid LLMNR TCP packet."); dns_stream_free(s); return 0; @@ -1445,20 +1703,6 @@ fail: return r; } -int manager_ifindex_is_loopback(Manager *m, int ifindex) { - Link *l; - assert(m); - - if (ifindex <= 0) - return -EINVAL; - - l = hashmap_get(m->links, INT_TO_PTR(ifindex)); - if (l->flags & IFF_LOOPBACK) - return 1; - - return 0; -} - int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) { LinkAddress *a; @@ -1488,7 +1732,7 @@ void manager_refresh_rrs(Manager *m) { int manager_next_hostname(Manager *m) { const char *p; - uint64_t u; + uint64_t u, a; char *h; assert(m); @@ -1506,7 +1750,15 @@ int manager_next_hostname(Manager *m) { if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0) u = 1; - u++; + /* Add a random number to the old value. This way we can avoid + * that two hosts pick the same hostname, win on IPv4 and lose + * on IPv6 (or vice versa), and pick the same hostname + * replacement hostname, ad infinitum. We still want the + * numbers to go up monotonically, hence we just add a random + * value 1..10 */ + + random_bytes(&a, sizeof(a)); + u += 1 + a % 10; if (asprintf(&h, "%.*s%" PRIu64, (int) (p - m->hostname), m->hostname, u) < 0) return -ENOMEM; @@ -1538,13 +1790,54 @@ LinkAddress* manager_find_link_address(Manager *m, int family, const union in_ad return NULL; } -int manager_our_packet(Manager *m, DnsPacket *p) { +bool manager_our_packet(Manager *m, DnsPacket *p) { assert(m); assert(p); return !!manager_find_link_address(m, p->family, &p->sender); } +DnsScope* manager_find_scope(Manager *m, DnsPacket *p) { + Link *l; + + assert(m); + assert(p); + + l = hashmap_get(m->links, INT_TO_PTR(p->ifindex)); + if (!l) + return NULL; + + if (p->protocol == DNS_PROTOCOL_LLMNR) { + if (p->family == AF_INET) + return l->llmnr_ipv4_scope; + else if (p->family == AF_INET6) + return l->llmnr_ipv6_scope; + } + + return NULL; +} + +void manager_verify_all(Manager *m) { + DnsScope *s; + + assert(m); + + LIST_FOREACH(scopes, s, m->dns_scopes) + dns_zone_verify_all(&s->zone); +} + +void manager_flush_dns_servers(Manager *m, DnsServerType t) { + assert(m); + + if (t == DNS_SERVER_SYSTEM) + while (m->dns_servers) + dns_server_free(m->dns_servers); + + if (t == DNS_SERVER_FALLBACK) + while (m->fallback_dns_servers) + dns_server_free(m->fallback_dns_servers); +} + static const char* const support_table[_SUPPORT_MAX] = { [SUPPORT_NO] = "no", [SUPPORT_YES] = "yes",