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 2001–2422 of 2,422

                        LIST_INSERT_AFTER(items, txt_data->txts, last, i);
                        last = i;
 
                        r = sd_bus_message_exit_container(message);
                        if (r < 0)
                                return r;
 
                }
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (txt_data->txts) {
                        LIST_PREPEND(items, service->txt_data_items, txt_data);
                        txt_data = NULL;
                }
        }
        if (r < 0)
                return r;
 
        r = sd_bus_message_exit_container(message);
        if (r < 0)
                return r;
 
        if (!service->txt_data_items) {
                _cleanup_(dnssd_txtdata_freep) DnssdTxtData *txt_data = NULL;
 
                txt_data = new0(DnssdTxtData, 1);
                if (!txt_data)
                        return log_oom();
 
                r = dns_txt_item_new_empty(&txt_data->txts);
                if (r < 0)
                        return r;
 
                LIST_PREPEND(items, service->txt_data_items, txt_data);
                txt_data = NULL;
        }
 
        r = sd_bus_path_encode("/org/freedesktop/resolve1/dnssd", service->id, &path);
        if (r < 0)
                return r;
 
        r = bus_verify_polkit_async(
                        message,
                        "org.freedesktop.resolve1.register-service",
                        /* details= */ NULL,
                        &m->polkit_registry,
                        error);
        if (r < 0)
                return r;
        if (r == 0)
                return 1; /* Polkit will call us back */
 
        r = sd_bus_track_new(sd_bus_message_get_bus(message), &bus_track, dnssd_registered_service_on_bus_track, service);
        if (r < 0)
                return r;
 
        r = sd_bus_track_add_sender(bus_track, message);
        if (r < 0)
                return r;
 
        /* The service is unregistered automatically when the client that registered it disconnects from the
         * bus, hence keep the bus track object pinned for the lifetime of the service. */
        service->bus_track = TAKE_PTR(bus_track);
 
        service->manager = m;
 
        r = hashmap_ensure_put(&m->dnssd_registered_services, &string_hash_ops, service->id, service);
        if (r < 0)
                return r;
 
        service = NULL;
 
        manager_refresh_rrs(m);
 
        return sd_bus_reply_method_return(message, "o", path);
}
 
static int call_dnssd_method(Manager *m, sd_bus_message *message, sd_bus_message_handler_t handler, sd_bus_error *error) {
        _cleanup_free_ char *name = NULL;
        DnssdRegisteredService *s = NULL;
        const char *path;
        int r;
 
        assert(m);
        assert(message);
        assert(handler);
 
        r = sd_bus_message_read(message, "o", &path);
        if (r < 0)
                return r;
 
        r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/dnssd", &name);
        if (r == 0)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DNSSD_SERVICE, "DNS-SD service with object path '%s' does not exist", path);
        if (r < 0)
                return r;
 
        s = hashmap_get(m->dnssd_registered_services, name);
        if (!s)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DNSSD_SERVICE, "DNS-SD service '%s' not known", name);
 
        return handler(message, s, error);
}
 
static int bus_method_unregister_service(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Manager *m = ASSERT_PTR(userdata);
 
        assert(message);
 
        return call_dnssd_method(m, message, bus_dnssd_method_unregister, error);
}
 
static int bus_method_get_delegate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_free_ char *p = NULL;
        Manager *m = ASSERT_PTR(userdata);
        int r;
 
        assert(message);
 
        const char *id;
        r = sd_bus_message_read(message, "s", &id);
        if (r < 0)
                return r;
 
        DnsDelegate *d = hashmap_get(m->delegates, id);
        if (!d)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DELEGATE, "Delegate '%s' not known", id);
 
        p = dns_delegate_bus_path(d);
        if (!p)
                return -ENOMEM;
 
        return sd_bus_reply_method_return(message, "o", p);
}
 
static int bus_method_list_delegates(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        Manager *m = ASSERT_PTR(userdata);
        int r;
 
        assert(message);
 
        r = sd_bus_message_new_method_return(message, &reply);
        if (r < 0)
                return r;
 
        r = sd_bus_message_open_container(reply, 'a', "(so)");
        if (r < 0)
                return r;
 
        DnsDelegate *d;
        HASHMAP_FOREACH(d, m->delegates) {
                _cleanup_free_ char *p = NULL;
 
                p = dns_delegate_bus_path(d);
                if (!p)
                        return -ENOMEM;
 
                r = sd_bus_message_append(reply, "(so)", d->id, p);
                if (r < 0)
                        return r;
        }
 
        r = sd_bus_message_close_container(reply);
        if (r < 0)
                return r;
 
        return sd_bus_message_send(reply);
}
 
