HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/resolved-bus.c

87,973 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 650259a8c0d21bec8049f497838f5a0141586a8e

Lines 1001–2000 of 2,422

                if (r < 0)
                        return r;
        }
 
        return 1;
}
 
static void resolve_service_all_complete(DnsQuery *query) {
        _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *canonical = NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_free_ char *name = NULL, *type = NULL, *domain = NULL;
        _cleanup_(dns_query_freep) DnsQuery *q = query;
        DnsQuestion *question;
        DnsResourceRecord *rr;
        unsigned added = 0;
        int r;
 
        assert(q);
 
        if (q->hook_query || q->block_all_complete > 0) {
                TAKE_PTR(q);
                return;
        }
 
        if ((q->flags & SD_RESOLVED_NO_ADDRESS) == 0) {
                DnsQuery *bad = NULL;
                bool have_success = false;
 
                LIST_FOREACH(auxiliary_queries, aux, q->auxiliary_queries) {
 
                        if (aux->hook_query) {
                                /* If an auxiliary query's hook is still pending, let's wait */
                                TAKE_PTR(q);
                                return;
                        }
 
                        switch (aux->state) {
 
                        case DNS_TRANSACTION_PENDING:
                                /* If an auxiliary query is still pending, let's wait */
                                TAKE_PTR(q);
                                return;
 
                        case DNS_TRANSACTION_SUCCESS:
                                if (aux->auxiliary_result == 0)
                                        have_success = true;
                                else
                                        bad = aux;
                                break;
 
                        default:
                                bad = aux;
                        }
                }
 
                if (!have_success) {
                        /* We can only return one error, hence pick the last error we encountered */
 
                        assert(bad);
 
                        if (bad->state == DNS_TRANSACTION_SUCCESS) {
                                assert(bad->auxiliary_result != 0);
 
                                if (bad->auxiliary_result == -ELOOP) {
                                        r = reply_method_errorf(q, BUS_ERROR_CNAME_LOOP, "CNAME loop detected, or CNAME resolving disabled on '%s'", dns_query_string(bad));
                                        goto finish;
                                }
 
                                assert(bad->auxiliary_result < 0);
                                r = bad->auxiliary_result;
                                goto finish;
                        }
 
                        r = reply_query_state(bad);
                        goto finish;
                }
        }
 
        r = sd_bus_message_new_method_return(q->bus_request, &reply);
        if (r < 0)
                goto finish;
 
        r = sd_bus_message_open_container(reply, 'a', "(qqqsa(iiay)s)");
        if (r < 0)
                goto finish;
 
        question = dns_query_question_for_protocol(q, q->answer_protocol);
 
        DNS_ANSWER_FOREACH(rr, q->answer) {
                r = dns_question_matches_rr(question, rr, NULL);
                if (r < 0)
                        goto finish;
                if (r == 0)
                        continue;
 
                r = append_srv(q, reply, rr);
                if (r < 0)
                        goto finish;
                if (r == 0) /* not an SRV record */
                        continue;
 
                if (!canonical)
                        canonical = dns_resource_record_ref(rr);
 
                added++;
        }
 
        if (added <= 0) {
                r = reply_method_errorf(q, BUS_ERROR_NO_SUCH_RR, "'%s' does not have any RR of the requested type", dns_query_string(q));
                goto finish;
        }
 
        r = sd_bus_message_close_container(reply);
        if (r < 0)
                goto finish;
 
        r = sd_bus_message_open_container(reply, 'a', "ay");
        if (r < 0)
                goto finish;
 
        DNS_ANSWER_FOREACH(rr, q->answer) {
                r = dns_question_matches_rr(question, rr, NULL);
                if (r < 0)
                        goto finish;
                if (r == 0)
                        continue;
 
                r = append_txt(reply, rr);
                if (r < 0)
                        goto finish;
        }
 
        r = sd_bus_message_close_container(reply);
        if (r < 0)
                goto finish;
 
        assert(canonical);
        r = dns_service_split(dns_resource_key_name(canonical->key), &name, &type, &domain);
        if (r < 0)
                goto finish;
 
        if (isempty(type)) {
                r = reply_method_errorf(q, BUS_ERROR_INCONSISTENT_SERVICE_RECORDS, "'%s' does not provide a consistent set of service resource records", dns_query_string(q));
                goto finish;
        }
 
        r = sd_bus_message_append(
                        reply,
                        "ssst",
                        name, type, domain,
                        dns_query_reply_flags_make(q));
        if (r < 0)
                goto finish;
 
        q->bus_request = sd_bus_message_unref(q->bus_request);
        r = sd_bus_send(q->manager->bus, reply, NULL);
 
finish:
        if (r < 0) {
                log_error_errno(r, "Failed to send service reply: %m");
                (void) reply_method_errnof(q, r, NULL);
        }
}
 
