HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/resolve/resolvectl.c
Git blob: 149f229a7d7186a95b4a8379de226d95331c4a92
Lines 2001–3000 of 3,869
vl,
"io.systemd.Resolve.Monitor.ResetServerFeatures",
/* reply= */ NULL,
SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
}
static int print_question(char prefix, const char *color, sd_json_variant *question) {
sd_json_variant *q = NULL;
int r;
assert(color);
JSON_VARIANT_ARRAY_FOREACH(q, question) {
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
char buf[DNS_RESOURCE_KEY_STRING_MAX];
r = dns_resource_key_from_json(q, &key);
if (r < 0) {
log_warning_errno(r, "Received monitor message with invalid question key, ignoring: %m");
continue;
}
printf("%s%s %c%s: %s\n",
color,
glyph(GLYPH_ARROW_RIGHT),
prefix,
ansi_normal(),
dns_resource_key_to_string(key, buf, sizeof(buf)));
}
return 0;
}
static int print_answer(sd_json_variant *answer) {
sd_json_variant *a;
int r;
JSON_VARIANT_ARRAY_FOREACH(a, answer) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
_cleanup_free_ void *d = NULL;
sd_json_variant *jraw;
const char *s;
size_t l;
jraw = sd_json_variant_by_key(a, "raw");
if (!jraw) {
log_warning("Received monitor answer lacking valid raw data, ignoring.");
continue;
}
r = sd_json_variant_unbase64(jraw, &d, &l);
if (r < 0) {
log_warning_errno(r, "Failed to undo base64 encoding of monitor answer raw data, ignoring.");
continue;
}
r = dns_resource_record_new_from_raw(&rr, d, l);
if (r < 0) {
log_warning_errno(r, "Failed to parse monitor answer RR, ignoring: %m");
continue;
}
s = dns_resource_record_to_string(rr);
if (!s)
return log_oom();
printf("%s%s A%s: %s\n",
ansi_highlight_yellow(),
glyph(GLYPH_ARROW_LEFT),
ansi_normal(),
s);
}
return 0;
}
typedef struct MonitorQueryParams {
sd_json_variant *question;
sd_json_variant *answer;
sd_json_variant *collected_questions;
int rcode;
int error;
int ede_code;
const char *state;
const char *result;
const char *ede_msg;
} MonitorQueryParams;
static void monitor_query_params_done(MonitorQueryParams *p) {
assert(p);
sd_json_variant_unref(p->question);
sd_json_variant_unref(p->answer);
sd_json_variant_unref(p->collected_questions);
}
static void monitor_query_dump(sd_json_variant *v) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "question", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(MonitorQueryParams, question), SD_JSON_MANDATORY },
{ "answer", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(MonitorQueryParams, answer), 0 },
{ "collectedQuestions", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(MonitorQueryParams, collected_questions), 0 },
{ "state", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MonitorQueryParams, state), SD_JSON_MANDATORY },
{ "result", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MonitorQueryParams, result), 0 },
{ "rcode", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(MonitorQueryParams, rcode), 0 },
{ "errno", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(MonitorQueryParams, error), 0 },
{ "extendedDNSErrorCode", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(MonitorQueryParams, ede_code), 0 },
{ "extendedDNSErrorMessage", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MonitorQueryParams, ede_msg), 0 },
{}
};
_cleanup_(monitor_query_params_done) MonitorQueryParams p = {
.rcode = -1,
.ede_code = -1,
};
assert(v);
if (sd_json_dispatch(v, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &p) < 0)
return;
/* First show the current question */
print_question('Q', ansi_highlight_cyan(), p.question);
/* And then show the questions that led to this one in case this was a CNAME chain */
print_question('C', ansi_highlight_grey(), p.collected_questions);
printf("%s%s S%s: %s",
streq_ptr(p.state, "success") ? ansi_highlight_green() : ansi_highlight_red(),
glyph(GLYPH_ARROW_LEFT),
ansi_normal(),
streq_ptr(p.state, "errno") ? ERRNO_NAME(p.error) :
streq_ptr(p.state, "rcode-failure") ? strna(dns_rcode_to_string(p.rcode)) :
strna(p.state));
if (!isempty(p.result))
printf(": %s", p.result);
if (p.ede_code >= 0)
printf(" (%s%s%s)",
FORMAT_DNS_EDE_RCODE(p.ede_code),
!isempty(p.ede_msg) ? ": " : "",
strempty(p.ede_msg));
puts("");
print_answer(p.answer);
}
static int monitor_reply(
sd_varlink *link,
sd_json_variant *parameters,
const char *error_id,
sd_varlink_reply_flags_t flags,
void *userdata) {
assert(link);
if (error_id) {
bool disconnect;
disconnect = streq(error_id, SD_VARLINK_ERROR_DISCONNECTED);
if (disconnect)
log_info("Disconnected.");
else
log_error("Varlink error: %s", error_id);
(void) sd_event_exit(ASSERT_PTR(sd_varlink_get_event(link)), disconnect ? EXIT_SUCCESS : EXIT_FAILURE);
return 0;
}
if (sd_json_variant_by_key(parameters, "ready")) {
/* The first message coming in will just indicate that we are now subscribed. We let our
* caller know if they asked for it. Once the caller sees this they should know that we are
* not going to miss any queries anymore. */
(void) sd_notify(/* unset_environment=false */ false, "READY=1");
return 0;
}
if (!sd_json_format_enabled(arg_json_format_flags)) {
monitor_query_dump(parameters);
printf("\n");
} else
sd_json_variant_dump(parameters, arg_json_format_flags, NULL, NULL);
fflush(stdout);
return 0;
}
VERB(verb_monitor, "monitor", NULL, VERB_ANY, 1, 0,
"Monitor DNS queries");
static int verb_monitor(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
_cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
int r, c;
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = sd_event_default(&event);
if (r < 0)
return log_error_errno(r, "Failed to get event loop: %m");
r = sd_event_set_signal_exit(event, true);
if (r < 0)
return log_error_errno(r, "Failed to enable exit on SIGINT/SIGTERM: %m");
r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve.Monitor");
if (r < 0)
return log_error_errno(r, "Failed to connect to query monitoring service /run/systemd/resolve/io.systemd.Resolve.Monitor: %m");
r = sd_varlink_set_relative_timeout(vl, USEC_INFINITY); /* We want the monitor to run basically forever */
if (r < 0)
return log_error_errno(r, "Failed to set varlink timeout: %m");
r = sd_varlink_attach_event(vl, event, SD_EVENT_PRIORITY_NORMAL);
if (r < 0)
return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
r = sd_varlink_bind_reply(vl, monitor_reply);
if (r < 0)
return log_error_errno(r, "Failed to bind reply callback to varlink connection: %m");
r = sd_varlink_observebo(
vl,
"io.systemd.Resolve.Monitor.SubscribeQueryResults",
SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
if (r < 0)
return log_error_errno(r, "Failed to issue SubscribeQueryResults() varlink call: %m");
r = sd_event_loop(event);
if (r < 0)
return log_error_errno(r, "Failed to run event loop: %m");
r = sd_event_get_exit_code(event, &c);
if (r < 0)
return log_error_errno(r, "Failed to get exit code: %m");
return c;
}
static int call_dns(sd_bus *bus, char **dns, const BusLocator *locator, sd_bus_error *error, bool extended) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL;
int r;
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = bus_message_new_method_call(bus, &req, locator, extended ? "SetLinkDNSEx" : "SetLinkDNS");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(req, "i", arg_ifindex);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_open_container(req, 'a', extended ? "(iayqs)" : "(iay)");
if (r < 0)
return bus_log_create_error(r);
/* If only argument is the empty string, then call SetLinkDNS() with an
* empty list, which will clear the list of domains for an interface. */
if (!strv_equal(dns, STRV_MAKE("")))
STRV_FOREACH(p, dns) {
_cleanup_free_ char *name = NULL;
struct in_addr_data data;
uint16_t port;
int ifindex;
r = in_addr_port_ifindex_name_from_string_auto(*p, &data.family, &data.address, &port, &ifindex, &name);
if (r < 0)
return log_error_errno(r, "Failed to parse DNS server address: %s", *p);
if (ifindex != 0 && ifindex != arg_ifindex)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid ifindex: %i", ifindex);
r = sd_bus_message_open_container(req, 'r', extended ? "iayqs" : "iay");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(req, "i", data.family);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append_array(req, 'y', &data.address, FAMILY_ADDRESS_SIZE(data.family));
if (r < 0)
return bus_log_create_error(r);
if (extended) {
r = sd_bus_message_append(req, "q", port);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(req, "s", name);
if (r < 0)
return bus_log_create_error(r);
}
r = sd_bus_message_close_container(req);
if (r < 0)
return bus_log_create_error(r);
}
r = sd_bus_message_close_container(req);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, req, 0, error, NULL);
if (r < 0 && extended && sd_bus_error_has_name(error, SD_BUS_ERROR_UNKNOWN_METHOD)) {
sd_bus_error_free(error);
return call_dns(bus, dns, locator, error, false);
}
return r;
}
static int dump_cache_item(sd_json_variant *item) {
struct item_info {
sd_json_variant *key;
sd_json_variant *rrs;
const char *type;
uint64_t until;
} item_info = {};
static const sd_json_dispatch_field dispatch_table[] = {
{ "key", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct item_info, key), SD_JSON_MANDATORY },
{ "rrs", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant_noref, offsetof(struct item_info, rrs), 0 },
{ "type", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct item_info, type), 0 },
{ "until", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct item_info, until), 0 },
{},
};
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *k = NULL;
int r, c = 0;
r = sd_json_dispatch(item, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &item_info);
if (r < 0)
return r;
r = dns_resource_key_from_json(item_info.key, &k);
if (r < 0)
return log_error_errno(r, "Failed to turn JSON data to resource key: %m");
if (item_info.type)
printf("%s %s%s%s\n", DNS_RESOURCE_KEY_TO_STRING(k), ansi_highlight_red(), item_info.type, ansi_normal());
else {
sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, item_info.rrs) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
_cleanup_free_ void *data = NULL;
sd_json_variant *raw;
size_t size;
raw = sd_json_variant_by_key(i, "raw");
if (!raw)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "raw field missing from RR JSON data.");
r = sd_json_variant_unbase64(raw, &data, &size);
if (r < 0)
return log_error_errno(r, "Unable to decode raw RR JSON data: %m");
r = dns_resource_record_new_from_raw(&rr, data, size);
if (r < 0)
return log_error_errno(r, "Failed to parse DNS data: %m");
printf("%s\n", dns_resource_record_to_string(rr));
c++;
}
}
return c;
}
static int dump_cache_scope(sd_json_variant *scope) {
struct scope_info {
const char *protocol;
int family;
int ifindex;
const char *ifname;
sd_json_variant *cache;
const char *dnssec_mode;
const char *dns_over_tls_mode;
} scope_info = {
.family = AF_UNSPEC,
};
sd_json_variant *i;
int r, c = 0;
static const sd_json_dispatch_field dispatch_table[] = {
{ "protocol", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, protocol), SD_JSON_MANDATORY },
{ "family", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_address_family, offsetof(struct scope_info, family), SD_JSON_RELAX },
{ "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_ifindex, offsetof(struct scope_info, ifindex), SD_JSON_RELAX },
{ "ifname", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, ifname), 0 },
{ "cache", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant_noref, offsetof(struct scope_info, cache), SD_JSON_MANDATORY },
{ "dnssec", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, dnssec_mode), 0 },
{ "dnsOverTLS", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, dns_over_tls_mode), 0 },
{},
};
r = sd_json_dispatch(scope, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &scope_info);
if (r < 0)
return r;
printf("%sScope protocol=%s", ansi_underline(), scope_info.protocol);
if (scope_info.family != AF_UNSPEC)
printf(" family=%s", af_to_name(scope_info.family));
if (scope_info.ifindex > 0)
printf(" ifindex=%i", scope_info.ifindex);
if (scope_info.ifname)
printf(" ifname=%s", scope_info.ifname);
if (dns_protocol_from_string(scope_info.protocol) == DNS_PROTOCOL_DNS) {
if (scope_info.dnssec_mode)
printf(" DNSSEC=%s", scope_info.dnssec_mode);
if (scope_info.dns_over_tls_mode)
printf(" DNSOverTLS=%s", scope_info.dns_over_tls_mode);
}
printf("%s\n", ansi_normal());
JSON_VARIANT_ARRAY_FOREACH(i, scope_info.cache) {
r = dump_cache_item(i);
if (r < 0)
return r;
c += r;
}
if (c == 0)
printf("%sNo entries.%s\n\n", ansi_grey(), ansi_normal());
else
printf("\n");
return 0;
}
VERB(verb_show_cache, "show-cache", NULL, VERB_ANY, 1, 0,
"Show cache contents");
static int verb_show_cache(int argc, char *argv[], uintptr_t _data, void *userdata) {
sd_json_variant *reply = NULL, *d = NULL;
_cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
int r;
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve.Monitor");
if (r < 0)
return log_error_errno(r, "Failed to connect to query monitoring service /run/systemd/resolve/io.systemd.Resolve.Monitor: %m");
r = varlink_callbo_and_log(
vl,
"io.systemd.Resolve.Monitor.DumpCache",
&reply,
SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
if (r < 0)
return r;
d = sd_json_variant_by_key(reply, "dump");
if (!d)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"DumpCache() response is missing 'dump' key.");
if (!sd_json_variant_is_array(d))
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"DumpCache() response 'dump' field not an array");
if (!sd_json_format_enabled(arg_json_format_flags)) {
sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, d) {
r = dump_cache_scope(i);
if (r < 0)
return r;
}
return 0;
}
return sd_json_variant_dump(d, arg_json_format_flags, NULL, NULL);
}
static int dump_server_state(sd_json_variant *server) {
_cleanup_(table_unrefp) Table *table = NULL;
TableCell *cell;
struct server_state {
const char *server_name;
const char *type;
const char *ifname;
int ifindex;
const char *verified_feature_level;
const char *possible_feature_level;
const char *dnssec_mode;
bool dnssec_supported;
size_t received_udp_fragment_max;
uint64_t n_failed_udp;
uint64_t n_failed_tcp;
bool packet_truncated;
bool packet_bad_opt;
bool packet_rrsig_missing;
bool packet_invalid;
bool packet_do_off;
} server_state = {
.ifindex = -1,
};
int r;
static const sd_json_dispatch_field dispatch_table[] = {
{ "Server", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, server_name), SD_JSON_MANDATORY },
{ "Type", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, type), SD_JSON_MANDATORY },
{ "Interface", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, ifname), 0 },
{ "InterfaceIndex", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_ifindex, offsetof(struct server_state, ifindex), SD_JSON_RELAX },
{ "VerifiedFeatureLevel", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, verified_feature_level), 0 },
{ "PossibleFeatureLevel", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, possible_feature_level), 0 },
{ "DNSSECMode", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, dnssec_mode), SD_JSON_MANDATORY },
{ "DNSSECSupported", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, dnssec_supported), SD_JSON_MANDATORY },
{ "ReceivedUDPFragmentMax", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, received_udp_fragment_max), SD_JSON_MANDATORY },
{ "FailedUDPAttempts", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, n_failed_udp), SD_JSON_MANDATORY },
{ "FailedTCPAttempts", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, n_failed_tcp), SD_JSON_MANDATORY },
{ "PacketTruncated", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_truncated), SD_JSON_MANDATORY },
{ "PacketBadOpt", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_bad_opt), SD_JSON_MANDATORY },
{ "PacketRRSIGMissing", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_rrsig_missing), SD_JSON_MANDATORY },
{ "PacketInvalid", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_invalid), SD_JSON_MANDATORY },
{ "PacketDoOff", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_do_off), SD_JSON_MANDATORY },
{},
};
r = sd_json_dispatch(server, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &server_state);
if (r < 0)
return r;
table = table_new_vertical();
if (!table)
return log_oom();
assert_se(cell = table_get_cell(table, 0, 0));
(void) table_set_ellipsize_percent(table, cell, 100);
(void) table_set_align_percent(table, cell, 0);
r = table_add_cell_stringf(table, NULL, "Server: %s", server_state.server_name);
if (r < 0)
return table_log_add_error(r);
r = table_add_many(table,
TABLE_EMPTY,
TABLE_FIELD, "Type",
TABLE_SET_ALIGN_PERCENT, 100,
TABLE_STRING, server_state.type);
if (r < 0)
return table_log_add_error(r);
if (server_state.ifname) {
r = table_add_many(table,
TABLE_FIELD, "Interface",
TABLE_STRING, server_state.ifname);
if (r < 0)
return table_log_add_error(r);
}
if (server_state.ifindex >= 0) {
r = table_add_many(table,
TABLE_FIELD, "Interface Index",
TABLE_INT, server_state.ifindex);
if (r < 0)
return table_log_add_error(r);
}
if (server_state.verified_feature_level) {
r = table_add_many(table,
TABLE_FIELD, "Verified feature level",
TABLE_STRING, server_state.verified_feature_level);
if (r < 0)
return table_log_add_error(r);
}
if (server_state.possible_feature_level) {
r = table_add_many(table,
TABLE_FIELD, "Possible feature level",
TABLE_STRING, server_state.possible_feature_level);
if (r < 0)
return table_log_add_error(r);
}
r = table_add_many(table,
TABLE_FIELD, "DNSSEC Mode",
TABLE_STRING, server_state.dnssec_mode,
TABLE_FIELD, "DNSSEC Supported",
TABLE_STRING, yes_no(server_state.dnssec_supported),
TABLE_FIELD, "Maximum UDP fragment size received",
TABLE_UINT64, server_state.received_udp_fragment_max,
TABLE_FIELD, "Failed UDP attempts",
TABLE_UINT64, server_state.n_failed_udp,
TABLE_FIELD, "Failed TCP attempts",
TABLE_UINT64, server_state.n_failed_tcp,
TABLE_FIELD, "Seen truncated packet",
TABLE_STRING, yes_no(server_state.packet_truncated),
TABLE_FIELD, "Seen OPT RR getting lost",
TABLE_STRING, yes_no(server_state.packet_bad_opt),
TABLE_FIELD, "Seen RRSIG RR missing",
TABLE_STRING, yes_no(server_state.packet_rrsig_missing),
TABLE_FIELD, "Seen invalid packet",
TABLE_STRING, yes_no(server_state.packet_invalid),
TABLE_FIELD, "Server dropped DO flag",
TABLE_STRING, yes_no(server_state.packet_do_off),
TABLE_SET_ALIGN_PERCENT, 0,
TABLE_EMPTY, TABLE_EMPTY);
if (r < 0)
return table_log_add_error(r);
return table_print_or_warn(table);
}
VERB(verb_show_server_state, "show-server-state", NULL, VERB_ANY, 1, 0,
"Show servers state");
static int verb_show_server_state(int argc, char *argv[], uintptr_t _data, void *userdata) {
sd_json_variant *reply = NULL, *d = NULL;
_cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
int r;
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve.Monitor");
if (r < 0)
return log_error_errno(r, "Failed to connect to query monitoring service /run/systemd/resolve/io.systemd.Resolve.Monitor: %m");
r = varlink_callbo_and_log(
vl,
"io.systemd.Resolve.Monitor.DumpServerState",
&reply,
SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", arg_ask_password));
if (r < 0)
return r;
d = sd_json_variant_by_key(reply, "dump");
if (!d)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"DumpCache() response is missing 'dump' key.");
if (!sd_json_variant_is_array(d))
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"DumpCache() response 'dump' field not an array");
if (!sd_json_format_enabled(arg_json_format_flags)) {
sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, d) {
r = dump_server_state(i);
if (r < 0)
return r;
}
return 0;
}
return sd_json_variant_dump(d, arg_json_format_flags, NULL, NULL);
}
VERB(verb_dns, "dns", "[LINK [SERVER…]]\0", VERB_ANY, VERB_ANY, 0,
"Get/set per-interface DNS server address");
static int verb_dns(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
return r;
}
if (arg_ifindex <= 0)
return status_all(STATUS_DNS);
if (argc < 3)
return status_ifindex(arg_ifindex, STATUS_DNS);
char **args = strv_skip(argv, 2);
r = call_dns(bus, args, bus_resolve_mgr, &error, true);
if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
sd_bus_error_free(&error);
r = call_dns(bus, args, bus_network_mgr, &error, true);
}
if (r < 0) {
if (arg_ifindex_permissive &&
sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
return 0;
return log_error_errno(r, "Failed to set DNS configuration: %s", bus_error_message(&error, r));
}
return 0;
}
static int call_domain(sd_bus *bus, char **domain, const BusLocator *locator, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL;
int r;
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = bus_message_new_method_call(bus, &req, locator, "SetLinkDomains");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(req, "i", arg_ifindex);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_open_container(req, 'a', "(sb)");
if (r < 0)
return bus_log_create_error(r);
/* If only argument is the empty string, then call SetLinkDomains() with an
* empty list, which will clear the list of domains for an interface. */
if (!strv_equal(domain, STRV_MAKE("")))
STRV_FOREACH(p, domain) {
const char *n;
n = **p == '~' ? *p + 1 : *p;
r = dns_name_is_valid(n);
if (r < 0)
return log_error_errno(r, "Failed to validate specified domain %s: %m", n);
if (r == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Domain not valid: %s",
n);
r = sd_bus_message_append(req, "(sb)", n, **p == '~');
if (r < 0)
return bus_log_create_error(r);
}
r = sd_bus_message_close_container(req);
if (r < 0)
return bus_log_create_error(r);
return sd_bus_call(bus, req, 0, error, NULL);
}
VERB(verb_domain, "domain", "[LINK [DOMAIN…]]\0", VERB_ANY, VERB_ANY, 0,
"Get/set per-interface search domain");
static int verb_domain(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
return r;
}
if (arg_ifindex <= 0)
return status_all(STATUS_DOMAIN);
if (argc < 3)
return status_ifindex(arg_ifindex, STATUS_DOMAIN);
char **args = strv_skip(argv, 2);
r = call_domain(bus, args, bus_resolve_mgr, &error);
if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
sd_bus_error_free(&error);
r = call_domain(bus, args, bus_network_mgr, &error);
}
if (r < 0) {
if (arg_ifindex_permissive &&
sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
return 0;
return log_error_errno(r, "Failed to set domain configuration: %s", bus_error_message(&error, r));
}
return 0;
}
VERB(verb_default_route, "default-route", "[LINK [BOOL]]\0", VERB_ANY, 3, 0,
"Get/set per-interface default route flag");
static int verb_default_route(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r, b;
r = acquire_bus(&bus);
if (r < 0)
return r;
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
return r;
}
if (arg_ifindex <= 0)
return status_all(STATUS_DEFAULT_ROUTE);
if (argc < 3)
return status_ifindex(arg_ifindex, STATUS_DEFAULT_ROUTE);
b = parse_boolean(argv[2]);
if (b < 0)
return log_error_errno(b, "Failed to parse boolean argument: %s", argv[2]);
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = bus_call_method(bus, bus_resolve_mgr, "SetLinkDefaultRoute", &error, NULL, "ib", arg_ifindex, b);
if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
sd_bus_error_free(&error);
r = bus_call_method(bus, bus_network_mgr, "SetLinkDefaultRoute", &error, NULL, "ib", arg_ifindex, b);
}
if (r < 0) {
if (arg_ifindex_permissive &&
sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
return 0;
return log_error_errno(r, "Failed to set default route configuration: %s", bus_error_message(&error, r));
}
return 0;
}
VERB(verb_llmnr, "llmnr", "[LINK [MODE]]\0", VERB_ANY, 3, 0,
"Get/set per-interface LLMNR mode");
static int verb_llmnr(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *global_llmnr_support_str = NULL;
ResolveSupport global_llmnr_support, llmnr_support;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
return r;
}
if (arg_ifindex <= 0)
return status_all(STATUS_LLMNR);
if (argc < 3)
return status_ifindex(arg_ifindex, STATUS_LLMNR);
llmnr_support = resolve_support_from_string(argv[2]);
if (llmnr_support < 0)
return log_error_errno(llmnr_support, "Invalid LLMNR setting: %s", argv[2]);
r = bus_get_property_string(bus, bus_resolve_mgr, "LLMNR", &error, &global_llmnr_support_str);
if (r < 0)
return log_error_errno(r, "Failed to get the global LLMNR support state: %s", bus_error_message(&error, r));
global_llmnr_support = resolve_support_from_string(global_llmnr_support_str);
if (global_llmnr_support < 0)
return log_error_errno(global_llmnr_support, "Received invalid global LLMNR setting: %s", global_llmnr_support_str);
if (global_llmnr_support < llmnr_support)
log_warning("Setting LLMNR support level \"%s\" for \"%s\", but the global support level is \"%s\".",
argv[2], arg_ifname, global_llmnr_support_str);
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = bus_call_method(bus, bus_resolve_mgr, "SetLinkLLMNR", &error, NULL, "is", arg_ifindex, argv[2]);
if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
sd_bus_error_free(&error);
r = bus_call_method(bus, bus_network_mgr, "SetLinkLLMNR", &error, NULL, "is", arg_ifindex, argv[2]);
}
if (r < 0) {
if (arg_ifindex_permissive &&
sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
return 0;
return log_error_errno(r, "Failed to set LLMNR configuration: %s", bus_error_message(&error, r));
}
return 0;
}
VERB(verb_mdns, "mdns", "[LINK [MODE]]\0", VERB_ANY, 3, 0,
"Get/set per-interface MulticastDNS mode");
static int verb_mdns(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *global_mdns_support_str = NULL;
ResolveSupport global_mdns_support, mdns_support;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
return r;
}
if (arg_ifindex <= 0)
return status_all(STATUS_MDNS);
if (argc < 3)
return status_ifindex(arg_ifindex, STATUS_MDNS);
mdns_support = resolve_support_from_string(argv[2]);
if (mdns_support < 0)
return log_error_errno(mdns_support, "Invalid mDNS setting: %s", argv[2]);
r = bus_get_property_string(bus, bus_resolve_mgr, "MulticastDNS", &error, &global_mdns_support_str);
if (r < 0)
return log_error_errno(r, "Failed to get the global mDNS support state: %s", bus_error_message(&error, r));
global_mdns_support = resolve_support_from_string(global_mdns_support_str);
if (global_mdns_support < 0)
return log_error_errno(global_mdns_support, "Received invalid global mDNS setting: %s", global_mdns_support_str);
if (global_mdns_support < mdns_support)
log_warning("Setting mDNS support level \"%s\" for \"%s\", but the global support level is \"%s\".",
argv[2], arg_ifname, global_mdns_support_str);
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = bus_call_method(bus, bus_resolve_mgr, "SetLinkMulticastDNS", &error, NULL, "is", arg_ifindex, argv[2]);
if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
sd_bus_error_free(&error);
r = bus_call_method(
bus,
bus_network_mgr,
"SetLinkMulticastDNS",
&error,
NULL,
"is", arg_ifindex, argv[2]);
}
if (r < 0) {
if (arg_ifindex_permissive &&
sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))
return 0;
return log_error_errno(r, "Failed to set MulticastDNS configuration: %s", bus_error_message(&error, r));
}
return 0;
}
VERB(verb_dns_over_tls, "dnsovertls", "[LINK [MODE]]\0", VERB_ANY, 3, 0,
"Get/set per-interface DNS-over-TLS mode");
static int verb_dns_over_tls(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
return r;
}
if (arg_ifindex <= 0)
return status_all(STATUS_DNS_OVER_TLS);
if (argc < 3)
return status_ifindex(arg_ifindex, STATUS_DNS_OVER_TLS);
(void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
r = bus_call_method(bus, bus_resolve_mgr, "SetLinkDNSOverTLS", &error, NULL, "is", arg_ifindex, argv[2]);
if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_LINK_BUSY)) {
sd_bus_error_free(&error);
r = bus_call_method(
bus,
bus_network_mgr,
"SetLinkDNSOverTLS",
&error,
NULL,
"is", arg_ifindex, argv[2]);
}
if (r < 0) {
if (arg_ifindex_permissive &&
sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_LINK))