static const sd_bus_vtable resolve_vtable[] = {
        SD_BUS_VTABLE_START(0),
        SD_BUS_PROPERTY("LLMNRHostname", "s", NULL, offsetof(Manager, llmnr_hostname), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("LLMNR", "s", bus_property_get_resolve_support, offsetof(Manager, llmnr_support), 0),
        SD_BUS_PROPERTY("MulticastDNS", "s", bus_property_get_resolve_support, offsetof(Manager, mdns_support), 0),
        SD_BUS_PROPERTY("DNSOverTLS", "s", bus_property_get_dns_over_tls_mode, 0, 0),
        SD_BUS_PROPERTY("DNS", "a(iiay)", bus_property_get_dns_servers, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("DNSEx", "a(iiayqs)", bus_property_get_dns_servers_ex, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("FallbackDNS", "a(iiay)", bus_property_get_fallback_dns_servers, offsetof(Manager, fallback_dns_servers), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("FallbackDNSEx", "a(iiayqs)", bus_property_get_fallback_dns_servers_ex, offsetof(Manager, fallback_dns_servers), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("CurrentDNSServer", "(iiay)", bus_property_get_current_dns_server, offsetof(Manager, current_dns_server), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("CurrentDNSServerEx", "(iiayqs)", bus_property_get_current_dns_server_ex, offsetof(Manager, current_dns_server), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("Domains", "a(isb)", bus_property_get_domains, 0, 0),
        SD_BUS_PROPERTY("TransactionStatistics", "(tt)", bus_property_get_transaction_statistics, 0, 0),
        SD_BUS_PROPERTY("CacheStatistics", "(ttt)", bus_property_get_cache_statistics, 0, 0),
        SD_BUS_PROPERTY("DNSSEC", "s", bus_property_get_dnssec_mode, 0, 0),
        SD_BUS_PROPERTY("DNSSECStatistics", "(tttt)", bus_property_get_dnssec_statistics, 0, 0),
        SD_BUS_PROPERTY("DNSSECSupported", "b", bus_property_get_dnssec_supported, 0, 0),
        SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", bus_property_get_string_set, offsetof(Manager, trust_anchor.negative_by_name), 0),
        SD_BUS_PROPERTY("DNSStubListener", "s", bus_property_get_dns_stub_listener_mode, offsetof(Manager, dns_stub_listener_mode), 0),
        SD_BUS_PROPERTY("ResolvConfMode", "s", bus_property_get_resolv_conf_mode, 0, 0),
 
        SD_BUS_METHOD_WITH_ARGS("ResolveHostname",
                                SD_BUS_ARGS("i", ifindex, "s", name, "i", family, "t", flags),
                                SD_BUS_RESULT("a(iiay)", addresses, "s", canonical, "t", flags),
                                bus_method_resolve_hostname,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ResolveAddress",
                                SD_BUS_ARGS("i",  ifindex, "i", family, "ay", address, "t", flags),
                                SD_BUS_RESULT("a(is)", names, "t", flags),
                                bus_method_resolve_address,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ResolveRecord",
                                SD_BUS_ARGS("i", ifindex, "s", name, "q", class, "q", type, "t", flags),
                                SD_BUS_RESULT("a(iqqay)", records, "t", flags),
                                bus_method_resolve_record,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ResolveService",
                                SD_BUS_ARGS("i", ifindex,
                                            "s", name,
                                            "s", type,
                                            "s", domain,
                                            "i", family,
                                            "t", flags),
                                SD_BUS_RESULT("a(qqqsa(iiay)s)", srv_data,
                                              "aay", txt_data,
                                              "s", canonical_name,
                                              "s", canonical_type,
                                              "s", canonical_domain,
                                              "t", flags),
                                bus_method_resolve_service,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("GetLink",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_RESULT("o", path),
                                bus_method_get_link,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNS",
                                SD_BUS_ARGS("i", ifindex, "a(iay)", addresses),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dns_servers,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNSEx",
                                SD_BUS_ARGS("i", ifindex, "a(iayqs)", addresses),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dns_servers_ex,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDomains",
                                SD_BUS_ARGS("i", ifindex, "a(sb)", domains),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_domains,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDefaultRoute",
                                SD_BUS_ARGS("i", ifindex, "b", enable),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_default_route,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkLLMNR",
                                SD_BUS_ARGS("i", ifindex, "s", mode),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_llmnr,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkMulticastDNS",
                                SD_BUS_ARGS("i", ifindex, "s", mode),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_mdns,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNSOverTLS",
                                SD_BUS_ARGS("i", ifindex, "s", mode),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dns_over_tls,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNSSEC",
                                SD_BUS_ARGS("i", ifindex, "s", mode),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dnssec,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNSSECNegativeTrustAnchors",
                                SD_BUS_ARGS("i", ifindex, "as", names),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dnssec_negative_trust_anchors,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("RevertLink",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_NO_RESULT,
                                bus_method_revert_link,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("RegisterService",
                                SD_BUS_ARGS("s", id,
                                            "s", name_template,
                                            "s", type,
                                            "q", service_port,
                                            "q", service_priority,
                                            "q", service_weight,
                                            "aa{say}", txt_datas),
                                SD_BUS_RESULT("o", service_path),
                                bus_method_register_service,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("UnregisterService",
                                SD_BUS_ARGS("o", service_path),
                                SD_BUS_NO_RESULT,
                                bus_method_unregister_service,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ResetStatistics",
                                SD_BUS_NO_ARGS,
                                SD_BUS_NO_RESULT,
                                bus_method_reset_statistics,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("FlushCaches",
                                SD_BUS_NO_ARGS,
                                SD_BUS_NO_RESULT,
                                bus_method_flush_caches,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ResetServerFeatures",
                                SD_BUS_NO_ARGS,
                                SD_BUS_NO_RESULT,
                                bus_method_reset_server_features,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("GetDelegate",
                                SD_BUS_ARGS("s", id),
                                SD_BUS_RESULT("o", path),
                                bus_method_get_delegate,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ListDelegates",
                                SD_BUS_NO_ARGS,
                                SD_BUS_RESULT("a(so)", delegates),
                                bus_method_list_delegates,
                                SD_BUS_VTABLE_UNPRIVILEGED),
 
        SD_BUS_VTABLE_END,
};
 
const BusObjectImplementation manager_object = {
        "/org/freedesktop/resolve1",
        "org.freedesktop.resolve1.Manager",
        .vtables = BUS_VTABLES(resolve_vtable),
        .children = BUS_IMPLEMENTATIONS(&link_object,
                                        &dnssd_object,
                                        &dns_delegate_object),
};
 
static int match_prepare_for_sleep(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
        Manager *m = ASSERT_PTR(userdata);
        int b, r;
 
        assert(message);
 
        r = sd_bus_message_read(message, "b", &b);
        if (r < 0) {
                bus_log_parse_error(r);
                return 0;
        }
 
        if (b)
                return 0;
 
        log_debug("Coming back from suspend, closing all TCP connections...");
        (void) dns_stream_disconnect_all(m);
 
        log_debug("Coming back from suspend, resetting all probed server features...");
        manager_reset_server_features(m);
 
        log_debug("Coming back from suspend, verifying all RRs...");
        manager_verify_all(m);
 
        return 0;
}
 
int manager_connect_bus(Manager *m) {
        int r;
 
        assert(m);
 
        if (m->bus)
                return 0;
 
        r = bus_open_system_watch_bind_with_description(&m->bus, "bus-api-resolve");
        if (r < 0)
                return log_error_errno(r, "Failed to connect to system bus: %m");
 
        r = bus_add_implementation(m->bus, &manager_object, m);
        if (r < 0)
                return r;
 
        r = bus_log_control_api_register(m->bus);
        if (r < 0)
                return r;
 
        r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.resolve1", 0, NULL, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to request name: %m");
 
        r = sd_bus_attach_event(m->bus, m->event, 0);
        if (r < 0)
                return log_error_errno(r, "Failed to attach bus to event loop: %m");
 
        r = bus_match_signal_async(
                        m->bus,
                        NULL,
                        bus_login_mgr,
                        "PrepareForSleep",
                        match_prepare_for_sleep,
                        NULL,
                        m);
        if (r < 0)
                log_warning_errno(r, "Failed to request match for PrepareForSleep, ignoring: %m");
 
        return 0;
}
 
int manager_send_changed_strv(Manager *manager, char **properties) {
        assert(manager);
 
        if (sd_bus_is_ready(manager->bus) <= 0)
                return 0;
 
        int r = sd_bus_emit_properties_changed_strv(
                        manager->bus,
                        "/org/freedesktop/resolve1",
                        "org.freedesktop.resolve1.Manager",
                        properties);
        if (r < 0)
                log_notice_errno(r, "Failed to emit notification about changed properties: %m");
 
        return r;
}