static void resolve_service_hostname_complete(DnsQuery *q) {
        int r;
 
        assert(q);
        assert(q->auxiliary_for);
 
        if (q->state != DNS_TRANSACTION_SUCCESS) {
                resolve_service_all_complete(q->auxiliary_for);
                return;
        }
 
        r = dns_query_process_cname_many(q);
        if (r == DNS_QUERY_CNAME) /* This was a cname, and the query was restarted. */
                return;
 
        /* This auxiliary lookup is finished or failed, let's see if all are finished now. */
        q->auxiliary_result = r < 0 ? r : 0;
        resolve_service_all_complete(q->auxiliary_for);
}
 
static int resolve_service_hostname(DnsQuery *q, DnsResourceRecord *rr, int ifindex) {
        _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
        _cleanup_(dns_query_freep) DnsQuery *aux = NULL;
        int r;
 
        assert(q);
        assert(rr);
        assert(rr->key);
        assert(rr->key->type == DNS_TYPE_SRV);
 
        /* OK, we found an SRV record for the service. Let's resolve
         * the hostname included in it */
 
        r = dns_question_new_address(&question, q->request_family, rr->srv.name, false);
        if (r < 0)
                return r;
 
        r = dns_query_new(q->manager, &aux, question, question, NULL, ifindex, q->flags|SD_RESOLVED_NO_SEARCH);
        if (r == -ENOANO)
                return reply_method_errorf(q, BUS_ERROR_DNS_REFUSED, "DNS query type refused.");
        if (r < 0)
                return r;
 
        aux->request_family = q->request_family;
        aux->complete = resolve_service_hostname_complete;
 
        r = dns_query_make_auxiliary(aux, q);
        if (r == -EAGAIN)
                /* Too many auxiliary lookups? If so, don't complain,
                 * let's just not add this one, we already have more
                 * than enough */
                return 0;
        if (r < 0)
                return r;
 
        /* Note that auxiliary queries do not track the original bus
         * client, only the primary request does that. */
 
        r = dns_query_go(aux);
        if (r < 0)
                return r;
 
        TAKE_PTR(aux);
        return 1;
}
 
static void bus_method_resolve_service_complete(DnsQuery *query) {
        _cleanup_(dns_query_freep) DnsQuery *q = query;
        bool has_root_domain = false;
        DnsResourceRecord *rr;
        DnsQuestion *question;
        unsigned found = 0;
        int ifindex, r;
 
        assert(q);
 
        if (q->state != DNS_TRANSACTION_SUCCESS) {
                r = reply_query_state(q);
                goto finish;
        }
 
        r = dns_query_process_cname_many(q);
        if (r == -ELOOP) {
                r = reply_method_errorf(q, BUS_ERROR_CNAME_LOOP, "CNAME loop detected, or CNAME resolving disabled on '%s'", dns_query_string(q));
                goto finish;
        }
        if (r < 0)
                goto finish;
        if (r == DNS_QUERY_CNAME) {
                /* This was a cname, and the query was restarted. */
                TAKE_PTR(q);
                return;
        }
 
        question = dns_query_question_for_protocol(q, q->answer_protocol);
 
        DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
                r = dns_question_matches_rr(question, rr, NULL);
                if (r < 0)
                        goto finish;
                if (r == 0)
                        continue;
 
                if (rr->key->type != DNS_TYPE_SRV)
                        continue;
 
                if (dns_name_is_root(rr->srv.name)) {
                        has_root_domain = true;
                        continue;
                }
 
                if ((q->flags & SD_RESOLVED_NO_ADDRESS) == 0) {
                        q->block_all_complete++;
                        r = resolve_service_hostname(q, rr, ifindex);
                        q->block_all_complete--;
 
                        if (r < 0)
                                goto finish;
                }
 
                found++;
        }
 
        if (has_root_domain && found <= 0) {
                /* If there's exactly one SRV RR and it uses the root domain as hostname, then the service is
                 * explicitly not offered on the domain. Report this as a recognizable error. See RFC 2782,
                 * Section "Usage Rules". */
                r = reply_method_errorf(q, BUS_ERROR_NO_SUCH_SERVICE, "'%s' does not provide the requested service", dns_query_string(q));
                goto finish;
        }
 
        if (found <= 0) {
                r = reply_method_errorf(q, BUS_ERROR_NO_SUCH_RR, "'%s' does not have any RR of the requested type", dns_query_string(q));
                goto finish;
        }
 
        /* Maybe we are already finished? check now... */
        resolve_service_all_complete(TAKE_PTR(q));
        return;
 
