HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/resolve/resolved-varlink.c
Git blob: 5d5cdc172bf751141c1f80e238df65b1b16b6f95
Lines 1001–1589 of 1,589
if (p.name && !p.type) /* Service name cannot be specified without service type. */
return sd_varlink_error_invalid_parameter(link, JSON_VARIANT_STRING_CONST("type"));
if (validate_and_mangle_query_flags(m, &p.flags, p.name, SD_RESOLVED_NO_TXT|SD_RESOLVED_NO_ADDRESS) < 0)
return sd_varlink_error_invalid_parameter(link, JSON_VARIANT_STRING_CONST("flags"));
/* Refuse the method if SRV is filtered. */
if (set_contains(m->refuse_record_types, INT_TO_PTR(DNS_TYPE_SRV)))
return sd_varlink_error(link, "io.systemd.Resolve.QueryRefused", NULL);
r = dns_question_new_service(&question_utf8, p.name, p.type, p.domain, !(p.flags & SD_RESOLVED_NO_TXT), false);
if (r < 0)
return r;
r = dns_question_new_service(&question_idna, p.name, p.type, p.domain, !(p.flags & SD_RESOLVED_NO_TXT), true);
if (r < 0)
return r;
r = dns_query_new_for_varlink(m, &q, question_utf8, question_idna, NULL, p.ifindex, p.flags|SD_RESOLVED_NO_SEARCH, link);
if (r < 0)
return r;
q->varlink_request = sd_varlink_ref(link);
q->request_family = p.family;
q->complete = vl_method_resolve_service_complete;
sd_varlink_set_userdata(link, q);
r = dns_query_go(q);
if (r < 0)
return r;
TAKE_PTR(q);
return 1;
}
static void vl_method_resolve_record_complete(DnsQuery *query) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_(dns_query_freep) DnsQuery *q = query;
DnsQuestion *question;
int r;
assert(q);
if (q->state != DNS_TRANSACTION_SUCCESS)
return (void) reply_query_state(q);
r = dns_query_process_cname_many(q);
if (r == -ELOOP)
return (void) sd_varlink_error(q->varlink_request, "io.systemd.Resolve.CNAMELoop", NULL);
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);
unsigned added = 0;
int ifindex;
DnsResourceRecord *rr;
DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = dns_question_matches_rr(question, rr, NULL);
if (r < 0)
goto finish;
if (r == 0)
continue;
r = dns_resource_record_to_json(rr, &v);
if (r < 0)
goto finish;
r = dns_resource_record_to_wire_format(rr, /* canonical= */ false); /* don't use DNSSEC canonical format, since it removes casing, but we want that for DNS_SD compat */
if (r < 0)
goto finish;
r = sd_json_variant_append_arraybo(
&array,
SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_INTEGER(ifindex)),
SD_JSON_BUILD_PAIR_CONDITION(!!v, "rr", SD_JSON_BUILD_VARIANT(v)),
SD_JSON_BUILD_PAIR_BASE64("raw", rr->wire_format, rr->wire_format_size));
if (r < 0)
goto finish;
added++;
}
if (added <= 0)
return (void) sd_varlink_error(q->varlink_request, "io.systemd.Resolve.NoSuchResourceRecord", NULL);
r = sd_varlink_replybo(
q->varlink_request,
SD_JSON_BUILD_PAIR_VARIANT("rrs", array),
SD_JSON_BUILD_PAIR_INTEGER("flags", dns_query_reply_flags_make(q)));
finish:
if (r < 0) {
log_full_errno(ERRNO_IS_DISCONNECT(r) ? LOG_DEBUG : LOG_ERR, r, "Failed to send record reply: %m");
(void) sd_varlink_error_errno(q->varlink_request, r);
}
}
static int vl_method_resolve_record(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_ifindex, offsetof(LookupParameters, ifindex), SD_JSON_RELAX },
{ "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, name), SD_JSON_MANDATORY },
{ "class", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(LookupParameters, class), 0 },
{ "type", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(LookupParameters, type), SD_JSON_MANDATORY },
{ "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(LookupParameters, flags), 0 },
{}
};
_cleanup_(lookup_parameters_destroy) LookupParameters p = {
.class = DNS_CLASS_IN,
.type = _DNS_TYPE_INVALID,
};
_cleanup_(dns_query_freep) DnsQuery *q = NULL;
Manager *m;
int r;
assert(link);
if (sd_varlink_get_userdata(link))
return -EBUSY;
m = ASSERT_PTR(sd_varlink_server_get_userdata(sd_varlink_get_server(link)));
if (FLAGS_SET(flags, SD_VARLINK_METHOD_ONEWAY))
return -EINVAL;
r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
if (r != 0)
return r;
r = dns_name_is_valid(p.name);
if (r < 0)
return r;
if (r == 0)
return sd_varlink_error_invalid_parameter(link, JSON_VARIANT_STRING_CONST("name"));
if (!dns_type_is_valid_query(p.type))
return sd_varlink_error(link, "io.systemd.Resolve.ResourceRecordTypeInvalidForQuery", NULL);
if (dns_type_is_zone_transfer(p.type))
return sd_varlink_error(link, "io.systemd.Resolve.ZoneTransfersNotPermitted", NULL);
if (dns_type_is_obsolete(p.type))
return sd_varlink_error(link, "io.systemd.Resolve.ResourceRecordTypeObsolete", NULL);
if (validate_and_mangle_query_flags(m, &p.flags, p.name, SD_RESOLVED_NO_SEARCH) < 0)
return sd_varlink_error_invalid_parameter(link, JSON_VARIANT_STRING_CONST("flags"));
_cleanup_(dns_question_unrefp) DnsQuestion *question = dns_question_new(1);
if (!question)
return -ENOMEM;
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
key = dns_resource_key_new(p.class, p.type, p.name);
if (!key)
return -ENOMEM;
r = dns_question_add(question, key, /* flags= */ 0);
if (r < 0)
return r;
r = dns_query_new_for_varlink(m, &q, question, question, NULL, p.ifindex, p.flags|SD_RESOLVED_NO_SEARCH|SD_RESOLVED_CLAMP_TTL, link);
if (r < 0)
return r;
q->varlink_request = sd_varlink_ref(link);
sd_varlink_set_userdata(link, q);
q->complete = vl_method_resolve_record_complete;
r = dns_query_go(q);
if (r < 0)
return r;
TAKE_PTR(q);
return 1;
}
static int verify_polkit(sd_varlink *link, sd_json_variant *parameters, const char *action) {
int r;
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
assert(action);
r = sd_varlink_dispatch(link, parameters, dispatch_table_polkit_only, /* userdata= */ NULL);
if (r != 0)
return r;
return varlink_verify_polkit_async(
link,
m->bus,
action,
/* details= */ NULL,
&m->polkit_registry);
}
static int vl_method_browse_services(sd_varlink* link, sd_json_variant* parameters, sd_varlink_method_flags_t flags, void* userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "domain", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParamatersBrowseServices, domain), 0 },
{ "type", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParamatersBrowseServices, type), 0 },
{ "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(LookupParamatersBrowseServices, ifindex), 0 },
{ "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(LookupParamatersBrowseServices, flags), 0 },
{}
};
LookupParamatersBrowseServices p = {};
Manager *m;
int r = 0;
assert(link);
assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
m = ASSERT_PTR(sd_varlink_server_get_userdata(sd_varlink_get_server(link)));
r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
if (r != 0)
return r;
if (validate_and_mangle_query_flags(m, &p.flags, /* name= */ NULL, /* ok= */ 0))
return sd_varlink_error_invalid_parameter_name(link, "flags");
r = dns_subscribe_browse_service(m, link, p.domain, p.type, p.ifindex, p.flags);
if (r < 0)
return sd_varlink_error_errno(link, r);
return 1;
}
static int vl_method_subscribe_query_results(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
int r;
assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
r = verify_polkit(link, parameters, "org.freedesktop.resolve1.subscribe-query-results");
if (r <= 0)
return r;
/* Send a ready message to the connecting client, to indicate that we are now listinening, and all
* queries issued after the point the client sees this will also be reported to the client. */
r = sd_varlink_notifybo(link, SD_JSON_BUILD_PAIR_BOOLEAN("ready", true));
if (r < 0)
return log_error_errno(r, "Failed to report monitor to be established: %m");
r = set_ensure_put(&m->varlink_query_results_subscription, NULL, link);
if (r < 0)
return log_error_errno(r, "Failed to add subscription to set: %m");
sd_varlink_ref(link);
log_debug("%u clients now attached for query result varlink notifications", set_size(m->varlink_query_results_subscription));
return 1;
}
static int vl_method_dump_cache(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *list = NULL;
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
int r;
assert(link);
r = verify_polkit(link, parameters, "org.freedesktop.resolve1.dump-cache");
if (r <= 0)
return r;
LIST_FOREACH(scopes, s, m->dns_scopes) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
r = dns_scope_to_json(s, /* with_cache= */ true, &j);
if (r < 0)
return r;
r = sd_json_variant_append_array(&list, j);
if (r < 0)
return r;
}
if (!list) {
r = sd_json_variant_new_array(&list, NULL, 0);
if (r < 0)
return r;
}
return sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_VARIANT("dump", list));
}
static int dns_server_dump_state_to_json_list(DnsServer *server, sd_json_variant **list) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
int r;
assert(list);
assert(server);
r = dns_server_dump_state_to_json(server, &j);
if (r < 0)
return r;
return sd_json_variant_append_array(list, j);
}
static int vl_method_dump_server_state(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *list = NULL;
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
Link *l;
int r;
r = verify_polkit(link, parameters, "org.freedesktop.resolve1.dump-server-state");
if (r <= 0)
return r;
LIST_FOREACH(servers, server, m->dns_servers) {
r = dns_server_dump_state_to_json_list(server, &list);
if (r < 0)
return r;
}
LIST_FOREACH(servers, server, m->fallback_dns_servers) {
r = dns_server_dump_state_to_json_list(server, &list);
if (r < 0)
return r;
}
HASHMAP_FOREACH(l, m->links)
LIST_FOREACH(servers, server, l->dns_servers) {
r = dns_server_dump_state_to_json_list(server, &list);
if (r < 0)
return r;
}
if (!list) {
r = sd_json_variant_new_array(&list, NULL, 0);
if (r < 0)
return r;
}
return sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_VARIANT("dump", list));
}
static int vl_method_dump_statistics(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
int r;
assert(link);
r = verify_polkit(link, parameters, "org.freedesktop.resolve1.dump-statistics");
if (r <= 0)
return r;
r = dns_manager_dump_statistics_json(m, &j);
if (r < 0)
return r;
return sd_varlink_replyb(link, SD_JSON_BUILD_VARIANT(j));
}
static int vl_method_reset_statistics(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
int r;
r = verify_polkit(link, parameters, "org.freedesktop.resolve1.reset-statistics");
if (r <= 0)
return r;
dns_manager_reset_statistics(m);
return sd_varlink_replyb(link, SD_JSON_BUILD_EMPTY_OBJECT);
}
static int vl_method_flush_caches(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
int r;
r = verify_polkit(link, parameters, "org.freedesktop.resolve1.flush-caches");
if (r <= 0)
return r;
manager_flush_caches(m, LOG_INFO);
return sd_varlink_reply(link, NULL);
}
static int vl_method_reset_server_features(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
int r;
r = verify_polkit(link, parameters, "org.freedesktop.resolve1.reset-server-features");
if (r <= 0)
return r;
(void) dns_stream_disconnect_all(m);
manager_reset_server_features(m);
return sd_varlink_reply(link, NULL);
}
static int vl_method_subscribe_dns_configuration(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
int r;
assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
r = verify_polkit(link, parameters, "org.freedesktop.resolve1.subscribe-dns-configuration");
if (r <= 0)
return r;
if (set_isempty(m->varlink_dns_configuration_subscription)) {
r = manager_start_dns_configuration_monitor(m);
if (r < 0)
return log_error_errno(r, "Failed to start DNS configuration monitor: %m");
}
r = sd_varlink_notify(link, m->dns_configuration_json);
if (r < 0)
goto fail;
r = set_ensure_put(&m->varlink_dns_configuration_subscription, NULL, link);
if (r < 0)
goto fail;
sd_varlink_ref(link);
log_debug("%u clients now attached for link configuration varlink notifications",
set_size(m->varlink_dns_configuration_subscription));
return 1;
fail:
if (set_isempty(m->varlink_dns_configuration_subscription))
manager_stop_dns_configuration_monitor(m);
return log_debug_errno(r, "Failed to subscribe client to DNS configuration monitor: %m");
}
static int vl_method_dump_dns_configuration(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *configuration = NULL;
Manager *m;
Link *l;
int r;
assert(link);
m = ASSERT_PTR(sd_varlink_server_get_userdata(sd_varlink_get_server(link)));
/* Make sure the accessible flag is not stale. */
dns_server_reset_accessible_all(m->dns_servers);
HASHMAP_FOREACH(l, m->links)
dns_server_reset_accessible_all(l->dns_servers);
r = manager_dump_dns_configuration_json(m, &configuration);
if (r < 0)
return r;
return sd_varlink_reply(link, configuration);
}
static int varlink_monitor_server_init(Manager *m) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *server = NULL;
int r;
assert(m);
if (m->varlink_monitor_server)
return 0;
r = varlink_server_new(&server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
r = sd_varlink_server_add_interface(server, &vl_interface_io_systemd_Resolve_Monitor);
if (r < 0)
return log_error_errno(r, "Failed to add Resolve.Monitor interface to varlink server: %m");
r = sd_varlink_server_bind_method_many(
server,
"io.systemd.Resolve.Monitor.SubscribeQueryResults", vl_method_subscribe_query_results,
"io.systemd.Resolve.Monitor.DumpCache", vl_method_dump_cache,
"io.systemd.Resolve.Monitor.DumpServerState", vl_method_dump_server_state,
"io.systemd.Resolve.Monitor.DumpStatistics", vl_method_dump_statistics,
"io.systemd.Resolve.Monitor.ResetStatistics", vl_method_reset_statistics,
"io.systemd.Resolve.Monitor.SubscribeDNSConfiguration", vl_method_subscribe_dns_configuration,
"io.systemd.Resolve.Monitor.FlushCaches", vl_method_flush_caches,
"io.systemd.Resolve.Monitor.ResetServerFeatures", vl_method_reset_server_features);
if (r < 0)
return log_error_errno(r, "Failed to register varlink methods: %m");
r = sd_varlink_server_bind_disconnect(server, vl_on_notification_disconnect);
if (r < 0)
return log_error_errno(r, "Failed to register varlink disconnect handler: %m");
r = sd_varlink_server_listen_name(server, "varlink-monitor");
if (r < 0)
return log_error_errno(r, "Failed to get varlink listen fd: %m");
if (r == 0) {
r = sd_varlink_server_listen_address(server, "/run/systemd/resolve/io.systemd.Resolve.Monitor", 0666);
if (r < 0)
return log_error_errno(r, "Failed to bind to varlink socket '/run/systemd/resolve/io.systemd.Resolve.Monitor': %m");
}
r = sd_varlink_server_attach_event(server, m->event, SD_EVENT_PRIORITY_NORMAL);
if (r < 0)
return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
m->varlink_monitor_server = TAKE_PTR(server);
return 0;
}
static int varlink_main_server_init(Manager *m) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
int r;
assert(m);
if (m->varlink_server)
return 0;
r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
r = sd_varlink_server_add_interface_many(
s,
&vl_interface_io_systemd_Resolve,
&vl_interface_io_systemd_service);
if (r < 0)
return log_error_errno(r, "Failed to add Resolve interface to varlink server: %m");
r = sd_varlink_server_bind_method_many(
s,
"io.systemd.Resolve.ResolveHostname", vl_method_resolve_hostname,
"io.systemd.Resolve.ResolveAddress", vl_method_resolve_address,
"io.systemd.Resolve.ResolveService", vl_method_resolve_service,
"io.systemd.Resolve.ResolveRecord", vl_method_resolve_record,
"io.systemd.service.Ping", varlink_method_ping,
"io.systemd.service.SetLogLevel", varlink_method_set_log_level,
"io.systemd.service.GetLogLevel", varlink_method_get_log_level,
"io.systemd.service.GetEnvironment", varlink_method_get_environment,
"io.systemd.Resolve.BrowseServices", vl_method_browse_services,
"io.systemd.Resolve.DumpDNSConfiguration", vl_method_dump_dns_configuration);
if (r < 0)
return log_error_errno(r, "Failed to register varlink methods: %m");
r = sd_varlink_server_bind_disconnect(s, vl_on_disconnect);
if (r < 0)
return log_error_errno(r, "Failed to register varlink disconnect handler: %m");
r = sd_varlink_server_listen_auto(s);
if (r < 0)
return log_error_errno(r, "Failed to get varlink listen fd: %m");
if (r == 0) {
r = sd_varlink_server_listen_address(s, "/run/systemd/resolve/io.systemd.Resolve", 0666);
if (r < 0)
return log_error_errno(r, "Failed to bind to varlink socket '/run/systemd/resolve/io.systemd.Resolve': %m");
}
r = sd_varlink_server_attach_event(s, m->event, SD_EVENT_PRIORITY_NORMAL);
if (r < 0)
return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
m->varlink_server = TAKE_PTR(s);
return 0;
}
int manager_varlink_init(Manager *m) {
int r;
r = varlink_main_server_init(m);
if (r < 0)
return r;
r = varlink_monitor_server_init(m);
if (r < 0)
return r;
return 0;
}
void manager_varlink_done(Manager *m) {
assert(m);
m->varlink_server = sd_varlink_server_unref(m->varlink_server);
m->varlink_monitor_server = sd_varlink_server_unref(m->varlink_monitor_server);
}