HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/resolvectl.c

155,789 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 149f229a7d7186a95b4a8379de226d95331c4a92

Lines 3001–3869 of 3,869

                        return 0;
 
                return log_error_errno(r, "Failed to set DNSOverTLS configuration: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB(verb_dnssec, "dnssec", "[LINK [MODE]]\0", VERB_ANY, 3, 0,
     "Get/set per-interface DNSSEC mode");
static int verb_dnssec(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_DNSSEC);
 
        if (argc < 3)
                return status_ifindex(arg_ifindex, STATUS_DNSSEC);
 
        (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
 
        r = bus_call_method(bus, bus_resolve_mgr, "SetLinkDNSSEC", &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, "SetLinkDNSSEC", &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 DNSSEC configuration: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
static int call_nta(sd_bus *bus, char **nta, 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, "SetLinkDNSSECNegativeTrustAnchors");
        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_append_strv(req, nta);
        if (r < 0)
                return bus_log_create_error(r);
 
        return sd_bus_call(bus, req, 0, error, NULL);
}
 
VERB(verb_nta, "nta", "[LINK [DOMAIN…]]\0", VERB_ANY, VERB_ANY, 0,
     "Get/set per-interface DNSSEC NTA");
static int verb_nta(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;
        char **args;
        bool clear;
        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_NTA);
 
        if (argc < 3)
                return status_ifindex(arg_ifindex, STATUS_NTA);
 
        (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
 
        /* If only argument is the empty string, then call SetLinkDNSSECNegativeTrustAnchors()
         * with an empty list, which will clear the list of domains for an interface. */
        args = strv_skip(argv, 2);
        clear = strv_equal(args, STRV_MAKE(""));
 
        if (!clear)
                STRV_FOREACH(p, args) {
                        r = dns_name_is_valid(*p);
                        if (r < 0)
                                return log_error_errno(r, "Failed to validate specified domain %s: %m", *p);
                        if (r == 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Domain not valid: %s",
                                                       *p);
                }
 
        r = call_nta(bus, clear ? NULL : 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_nta(bus, clear ? NULL : 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 DNSSEC NTA configuration: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB(verb_revert_link, "revert", "LINK\0", VERB_ANY, 2, 0,
     "Revert per-interface configuration");
static int verb_revert_link(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 log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Interface argument required.");
 
        (void) polkit_agent_open_if_enabled(BUS_TRANSPORT_LOCAL, arg_ask_password);
 
        r = bus_call_method(bus, bus_resolve_mgr, "RevertLink", &error, NULL, "i", arg_ifindex);
        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, "RevertLinkDNS", &error, NULL, "i", arg_ifindex);
        }
        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 revert interface configuration: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB(verb_log_level, "log-level", "[LEVEL]\0", VERB_ANY, 2, 0,
     "Get/set logging threshold for systemd-resolved");
static int verb_log_level(int argc, char *argv[], uintptr_t _data, void *userdata) {
        int r;
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
        r = sd_varlink_connect_address(&vl, "/run/systemd/resolve/io.systemd.Resolve");
        if (r < 0)
                return log_error_errno(r, "Failed to connect to /run/systemd/resolve/io.systemd.Resolve: %m");
 
        if (argc == 1) {
                /* Show current log level */
                _cleanup_free_ char *level_str = NULL;
                r = varlink_get_log_level_string(vl, &level_str);
                if (r < 0)
                        return r;
 
                puts(level_str);
 
        } else if (argc == 2) {
                /* Set new log level */
                r = varlink_set_log_level_string(vl, argv[1]);
                if (r < 0)
                        return r;
        } else
                assert_not_reached();
 
        return 0;
}
 
static int parse_protocol(const char *arg) {
        if (streq(arg, "help")) {
                if (arg_legend)
                        puts("Known protocol types:");
                puts("dns\n"
                     "llmnr\n"
                     "llmnr-ipv4\n"
                     "llmnr-ipv6\n"
                     "mdns\n"
                     "mdns-ipv4\n"
                     "mdns-ipv6");
                return 0;
        }
 
        if (streq(arg, "dns"))
                arg_flags |= SD_RESOLVED_DNS;
        else if (streq(arg, "llmnr"))
                arg_flags |= SD_RESOLVED_LLMNR;
        else if (streq(arg, "llmnr-ipv4"))
                arg_flags |= SD_RESOLVED_LLMNR_IPV4;
        else if (streq(arg, "llmnr-ipv6"))
                arg_flags |= SD_RESOLVED_LLMNR_IPV6;
        else if (streq(arg, "mdns"))
                arg_flags |= SD_RESOLVED_MDNS;
        else if (streq(arg, "mdns-ipv4"))
                arg_flags |= SD_RESOLVED_MDNS_IPV4;
        else if (streq(arg, "mdns-ipv6"))
                arg_flags |= SD_RESOLVED_MDNS_IPV6;
        else
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Unknown protocol specifier: %s", arg);
        return 1;
}
 
static void help_dns_types(void) {
        if (arg_legend)
                puts("Known DNS RR types:");
 
        DUMP_STRING_TABLE(dns_type, int, _DNS_TYPE_MAX);
}
 
static void help_dns_classes(void) {
        if (arg_legend)
                puts("Known DNS RR classes:");
 
        DUMP_STRING_TABLE(dns_class, int, _DNS_CLASS_MAX);
}
 
VERB_COMMON_HELP_AUTO_PROGRAM_HIDDEN("resolvectl");
 
COMMAND(
        "systemd-resolve\0",
        "This command is deprecated. Use resolvectl.1 instead.",
        .man_pages = "resolvectl(1)\0",
        .option_namespace = "systemd-resolve",
        .pager_flags = &arg_pager_flags,
);
 
static int compat_parse_argv(int argc, char *argv[], char ***remaining_args) {
        int r;
 
        assert(argc >= 0);
        assert(argv);
        assert(remaining_args);
 
        OptionParser opts = { argc, argv, .namespace = "systemd-resolve" };
 
        FOREACH_OPTION_OR_RETURN(c, &opts)
                switch (c) {
 
                OPTION_NAMESPACE("systemd-resolve"): {}
 
                OPTION_COMMON_HELP:
                        printf("systemd-resolve is deprecated. Call resolvectl instead.\n");
                        return 0;
 
                OPTION_COMMON_VERSION:
                        return version();
 
                OPTION_SHORT('4', NULL, "Resolve IPv4 addresses"):
                        arg_family = AF_INET;
                        break;
 
                OPTION_SHORT('6', NULL, "Resolve IPv6 addresses"):
                        arg_family = AF_INET6;
                        break;
 
                OPTION('i', "interface", "INTERFACE", "Look on interface"):
                        r = ifname_mangle(opts.arg);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION('p', "protocol", "PROTO|help", "Look via protocol"):
                        r = parse_protocol(opts.arg);
                        if (r <= 0)
                                return r;
                        break;
 
                OPTION('t', "type", "TYPE|help", "Query RR with DNS type"):
                        if (streq(opts.arg, "help")) {
                                help_dns_types();
                                return 0;
                        }
 
                        r = dns_type_from_string(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse RR record type %s: %m", opts.arg);
 
                        arg_type = (uint16_t) r;
                        assert((int) arg_type == r);
 
                        arg_mode = MODE_RESOLVE_RECORD;
                        break;
 
                OPTION('c', "class", "CLASS|help", "Query RR with DNS class"):
                        if (streq(opts.arg, "help")) {
                                help_dns_classes();
                                return 0;
                        }
 
                        r = dns_class_from_string(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse RR record class %s: %m", opts.arg);
 
                        arg_class = (uint16_t) r;
                        assert((int) arg_class == r);
 
                        break;
 
                OPTION_LONG("service", NULL, "Resolve service (SRV)"):
                        arg_mode = MODE_RESOLVE_SERVICE;
                        break;
 
                OPTION_LONG("service-address", "BOOL", "Resolve address for services (default: yes)"):
                        r = parse_boolean_argument("--service-address=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_ADDRESS, r == 0);
                        break;
 
                OPTION_LONG("service-txt", "BOOL", "Resolve TXT records for services (default: yes)"):
                        r = parse_boolean_argument("--service-txt=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_TXT, r == 0);
                        arg_service_txt_set = true;
                        break;
 
                OPTION_LONG("openpgp", NULL, "Query OpenPGP public key"):
                        arg_mode = MODE_RESOLVE_OPENPGP;
                        break;
 
                OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "tlsa", "FAMILY", "Query TLS public key"):
                        arg_mode = MODE_RESOLVE_TLSA;
                        if (!opts.arg || service_family_is_valid(opts.arg))
                                arg_service_family = opts.arg;
                        else
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Unknown service family \"%s\".", opts.arg);
                        break;
 
                OPTION_LONG("cname", "BOOL", "Follow CNAME redirects (default: yes)"):
                        r = parse_boolean_argument("--cname=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_CNAME, r == 0);
                        break;
 
                OPTION_LONG("search", "BOOL", "Use search domains for single-label names (default: yes)"):
                        r = parse_boolean_argument("--search=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_SEARCH, r == 0);
                        break;
 
                OPTION_LONG("statistics", NULL, "Show resolver statistics"):
                        arg_mode = MODE_STATISTICS;
                        break;
 
                OPTION_LONG("reset-statistics", NULL, "Reset resolver statistics"):
                        arg_mode = MODE_RESET_STATISTICS;
                        break;
 
                OPTION_LONG("status", NULL, "Show link and server status"):
                        arg_mode = MODE_STATUS;
                        break;
 
                OPTION_LONG("flush-caches", NULL, "Flush all local DNS caches"):
                        arg_mode = MODE_FLUSH_CACHES;
                        break;
 
                OPTION_LONG("reset-server-features", NULL,
                            "Forget learnt DNS server feature levels"):
                        arg_mode = MODE_RESET_SERVER_FEATURES;
                        break;
 
                OPTION_LONG("set-dns", "SERVER", "Set per-interface DNS server address"):
                        r = strv_extend(&arg_set_dns, opts.arg);
                        if (r < 0)
                                return log_oom();
 
                        arg_mode = MODE_SET_LINK;
                        break;
 
                OPTION_LONG("set-domain", "DOMAIN", "Set per-interface search domain"):
                        r = strv_extend(&arg_set_domain, opts.arg);
                        if (r < 0)
                                return log_oom();
 
                        arg_mode = MODE_SET_LINK;
                        break;
 
                OPTION_LONG("set-llmnr", "MODE", "Set per-interface LLMNR mode"):
                        arg_set_llmnr = opts.arg;
                        arg_mode = MODE_SET_LINK;
                        break;
 
                OPTION_LONG("set-mdns", "MODE", "Set per-interface MulticastDNS mode"):
                        arg_set_mdns = opts.arg;
                        arg_mode = MODE_SET_LINK;
                        break;
 
                OPTION_LONG("set-dnsovertls", "MODE", "Set per-interface DNS-over-TLS mode"):
                        arg_set_dns_over_tls = opts.arg;
                        arg_mode = MODE_SET_LINK;
                        break;
 
                OPTION_LONG("set-dnssec", "MODE", "Set per-interface DNSSEC mode"):
                        arg_set_dnssec = opts.arg;
                        arg_mode = MODE_SET_LINK;
                        break;
 
                OPTION_LONG("set-nta", "DOMAIN", "Set per-interface DNSSEC NTA"):
                        r = strv_extend(&arg_set_nta, opts.arg);
                        if (r < 0)
                                return log_oom();
 
                        arg_mode = MODE_SET_LINK;
                        break;
 
                OPTION_LONG("revert", NULL, "Revert per-interface configuration"):
                        arg_mode = MODE_REVERT_LINK;
                        break;
 
                OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "raw", "payload|packet",
                                  "Dump the answer as binary data"):
                        if (on_tty())
                                return log_error_errno(SYNTHETIC_ERRNO(ENOTTY),
                                                       "Refusing to write binary data to tty.");
 
                        if (opts.arg == NULL || streq(opts.arg, "payload"))
                                arg_raw = RAW_PAYLOAD;
                        else if (streq(opts.arg, "packet"))
                                arg_raw = RAW_PACKET;
                        else
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Unknown --raw specifier \"%s\".",
                                                       opts.arg);
 
                        arg_legend = false;
                        break;
 
                OPTION_COMMON_NO_PAGER:
                        arg_pager_flags |= PAGER_DISABLE;
                        break;
 
                OPTION_LONG("legend", "BOOL", "Print headers and additional info (default: yes)"):
                        r = parse_boolean_argument("--legend=", opts.arg, &arg_legend);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_COMMON_INTROSPECT_CLI:
                        return introspect_cli(arg_json_format_flags);
                }
 
        if (arg_type == 0 && arg_class != 0)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "--class= may only be used in conjunction with --type=.");
 
        if (arg_type != 0 && arg_mode == MODE_RESOLVE_SERVICE)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "--service and --type= may not be combined.");
 
        if (arg_type != 0 && arg_class == 0)
                arg_class = DNS_CLASS_IN;
 
        if (arg_class != 0 && arg_type == 0)
                arg_type = DNS_TYPE_A;
 
        if (IN_SET(arg_mode, MODE_SET_LINK, MODE_REVERT_LINK)) {
 
                if (arg_ifindex <= 0)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "--set-dns=, --set-domain=, --set-llmnr=, --set-mdns=, --set-dnsovertls=, --set-dnssec=, --set-nta= and --revert require --interface=.");
        }
 
        *remaining_args = option_parser_get_args(&opts);
        return 1 /* work to do */;
}
 
static int native_parse_argv(int argc, char *argv[], char ***remaining_args) {
        int r;
 
        assert(argc >= 0);
        assert(argv);
        assert(remaining_args);
 
        OptionParser opts = { argc, argv, .namespace = "resolvectl" };
 
        FOREACH_OPTION_OR_RETURN(c, &opts)
                switch (c) {
 
                OPTION_NAMESPACE("resolvectl"): {}
 
                OPTION_COMMON_HELP:
                        return command_print_help_name("resolvectl");
 
                OPTION_COMMON_VERSION:
                        return version();
 
                OPTION_SHORT('4', NULL, "Resolve IPv4 addresses"):
                        arg_family = AF_INET;
                        break;
 
                OPTION_SHORT('6', NULL, "Resolve IPv6 addresses"):
                        arg_family = AF_INET6;
                        break;
 
                OPTION('i', "interface", "INTERFACE", "Look on interface"):
                        r = ifname_mangle(opts.arg);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION('p', "protocol", "PROTO|help", "Look via protocol"):
                        r = parse_protocol(opts.arg);
                        if (r <= 0)
                                return r;
                        break;
 
                OPTION('t', "type", "TYPE|help", "Query RR with DNS type"):
                        if (streq(opts.arg, "help")) {
                                help_dns_types();
                                return 0;
                        }
 
                        r = dns_type_from_string(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse RR record type %s: %m", opts.arg);
 
                        arg_type = (uint16_t) r;
                        assert((int) arg_type == r);
 
                        break;
 
                OPTION('c', "class", "CLASS|help", "Query RR with DNS class"):
                        if (streq(opts.arg, "help")) {
                                help_dns_classes();
                                return 0;
                        }
 
                        r = dns_class_from_string(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse RR record class %s: %m", opts.arg);
 
                        arg_class = (uint16_t) r;
                        assert((int) arg_class == r);
 
                        break;
 
                OPTION_LONG("service-address", "BOOL", "Resolve address for services (default: yes)"):
                        r = parse_boolean_argument("--service-address=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_ADDRESS, r == 0);
                        break;
 
                OPTION_LONG("service-txt", "BOOL", "Resolve TXT records for services (default: yes)"):
                        r = parse_boolean_argument("--service-txt=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_TXT, r == 0);
                        arg_service_txt_set = true;
                        break;
 
                OPTION_LONG("cname", "BOOL", "Follow CNAME redirects (default: yes)"):
                        r = parse_boolean_argument("--cname=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_CNAME, r == 0);
                        break;
 
                OPTION_LONG("validate", "BOOL", "Allow DNSSEC validation (default: yes)"):
                        r = parse_boolean_argument("--validate=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_VALIDATE, r == 0);
                        break;
 
                OPTION_LONG("synthesize", "BOOL", "Allow synthetic response (default: yes)"):
                        r = parse_boolean_argument("--synthesize=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_SYNTHESIZE, r == 0);
                        break;
 
                OPTION_LONG("cache", "BOOL", "Allow response from cache (default: yes)"):
                        r = parse_boolean_argument("--cache=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_CACHE, r == 0);
                        break;
 
                OPTION_LONG("stale-data", "BOOL",
                            "Allow response from cache with stale data (default: yes)"):
                        r = parse_boolean_argument("--stale-data=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_STALE, r == 0);
                        break;
 
                OPTION_LONG("relax-single-label", "BOOL",
                            "Allow single label lookups to go upstream (default: no)"):
                        r = parse_boolean_argument("--relax-single-label=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_RELAX_SINGLE_LABEL, r > 0);
                        break;
 
                OPTION_LONG("zone", "BOOL",
                            "Allow response from locally registered mDNS/LLMNR records (default: yes)"):
                        r = parse_boolean_argument("--zone=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_ZONE, r == 0);
                        break;
 
                OPTION_LONG("trust-anchor", "BOOL",
                            "Allow response from local trust anchor (default: yes)"):
                        r = parse_boolean_argument("--trust-anchor=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_TRUST_ANCHOR, r == 0);
                        break;
 
                OPTION_LONG("network", "BOOL", "Allow response from network (default: yes)"):
                        r = parse_boolean_argument("--network=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_NETWORK, r == 0);
                        break;
 
                OPTION_LONG("search", "BOOL", "Use search domains for single-label names (default: yes)"):
                        r = parse_boolean_argument("--search=", opts.arg, NULL);
                        if (r < 0)
                                return r;
                        SET_FLAG(arg_flags, SD_RESOLVED_NO_SEARCH, r == 0);
                        break;
 
                OPTION_LONG_FLAGS(OPTION_OPTIONAL_ARG, "raw", "payload|packet",
                                  "Dump the answer as binary data"):
                        if (on_tty())
                                return log_error_errno(SYNTHETIC_ERRNO(ENOTTY),
                                                       "Refusing to write binary data to tty.");
 
                        if (opts.arg == NULL || streq(opts.arg, "payload"))
                                arg_raw = RAW_PAYLOAD;
                        else if (streq(opts.arg, "packet"))
                                arg_raw = RAW_PACKET;
                        else
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Unknown --raw specifier \"%s\".",
                                                       opts.arg);
 
                        arg_legend = false;
                        break;
 
                OPTION_COMMON_NO_PAGER:
                        arg_pager_flags |= PAGER_DISABLE;
                        break;
 
                OPTION_COMMON_NO_ASK_PASSWORD:
                        arg_ask_password = false;
                        break;
 
                OPTION_LONG("legend", "BOOL", "Print headers and additional info (default: yes)"):
                        r = parse_boolean_argument("--legend=", opts.arg, &arg_legend);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_COMMON_JSON:
                        r = parse_json_argument(opts.arg, &arg_json_format_flags);
                        if (r <= 0)
                                return r;
                        break;
 
                OPTION_COMMON_LOWERCASE_J:
                        arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
                        break;
 
                OPTION_COMMON_INTROSPECT_CLI:
                        return introspect_cli(arg_json_format_flags);
                }
 
        if (arg_raw != RAW_NONE && sd_json_format_enabled(arg_json_format_flags))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--raw and --json= may not be combined.");
 
        if (arg_type == 0 && arg_class != 0)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "--class= may only be used in conjunction with --type=.");
 
        if (arg_type != 0 && arg_class == 0)
                arg_class = DNS_CLASS_IN;
 
        if (arg_class != 0 && arg_type == 0)
                arg_type = DNS_TYPE_A;
 
        *remaining_args = option_parser_get_args(&opts);
        return 1 /* work to do */;
}
 
static int translate(const char *verb, const char *single_arg, char **args) {
        char **fake, **p;
        size_t num;
 
        assert(verb);
 
        num = !!single_arg + strv_length(args) + 1;
 
        p = fake = newa0(char *, num + 1);
        *p++ = (char *) verb;
        if (single_arg)
                *p++ = (char *) single_arg;
        STRV_FOREACH(a, args)
                *p++ = *a;
 
        return dispatch_verb(fake, /* userdata= */ NULL);
}
 
static int compat_main(char **args) {
        int r = 0;
 
        switch (arg_mode) {
        case MODE_RESOLVE_HOST:
        case MODE_RESOLVE_RECORD:
                return translate("query", NULL, args);
 
        case MODE_RESOLVE_SERVICE:
                return translate("service", NULL, args);
 
        case MODE_RESOLVE_OPENPGP:
                return translate("openpgp", NULL, args);
 
        case MODE_RESOLVE_TLSA:
                return translate("tlsa", arg_service_family, args);
 
        case MODE_STATISTICS:
                return translate("statistics", NULL, NULL);
 
        case MODE_RESET_STATISTICS:
                return translate("reset-statistics", NULL, NULL);
 
        case MODE_FLUSH_CACHES:
                return translate("flush-caches", NULL, NULL);
 
        case MODE_RESET_SERVER_FEATURES:
                return translate("reset-server-features", NULL, NULL);
 
        case MODE_STATUS:
                return translate("status", NULL, args);
 
        case MODE_SET_LINK:
                assert(arg_ifname);
 
                if (arg_disable_default_route) {
                        r = translate("default-route", arg_ifname, STRV_MAKE("no"));
                        if (r < 0)
                                return r;
                }
 
                if (arg_set_dns) {
                        r = translate("dns", arg_ifname, arg_set_dns);
                        if (r < 0)
                                return r;
                }
 
                if (arg_set_domain) {
                        r = translate("domain", arg_ifname, arg_set_domain);
                        if (r < 0)
                                return r;
                }
 
                if (arg_set_nta) {
                        r = translate("nta", arg_ifname, arg_set_nta);
                        if (r < 0)
                                return r;
                }
 
                if (arg_set_llmnr) {
                        r = translate("llmnr", arg_ifname, STRV_MAKE(arg_set_llmnr));
                        if (r < 0)
                                return r;
                }
 
                if (arg_set_mdns) {
                        r = translate("mdns", arg_ifname, STRV_MAKE(arg_set_mdns));
                        if (r < 0)
                                return r;
                }
 
                if (arg_set_dns_over_tls) {
                        r = translate("dnsovertls", arg_ifname, STRV_MAKE(arg_set_dns_over_tls));
                        if (r < 0)
                                return r;
                }
 
                if (arg_set_dnssec) {
                        r = translate("dnssec", arg_ifname, STRV_MAKE(arg_set_dnssec));
                        if (r < 0)
                                return r;
                }
 
                return r;
 
        case MODE_REVERT_LINK:
                assert(arg_ifname);
 
                return translate("revert", arg_ifname, NULL);
 
        case _MODE_INVALID:
                assert_not_reached();
        }
 
        return 0;
}
 
static int run(int argc, char **argv) {
        char **args = NULL;
        bool compat = false;
        int r;
 
        LIBCRYPTO_NOTE(suggested);
        LIBIDN2_NOTE(recommended);
 
        setlocale(LC_ALL, "");
        log_setup();
 
        if (invoked_as(argv, "resolvconf")) {
                compat = true;
                r = resolvconf_parse_argv(argc, argv);
        } else if (invoked_as(argv, "systemd-resolve")) {
                compat = true;
                r = compat_parse_argv(argc, argv, &args);
        } else
                r = native_parse_argv(argc, argv, &args);
        if (r <= 0)
                return r;
 
        if (compat)
                return compat_main(args);
 
        return dispatch_verb(args, /* userdata= */ NULL);
}
 
DEFINE_MAIN_FUNCTION(run);