finish:
        if (r < 0) {
                log_error_errno(r, "Failed to send service reply: %m");
                (void) reply_method_errnof(q, r, NULL);
        }
}
 
static int bus_method_resolve_service(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_(dns_question_unrefp) DnsQuestion *question_idna = NULL, *question_utf8 = NULL;
        _cleanup_(dns_query_freep) DnsQuery *q = NULL;
        const char *name, *type, *domain;
        Manager *m = ASSERT_PTR(userdata);
        int family, ifindex;
        uint64_t flags;
        int r;
 
        assert(message);
 
        assert_cc(sizeof(int) == sizeof(int32_t));
 
        r = sd_bus_message_read(message, "isssit", &ifindex, &name, &type, &domain, &family, &flags);
        if (r < 0)
                return r;
 
        if (ifindex < 0)
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");
 
        if (!IN_SET(family, AF_INET, AF_INET6, AF_UNSPEC))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
 
        if (isempty(name))
                name = NULL;
        else if (!dns_service_name_is_valid(name))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid service name '%s'", name);
 
        if (isempty(type))
                type = NULL;
        else if (!dns_srv_type_is_valid(type))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid SRV service type '%s'", type);
 
        r = dns_name_is_valid(domain);
        if (r < 0)
                return r;
        if (r == 0)
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid domain '%s'", domain);
 
        if (name && !type)
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Service name cannot be specified without service type.");
 
        if (validate_and_mangle_query_flags(m, &flags, name, SD_RESOLVED_NO_TXT|SD_RESOLVED_NO_ADDRESS) < 0)
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid flags parameter");
 
        /* Refuse the method if SRV is filtered. */
        if (set_contains(m->refuse_record_types, INT_TO_PTR(DNS_TYPE_SRV)))
                return sd_bus_error_set(error, BUS_ERROR_DNS_REFUSED, "DNS query type refused.");
 
        r = dns_question_new_service(&question_utf8, name, type, domain, !(flags & SD_RESOLVED_NO_TXT), false);
        if (r < 0)
                return r;
 
        r = dns_question_new_service(&question_idna, name, type, domain, !(flags & SD_RESOLVED_NO_TXT), true);
        if (r < 0)
                return r;
 
        bus_client_log(message, "service resolution");
 
        r = dns_query_new_for_bus(m, &q, question_utf8, question_idna, NULL, ifindex, flags|SD_RESOLVED_NO_SEARCH, error);
        if (r < 0)
                return r;
 
        q->bus_request = sd_bus_message_ref(message);
        q->request_family = family;
        q->complete = bus_method_resolve_service_complete;
 
        r = dns_query_bus_track(q, message);
        if (r < 0)
                return r;
 
        r = dns_query_go(q);
        if (r < 0)
                return r;
 
        TAKE_PTR(q);
        return 1;
}
 
int bus_dns_server_append(
                sd_bus_message *reply,
                DnsServer *s,
                bool with_ifindex, /* include "ifindex" field */
                bool extended) {   /* also include port number and server name */
        int r;
 
        assert(reply);
 
        if (!s) {
                if (with_ifindex) {
                        if (extended)
                                return sd_bus_message_append(reply, "(iiayqs)", 0, AF_UNSPEC, 0, 0, NULL);
                        else
                                return sd_bus_message_append(reply, "(iiay)", 0, AF_UNSPEC, 0);
                } else {
                        if (extended)
                                return sd_bus_message_append(reply, "(iayqs)", AF_UNSPEC, 0, 0, NULL);
                        else
                                return sd_bus_message_append(reply, "(iay)", AF_UNSPEC, 0);
                }
        }
 
        r = sd_bus_message_open_container(
                        reply,
                        'r',
                        with_ifindex ? (extended ? "iiayqs" : "iiay") :
                                       (extended ? "iayqs" : "iay"));
        if (r < 0)
                return r;
 
        if (with_ifindex) {
                r = sd_bus_message_append(reply, "i", dns_server_ifindex(s));
                if (r < 0)
                        return r;
        }
 
        r = sd_bus_message_append(reply, "i", s->family);
        if (r < 0)
                return r;
 
        r = sd_bus_message_append_array(reply, 'y', &s->address, FAMILY_ADDRESS_SIZE(s->family));
        if (r < 0)
                return r;
 
        if (extended) {
                r = sd_bus_message_append(reply, "q", s->port);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_append(reply, "s", s->server_name);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int bus_property_get_dns_servers_internal(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error,
                bool extended) {
 
        Manager *m = ASSERT_PTR(userdata);
        Link *l;
        int r;
 
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', extended ? "(iiayqs)" : "(iiay)");
        if (r < 0)
                return r;
 
        LIST_FOREACH(servers, s, m->dns_servers) {
                r = bus_dns_server_append(reply, s, true, extended);
                if (r < 0)
                        return r;
        }
 
        HASHMAP_FOREACH(l, m->links)
                LIST_FOREACH(servers, s, l->dns_servers) {
                        r = bus_dns_server_append(reply, s, true, extended);
                        if (r < 0)
                                return r;
                }
 
        return sd_bus_message_close_container(reply);
}
 
static int bus_property_get_dns_servers(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
        return bus_property_get_dns_servers_internal(bus, path, interface, property, reply, userdata, error, false);
}
 
static int bus_property_get_dns_servers_ex(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
        return bus_property_get_dns_servers_internal(bus, path, interface, property, reply, userdata, error, true);
}
 
static int bus_property_get_fallback_dns_servers_internal(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error,
                bool extended) {
 
        DnsServer **f = ASSERT_PTR(userdata);
        int r;
 
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', extended ? "(iiayqs)" : "(iiay)");
        if (r < 0)
                return r;
 
        LIST_FOREACH(servers, s, *f) {
                r = bus_dns_server_append(reply, s, true, extended);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int bus_property_get_fallback_dns_servers(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
        return bus_property_get_fallback_dns_servers_internal(bus, path, interface, property, reply, userdata, error, false);
}
 
static int bus_property_get_fallback_dns_servers_ex(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
        return bus_property_get_fallback_dns_servers_internal(bus, path, interface, property, reply, userdata, error, true);
}
 
static int bus_property_get_current_dns_server_internal(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error,
                bool extended) {
 
        DnsServer *s;
 
        assert(reply);
        assert(userdata);
 
        s = *(DnsServer **) userdata;
 
        return bus_dns_server_append(reply, s, true, extended);
}
 
static int bus_property_get_current_dns_server(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
        return bus_property_get_current_dns_server_internal(bus, path, interface, property, reply, userdata, error, false);
}
 
static int bus_property_get_current_dns_server_ex(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
        return bus_property_get_current_dns_server_internal(bus, path, interface, property, reply, userdata, error, true);
}
 
static int bus_property_get_domains(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        Manager *m = ASSERT_PTR(userdata);
        Link *l;
        int r;
 
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(isb)");
        if (r < 0)
                return r;
 
        LIST_FOREACH(domains, d, m->search_domains) {
                r = sd_bus_message_append(reply, "(isb)", 0, d->name, d->route_only);
                if (r < 0)
                        return r;
        }
 
        HASHMAP_FOREACH(l, m->links) {
                LIST_FOREACH(domains, d, l->search_domains) {
                        r = sd_bus_message_append(reply, "(isb)", l->ifindex, d->name, d->route_only);
                        if (r < 0)
                                return r;
                }
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int bus_property_get_transaction_statistics(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        Manager *m = ASSERT_PTR(userdata);
 
        assert(reply);
 
        return sd_bus_message_append(reply, "(tt)",
                                     (uint64_t) hashmap_size(m->dns_transactions),
                                     (uint64_t) m->n_transactions_total);
}
 
static int bus_property_get_cache_statistics(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        uint64_t size = 0, hit = 0, miss = 0;
        Manager *m = ASSERT_PTR(userdata);
 
        assert(reply);
 
        LIST_FOREACH(scopes, s, m->dns_scopes) {
                size += dns_cache_size(&s->cache);
                hit += s->cache.n_hit;
                miss += s->cache.n_miss;
        }
 
        return sd_bus_message_append(reply, "(ttt)", size, hit, miss);
}
 
static int bus_property_get_dnssec_statistics(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        Manager *m = ASSERT_PTR(userdata);
 
        assert(reply);
 
        return sd_bus_message_append(reply, "(tttt)",
                                     (uint64_t) m->n_dnssec_verdict[DNSSEC_SECURE],
                                     (uint64_t) m->n_dnssec_verdict[DNSSEC_INSECURE],
                                     (uint64_t) m->n_dnssec_verdict[DNSSEC_BOGUS],
                                     (uint64_t) m->n_dnssec_verdict[DNSSEC_INDETERMINATE]);
}
 
static BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_dns_stub_listener_mode, dns_stub_listener_mode, DnsStubListenerMode);
static BUS_DEFINE_PROPERTY_GET(bus_property_get_dnssec_supported, "b", Manager, manager_dnssec_supported);
static BUS_DEFINE_PROPERTY_GET2(bus_property_get_dnssec_mode, "s", Manager, manager_get_dnssec_mode, dnssec_mode_to_string);
static BUS_DEFINE_PROPERTY_GET2(bus_property_get_dns_over_tls_mode, "s", Manager, manager_get_dns_over_tls_mode, dns_over_tls_mode_to_string);
 
static int bus_property_get_resolv_conf_mode(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        int r;
 
        assert(reply);
 
        r = resolv_conf_mode();
        if (r < 0) {
                log_warning_errno(r, "Failed to test /etc/resolv.conf mode, ignoring: %m");
                return sd_bus_message_append(reply, "s", NULL);
        }
 
        return sd_bus_message_append(reply, "s", resolv_conf_mode_to_string(r));
}
 
static int bus_method_reset_statistics(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Manager *m = ASSERT_PTR(userdata);
        int r;
 
        assert(message);
 
        r = bus_verify_polkit_async(
                        message,
                        "org.freedesktop.resolve1.reset-statistics",
                        /* details= */ NULL,
                        &m->polkit_registry,
                        error);
        if (r < 0)
                return r;
        if (r == 0)
                return 1; /* Polkit will call us back */
 
        bus_client_log(message, "statistics reset");
 
        dns_manager_reset_statistics(m);
 
        return sd_bus_reply_method_return(message, NULL);
}
 
static int get_any_link(Manager *m, int ifindex, Link **ret, sd_bus_error *error) {
        Link *l;
 
        assert(m);
        assert(ret);
 
        l = hashmap_get(m->links, INT_TO_PTR(ifindex));
        if (!l)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %i not known", ifindex);
 
        *ret = l;
        return 0;
}
 
static int call_link_method(Manager *m, sd_bus_message *message, sd_bus_message_handler_t handler, sd_bus_error *error) {
        int ifindex, r;
        Link *l = NULL;  /* avoid false maybe-uninitialized warning */
 
        assert(m);
        assert(message);
        assert(handler);
 
        r = bus_message_read_ifindex(message, error, &ifindex);
        if (r < 0)
                return r;
 
        r = get_any_link(m, ifindex, &l, error);
        if (r < 0)
                return r;
 
        return handler(message, l, error);
}
 
static int bus_method_set_link_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dns_servers, error);
}
 
static int bus_method_set_link_dns_servers_ex(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dns_servers_ex, error);
}
 
static int bus_method_set_link_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_domains, error);
}
 
static int bus_method_set_link_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_default_route, error);
}
 
static int bus_method_set_link_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_llmnr, error);
}
 
static int bus_method_set_link_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_mdns, error);
}
 
static int bus_method_set_link_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dns_over_tls, error);
}
 
static int bus_method_set_link_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dnssec, error);
}
 
static int bus_method_set_link_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dnssec_negative_trust_anchors, error);
}
 
static int bus_method_revert_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_revert, error);
}
 
static int bus_method_get_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_free_ char *p = NULL;
        Manager *m = ASSERT_PTR(userdata);
        int r, ifindex;
        Link *l = NULL;  /* avoid false maybe-uninitialized warning */
 
        assert(message);
 
        r = bus_message_read_ifindex(message, error, &ifindex);
        if (r < 0)
                return r;
 
        r = get_any_link(m, ifindex, &l, error);
        if (r < 0)
                return r;
 
        p = link_bus_path(l);
        if (!p)
                return -ENOMEM;
 
        return sd_bus_reply_method_return(message, "o", p);
}
 
static int bus_method_flush_caches(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Manager *m = ASSERT_PTR(userdata);
        int r;
 
        assert(message);
 
        r = bus_verify_polkit_async(
                        message,
                        "org.freedesktop.resolve1.flush-caches",
                        /* details= */ NULL,
                        &m->polkit_registry,
                        error);
        if (r < 0)
                return r;
        if (r == 0)
                return 1; /* Polkit will call us back */
 
        bus_client_log(message, "cache flush");
 
        manager_flush_caches(m, LOG_INFO);
 
        return sd_bus_reply_method_return(message, NULL);
}
 
static int bus_method_reset_server_features(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Manager *m = ASSERT_PTR(userdata);
        int r;
 
        assert(message);
 
        r = bus_verify_polkit_async(
                        message,
                        "org.freedesktop.resolve1.reset-server-features",
                        /* details= */ NULL,
                        &m->polkit_registry,
                        error);
        if (r < 0)
                return r;
        if (r == 0)
                return 1; /* Polkit will call us back */
 
        bus_client_log(message, "server feature reset");
 
        (void) dns_stream_disconnect_all(m);
        manager_reset_server_features(m);
 
        return sd_bus_reply_method_return(message, NULL);
}
 
static int dnssd_registered_service_on_bus_track(sd_bus_track *t, void *userdata) {
        DnssdRegisteredService *s = ASSERT_PTR(userdata);
 
        assert(t);
 
        log_debug("Client of DNS-SD service '%s' vanished, unregistering.", s->id);
        dnssd_registered_service_unregister(s);
 
        return 0;
}
 
static int bus_method_register_service(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
        _cleanup_(dnssd_registered_service_freep) DnssdRegisteredService *service = NULL;
        _cleanup_(sd_bus_track_unrefp) sd_bus_track *bus_track = NULL;
        const char *id, *name_template, *type;
        _cleanup_free_ char *path = NULL;
        DnssdRegisteredService *s = NULL;
        Manager *m = ASSERT_PTR(userdata);
        uid_t euid;
        int r;
 
        assert(message);
 
        if (m->mdns_support != RESOLVE_SUPPORT_YES)
                return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for MulticastDNS is disabled");
 
        service = new0(DnssdRegisteredService, 1);
        if (!service)
                return log_oom();
 
        r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
        if (r < 0)
                return r;
 
        r = sd_bus_creds_get_euid(creds, &euid);
        if (r < 0)
                return r;
        service->originator = euid;
        service->config_source = RESOLVE_CONFIG_SOURCE_DBUS;
 
        r = sd_bus_message_read(message, "sssqqq", &id, &name_template, &type,
                                &service->port, &service->priority,
                                &service->weight);
        if (r < 0)
                return r;
 
        if (!filename_part_is_valid(id))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "DNS-SD service identifier '%s' is invalid", id);
 
        if (!dnssd_srv_type_is_valid(type))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "DNS-SD service type '%s' is invalid", type);
 
        s = hashmap_get(m->dnssd_registered_services, id);
        if (s)
                return sd_bus_error_setf(error, BUS_ERROR_DNSSD_SERVICE_EXISTS, "DNS-SD service '%s' exists already", id);
 
        service->id = strdup(id);
        if (!service->id)
                return log_oom();
 
        service->name_template = strdup(name_template);
        if (!service->name_template)
                return log_oom();
 
        service->type = strdup(type);
        if (!service->type)
                return log_oom();
 
        r = dnssd_render_instance_name(m, service, NULL);
        if (r < 0)
                return r;
 
        r = sd_bus_message_enter_container(message, SD_BUS_TYPE_ARRAY, "a{say}");
        if (r < 0)
                return r;
 
        while ((r = sd_bus_message_enter_container(message, SD_BUS_TYPE_ARRAY, "{say}")) > 0) {
                _cleanup_(dnssd_txtdata_freep) DnssdTxtData *txt_data = NULL;
                DnsTxtItem *last = NULL;
 
                txt_data = new0(DnssdTxtData, 1);
                if (!txt_data)
                        return log_oom();
 
                while ((r = sd_bus_message_enter_container(message, SD_BUS_TYPE_DICT_ENTRY, "say")) > 0) {
                        const char *key;
                        const void *value;
                        size_t size;
                        DnsTxtItem *i;
 
                        r = sd_bus_message_read(message, "s", &key);
                        if (r < 0)
                                return r;
 
                        if (isempty(key))
                                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Keys in DNS-SD TXT RRs can't be empty");
 
                        if (!ascii_is_valid(key))
                                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "TXT key '%s' contains non-ASCII symbols", key);
 
                        r = sd_bus_message_read_array(message, 'y', &value, &size);
                        if (r < 0)
                                return r;
 
                        r = dnssd_txt_item_new_from_data(key, value, size, &i);
                        if (r < 0)
                                return r;