自学教程：C++ strna函数代码示例

static int merge_env_file_push(                const char *filename, unsigned line,                const char *key, char *value,                void *userdata,                int *n_pushed) {        char ***env = userdata;        char *expanded_value;        assert(env);        if (!value) {                log_error("%s:%u: invalid syntax (around /"%s/"), ignoring.", strna(filename), line, key);                return 0;        }        if (!env_name_is_valid(key)) {                log_error("%s:%u: invalid variable name /"%s/", ignoring.", strna(filename), line, key);                free(value);                return 0;        }        expanded_value = replace_env(value, *env,                                     REPLACE_ENV_USE_ENVIRONMENT|                                     REPLACE_ENV_ALLOW_BRACELESS|                                     REPLACE_ENV_ALLOW_EXTENDED);        if (!expanded_value)                return -ENOMEM;        free_and_replace(value, expanded_value);        return load_env_file_push(filename, line, key, value, env, n_pushed);}

static int load_env_file_push(                const char *filename, unsigned line,                const char *key, char *value,                void *userdata) {        char ***m = userdata;        char *p;        int r;        if (!utf8_is_valid(key)) {                _cleanup_free_ char *t = utf8_escape_invalid(key);                log_error("%s:%u: invalid UTF-8 for key '%s', ignoring.", strna(filename), line, t);                return -EINVAL;        }        if (value && !utf8_is_valid(value)) {                _cleanup_free_ char *t = utf8_escape_invalid(value);                log_error("%s:%u: invalid UTF-8 value for key %s: '%s', ignoring.", strna(filename), line, key, t);                return -EINVAL;        }        p = strjoin(key, "=", strempty(value), NULL);        if (!p)                return -ENOMEM;        r = strv_consume(m, p);        if (r < 0)                return r;        free(value);        return 0;}

static int add_root_mount(void) {        _cleanup_free_ char *what = NULL;        const char *opts;        if (isempty(arg_root_what)) {                log_debug("Could not find a root= entry on the kernel command line.");                return 0;        }        what = fstab_node_to_udev_node(arg_root_what);        if (!path_is_absolute(what)) {                log_debug("Skipping entry what=%s where=/sysroot type=%s", what, strna(arg_root_fstype));                return 0;        }        if (!arg_root_options)                opts = arg_root_rw > 0 ? "rw" : "ro";        else if (arg_root_rw >= 0 ||                 !fstab_test_option(arg_root_options, "ro/0" "rw/0"))                opts = strjoina(arg_root_options, ",", arg_root_rw > 0 ? "rw" : "ro");        else                opts = arg_root_options;        log_debug("Found entry what=%s where=/sysroot type=%s", what, strna(arg_root_fstype));        return add_mount(what,                         "/sysroot",                         arg_root_fstype,                         opts,                         1,                         false,                         false,                         false,                         SPECIAL_INITRD_ROOT_FS_TARGET,                         "/proc/cmdline");}

static void print_status_info(StatusInfo *i) {        assert(i);        if (strv_isempty(i->locale))                puts("   System Locale: n/a/n");        else {                char **j;                printf("   System Locale: %s/n", i->locale[0]);                STRV_FOREACH(j, i->locale + 1)                        printf("                  %s/n", *j);        }        printf("       VC Keymap: %s/n", strna(i->vconsole_keymap));        if (!isempty(i->vconsole_keymap_toggle))                printf("VC Toggle Keymap: %s/n", i->vconsole_keymap_toggle);        printf("      X11 Layout: %s/n", strna(i->x11_layout));        if (!isempty(i->x11_model))                printf("       X11 Model: %s/n", i->x11_model);        if (!isempty(i->x11_variant))                printf("     X11 Variant: %s/n", i->x11_variant);        if (!isempty(i->x11_options))                printf("     X11 Options: %s/n", i->x11_options);}

static void test_u_n_t_one(const char *name, const char *expected, int ret) {        _cleanup_free_ char *f = NULL;        assert_se(unit_name_template(name, &f) == ret);        printf("got: %s, expected: %s/n", strna(f), strna(expected));        assert_se(streq_ptr(f, expected));}

static void test_get_process_comm(pid_t pid) {        struct stat st;        _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;        _cleanup_free_ char *env = NULL;        char path[strlen("/proc//comm") + DECIMAL_STR_MAX(pid_t)];        pid_t e;        uid_t u;        gid_t g;        dev_t h;        int r;        xsprintf(path, "/proc/"PID_FMT"/comm", pid);        if (stat(path, &st) == 0) {                assert_se(get_process_comm(pid, &a) >= 0);                log_info("PID"PID_FMT" comm: '%s'", pid, a);        } else                log_warning("%s not exist.", path);        assert_se(get_process_cmdline(pid, 0, true, &c) >= 0);        log_info("PID"PID_FMT" cmdline: '%s'", pid, c);        assert_se(get_process_cmdline(pid, 8, false, &d) >= 0);        log_info("PID"PID_FMT" cmdline truncated to 8: '%s'", pid, d);        free(d);        assert_se(get_process_cmdline(pid, 1, false, &d) >= 0);        log_info("PID"PID_FMT" cmdline truncated to 1: '%s'", pid, d);        assert_se(get_process_ppid(pid, &e) >= 0);        log_info("PID"PID_FMT" PPID: "PID_FMT, pid, e);        assert_se(pid == 1 ? e == 0 : e > 0);        assert_se(is_kernel_thread(pid) == 0 || pid != 1);        r = get_process_exe(pid, &f);        assert_se(r >= 0 || r == -EACCES);        log_info("PID"PID_FMT" exe: '%s'", pid, strna(f));        assert_se(get_process_uid(pid, &u) == 0);        log_info("PID"PID_FMT" UID: "UID_FMT, pid, u);        assert_se(u == 0 || pid != 1);        assert_se(get_process_gid(pid, &g) == 0);        log_info("PID"PID_FMT" GID: "GID_FMT, pid, g);        assert_se(g == 0 || pid != 1);        r = get_process_environ(pid, &env);        assert_se(r >= 0 || r == -EACCES);        log_info("PID"PID_FMT" strlen(environ): %zi", pid, env ? (ssize_t)strlen(env) : (ssize_t)-errno);        if (!detect_container())                assert_se(get_ctty_devnr(pid, &h) == -ENXIO || pid != 1);        getenv_for_pid(pid, "PATH", &i);        log_info("PID"PID_FMT" $PATH: '%s'", pid, strna(i));}

static int add_usr_mount(void) {        _cleanup_free_ char *what = NULL;        const char *opts;        if (!arg_usr_what && !arg_usr_fstype && !arg_usr_options)                return 0;        if (arg_root_what && !arg_usr_what) {                arg_usr_what = strdup(arg_root_what);                if (!arg_usr_what)                        return log_oom();        }        if (arg_root_fstype && !arg_usr_fstype) {                arg_usr_fstype = strdup(arg_root_fstype);                if (!arg_usr_fstype)                        return log_oom();        }        if (arg_root_options && !arg_usr_options) {                arg_usr_options = strdup(arg_root_options);                if (!arg_usr_options)                        return log_oom();        }        if (!arg_usr_what)                return 0;        what = fstab_node_to_udev_node(arg_usr_what);        if (!path_is_absolute(what)) {                log_debug("Skipping entry what=%s where=/sysroot/usr type=%s", what, strna(arg_usr_fstype));                return -1;        }        if (!arg_usr_options)                opts = arg_root_rw > 0 ? "rw" : "ro";        else if (!fstab_test_option(arg_usr_options, "ro/0" "rw/0"))                opts = strjoina(arg_usr_options, ",", arg_root_rw > 0 ? "rw" : "ro");        else                opts = arg_usr_options;        log_debug("Found entry what=%s where=/sysroot/usr type=%s", what, strna(arg_usr_fstype));        return add_mount(what,                         "/sysroot/usr",                         arg_usr_fstype,                         opts,                         1,                         false,                         false,                         false,                         SPECIAL_INITRD_ROOT_FS_TARGET,                         "/proc/cmdline");}

static void print_status_info(StatusInfo *i) {        sd_id128_t mid, bid;        int r;        const char *id = NULL;        _cleanup_free_ char *pretty_name = NULL, *cpe_name = NULL;        struct utsname u;        assert(i);        printf("   Static hostname: %s/n",               strna(i->static_hostname));        if (!isempty(i->pretty_hostname) &&            !streq_ptr(i->pretty_hostname, i->static_hostname))                printf("   Pretty hostname: %s/n",                       strna(i->pretty_hostname));        if (!isempty(i->hostname) &&            !streq_ptr(i->hostname, i->static_hostname))                printf("Transient hostname: %s/n",                       strna(i->hostname));        printf("         Icon name: %s/n"               "           Chassis: %s/n",               strna(i->icon_name),               strna(i->chassis));        r = sd_id128_get_machine(&mid);        if (r >= 0)                printf("        Machine ID: " SD_ID128_FORMAT_STR "/n", SD_ID128_FORMAT_VAL(mid));        r = sd_id128_get_boot(&bid);        if (r >= 0)                printf("           Boot ID: " SD_ID128_FORMAT_STR "/n", SD_ID128_FORMAT_VAL(bid));        if (detect_virtualization(&id) > 0)                printf("    Virtualization: %s/n", id);        r = parse_env_file("/etc/os-release", NEWLINE,                           "PRETTY_NAME", &pretty_name,                           "CPE_NAME", &cpe_name,                           NULL);        if (!isempty(pretty_name))                printf("  Operating System: %s/n", pretty_name);        if (!isempty(cpe_name))                printf("       CPE OS Name: %s/n", cpe_name);        assert_se(uname(&u) >= 0);        printf("            Kernel: %s %s/n"               "      Architecture: %s/n", u.sysname, u.release, u.machine);}

static void print_status_info(StatusInfo *i) {        sd_id128_t mid = {}, bid = {};        int r;        assert(i);        printf("   Static hostname: %s/n", strna(i->static_hostname));        if (!isempty(i->pretty_hostname) &&            !streq_ptr(i->pretty_hostname, i->static_hostname))                printf("   Pretty hostname: %s/n", i->pretty_hostname);        if (!isempty(i->hostname) &&            !streq_ptr(i->hostname, i->static_hostname))                printf("Transient hostname: %s/n", i->hostname);        if (!isempty(i->icon_name))                printf("         Icon name: %s/n",                       strna(i->icon_name));        if (!isempty(i->chassis))                printf("           Chassis: %s/n",                       strna(i->chassis));        if (!isempty(i->deployment))                printf("        Deployment: %s/n", i->deployment);        if (!isempty(i->location))                printf("          Location: %s/n", i->location);        r = sd_id128_get_machine(&mid);        if (r >= 0)                printf("        Machine ID: " SD_ID128_FORMAT_STR "/n", SD_ID128_FORMAT_VAL(mid));        r = sd_id128_get_boot(&bid);        if (r >= 0)                printf("           Boot ID: " SD_ID128_FORMAT_STR "/n", SD_ID128_FORMAT_VAL(bid));        if (!isempty(i->virtualization))                printf("    Virtualization: %s/n", i->virtualization);        if (!isempty(i->os_pretty_name))                printf("  Operating System: %s/n", i->os_pretty_name);        if (!isempty(i->os_cpe_name))                printf("       CPE OS Name: %s/n", i->os_cpe_name);        if (!isempty(i->kernel_name) && !isempty(i->kernel_release))                printf("            Kernel: %s %s/n", i->kernel_name, i->kernel_release);        if (!isempty(i->architecture))                printf("      Architecture: %s/n", i->architecture);}

static int getnameinfo_handler(sd_resolve_query *q, int ret, const char *host, const char *serv, void *userdata) {        assert_se(q);        if (ret != 0) {                log_error("getnameinfo error: %s %i", gai_strerror(ret), ret);                return 0;        }        printf("Host: %s -- Serv: %s/n", strna(host), strna(serv));        return 0;}

static void test_u_n_f_p_one(const char *path, const char *suffix, const char *expected, int ret) {        _cleanup_free_ char *t = NULL;        assert_se(unit_name_from_path(path, suffix, &t) == ret);        puts(strna(t));        assert_se(streq_ptr(t, expected));        if (t) {                _cleanup_free_ char *k = NULL;                assert_se(unit_name_to_path(t, &k) == 0);                puts(strna(k));                assert_se(path_equal(k, isempty(path) ? "/" : path));        }}

static int print_inhibitors(sd_bus *bus, sd_bus_error *error) {        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;        const char *what, *who, *why, *mode;        unsigned int uid, pid;        unsigned n = 0;        int r;        r = sd_bus_call_method(                        bus,                        "org.freedesktop.login1",                        "/org/freedesktop/login1",                        "org.freedesktop.login1.Manager",                        "ListInhibitors",                        error,                        &reply,                        "");        if (r < 0)                return r;        r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");        if (r < 0)                return bus_log_parse_error(r);        while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {                _cleanup_free_ char *comm = NULL, *u = NULL;                get_process_comm(pid, &comm);                u = uid_to_name(uid);                printf("     Who: %s (UID "UID_FMT"/%s, PID "PID_FMT"/%s)/n"                       "    What: %s/n"                       "     Why: %s/n"                       "    Mode: %s/n/n",                       who, uid, strna(u), pid, strna(comm),                       what,                       why,                       mode);                n++;        }        if (r < 0)                return bus_log_parse_error(r);        r = sd_bus_message_exit_container(reply);        if (r < 0)                return bus_log_parse_error(r);        printf("%u inhibitors listed./n", n);        return 0;}

static int parse_env_file_push(                const char *filename, unsigned line,                const char *key, char *value,                void *userdata,                int *n_pushed) {        const char *k;        va_list aq, *ap = userdata;        if (!utf8_is_valid(key)) {                _cleanup_free_ char *p = NULL;                p = utf8_escape_invalid(key);                log_error("%s:%u: invalid UTF-8 in key '%s', ignoring.", strna(filename), line, p);                return -EINVAL;        }        if (value && !utf8_is_valid(value)) {                _cleanup_free_ char *p = NULL;                p = utf8_escape_invalid(value);                log_error("%s:%u: invalid UTF-8 value for key %s: '%s', ignoring.", strna(filename), line, key, p);                return -EINVAL;        }        va_copy(aq, *ap);        while ((k = va_arg(aq, const char *))) {                char **v;                v = va_arg(aq, char **);                if (streq(key, k)) {                        va_end(aq);                        free(*v);                        *v = value;                        if (n_pushed)                                (*n_pushed)++;                        return 1;                }        }        va_end(aq);        free(value);        return 0;}

static int show_status(char **args, unsigned n) {        char buf[64];        struct boot_info *info;        int err;        err = boot_info_new(&info);        if (err < 0)                return -ENOMEM;        err = boot_info_query(info);        printf("    Machine ID: %s/n", sd_id128_to_string(info->machine_id, buf));        printf("       Boot ID: %s/n", sd_id128_to_string(info->boot_id, buf));        if (info->fw_type)                printf("      Firmware: %s (%s)/n", info->fw_type, strna(info->fw_info));        if (info->fw_entry_active >= 0) {                printf("Firmware entry: %s/n", strna(info->fw_entries[info->fw_entry_active].title));                if (info->fw_entries[info->fw_entry_active].path)                        printf("                %s/n", info->fw_entries[info->fw_entry_active].path);                if (!sd_id128_equal(info->fw_entries[info->fw_entry_active].part_uuid, SD_ID128_NULL))                        printf("                /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x/n",                               SD_ID128_FORMAT_VAL(info->fw_entries[info->fw_entry_active].part_uuid));        }        if (info->loader) {                printf("        Loader: %s/n", info->loader);                printf("                %s/n", strna(info->loader_image_path));                if (!sd_id128_equal(info->loader_part_uuid, SD_ID128_NULL))                        printf("                /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x/n",                               SD_ID128_FORMAT_VAL(info->loader_part_uuid));                if (info->loader_entry_active >= 0) {                        printf("  Loader entry: %s/n", strna(info->loader_entries[info->loader_entry_active].title));                        printf("                %s/n", info->loader_entries[info->loader_entry_active].path);                }                printf("Loader options: %s/n", strna(info->loader_options_added));        } else                printf("No suitable data is provided by the boot manager. See:/n"                       "  http://www.freedesktop.org/wiki/Software/systemd/BootLoaderInterface/n"                       "  http://www.freedesktop.org/wiki/Specifications/BootLoaderSpec/n"                       "for details./n");        printf("/n");        boot_info_free(info);        return err;}

static int accept_cb(sd_event_source *s, int fd, uint32_t revents, void *userdata) {        _cleanup_free_ char *peer = NULL;        Context *context = userdata;        int nfd = -1, r;        assert(s);        assert(fd >= 0);        assert(revents & EPOLLIN);        assert(context);        nfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);        if (nfd < 0) {                if (errno != -EAGAIN)                        log_warning_errno(errno, "Failed to accept() socket: %m");        } else {                getpeername_pretty(nfd, true, &peer);                log_debug("New connection from %s", strna(peer));                r = add_connection_socket(context, nfd);                if (r < 0) {                        log_error_errno(r, "Failed to accept connection, ignoring: %m");                        safe_close(fd);                }        }        r = sd_event_source_set_enabled(s, SD_EVENT_ONESHOT);        if (r < 0) {                log_error_errno(r, "Error while re-enabling listener with ONESHOT: %m");                sd_event_exit(context->event, r);                return r;        }        return 1;}

static int automount_dispatch_io(sd_event_source *s, int fd, uint32_t events, void *userdata) {        union autofs_v5_packet_union packet;        Automount *a = AUTOMOUNT(userdata);        ssize_t l;        int r;        assert(a);        assert(fd == a->pipe_fd);        if (events != EPOLLIN) {                log_error_unit(UNIT(a)->id, "Got invalid poll event on pipe.");                goto fail;        }        l = loop_read(a->pipe_fd, &packet, sizeof(packet), true);        if (l != sizeof(packet)) {                log_error_unit(UNIT(a)->id, "Invalid read from pipe: %s", l < 0 ? strerror(-l) : "short read");                goto fail;        }        switch (packet.hdr.type) {        case autofs_ptype_missing_direct:                if (packet.v5_packet.pid > 0) {                        _cleanup_free_ char *p = NULL;                        get_process_comm(packet.v5_packet.pid, &p);                        log_info_unit(UNIT(a)->id,                                       "Got automount request for %s, triggered by "PID_FMT" (%s)",                                       a->where, packet.v5_packet.pid, strna(p));                } else                        log_debug_unit(UNIT(a)->id, "Got direct mount request on %s", a->where);                r = set_ensure_allocated(&a->tokens, trivial_hash_func, trivial_compare_func);                if (r < 0) {                        log_error_unit(UNIT(a)->id, "Failed to allocate token set.");                        goto fail;                }                r = set_put(a->tokens, UINT_TO_PTR(packet.v5_packet.wait_queue_token));                if (r < 0) {                        log_error_unit(UNIT(a)->id, "Failed to remember token: %s", strerror(-r));                        goto fail;                }                automount_enter_runnning(a);                break;        default:                log_error_unit(UNIT(a)->id, "Received unknown automount request %i", packet.hdr.type);                break;        }        return 0;fail:        automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);        return 0;}

static void print_source(int ifindex, uint64_t flags, usec_t rtt) {        char rtt_str[FORMAT_TIMESTAMP_MAX];        if (!arg_legend)                return;        if (ifindex <= 0 && flags == 0)                return;        fputs("/n-- Information acquired via", stdout);        if (flags != 0)                printf(" protocol%s%s%s",                       flags & SD_RESOLVED_DNS ? " DNS" :"",                       flags & SD_RESOLVED_LLMNR_IPV4 ? " LLMNR/IPv4" : "",                       flags & SD_RESOLVED_LLMNR_IPV6 ? " LLMNR/IPv6" : "");        if (ifindex > 0) {                char ifname[IF_NAMESIZE] = "";                printf(" interface %s", strna(if_indextoname(ifindex, ifname)));        }        assert_se(format_timespan(rtt_str, sizeof(rtt_str), rtt, 100));        printf(" in %s", rtt_str);        fputc('.', stdout);        fputc('/n', stdout);}

static void test_dnssec_nsec3_hash(void) {        static const uint8_t salt[] = { 0xB0, 0x1D, 0xFA, 0xCE };        static const uint8_t next_hashed_name[] = { 0x84, 0x10, 0x26, 0x53, 0xc9, 0xfa, 0x4d, 0x85, 0x6c, 0x97, 0x82, 0xe2, 0x8f, 0xdf, 0x2d, 0x5e, 0x87, 0x69, 0xc4, 0x52 };        _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;        uint8_t h[DNSSEC_HASH_SIZE_MAX];        _cleanup_free_ char *b = NULL;        int k;        /* The NSEC3 RR for eurid.eu on 2015-12-14. */        rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_NSEC3, "PJ8S08RR45VIQDAQGE7EN3VHKNROTBMM.eurid.eu.");        assert_se(rr);        rr->nsec3.algorithm = DNSSEC_DIGEST_SHA1;        rr->nsec3.flags = 1;        rr->nsec3.iterations = 1;        rr->nsec3.salt = memdup(salt, sizeof(salt));        assert_se(rr->nsec3.salt);        rr->nsec3.salt_size = sizeof(salt);        rr->nsec3.next_hashed_name = memdup(next_hashed_name, sizeof(next_hashed_name));        assert_se(rr->nsec3.next_hashed_name);        rr->nsec3.next_hashed_name_size = sizeof(next_hashed_name);        log_info("NSEC3: %s", strna(dns_resource_record_to_string(rr)));        k = dnssec_nsec3_hash(rr, "eurid.eu", &h);        assert_se(k >= 0);        b = base32hexmem(h, k, false);        assert_se(b);        assert_se(strcasecmp(b, "PJ8S08RR45VIQDAQGE7EN3VHKNROTBMM") == 0);}

static int print_efi_option(uint16_t id, bool in_order) {        _cleanup_free_ char *title = NULL;        _cleanup_free_ char *path = NULL;        sd_id128_t partition;        bool active;        int r = 0;        r = efi_get_boot_option(id, &title, &partition, &path, &active);        if (r < 0)                return r;        /* print only configured entries with partition information */        if (!path || sd_id128_is_null(partition))                return 0;        efi_tilt_backslashes(path);        printf("        Title: %s/n", strna(title));        printf("           ID: 0x%04X/n", id);        printf("       Status: %sactive%s/n", active ? "" : "in", in_order ? ", boot-order" : "");        printf("    Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x/n", SD_ID128_FORMAT_VAL(partition));        printf("         File: %s%s/n", special_glyph(TREE_RIGHT), path);        printf("/n");        return 0;}

static int method_set_hostname(sd_bus_message *m, void *userdata, sd_bus_error *error) {    Context *c = userdata;    const char *name;    int interactive;    char *h;    int r;    assert(m);    assert(c);    r = sd_bus_message_read(m, "sb", &name, &interactive);    if (r < 0)        return r;    if (isempty(name))        name = c->data[PROP_STATIC_HOSTNAME];    if (isempty(name))        name = "localhost";    if (!hostname_is_valid(name, false))        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid hostname '%s'", name);    if (streq_ptr(name, c->data[PROP_HOSTNAME]))        return sd_bus_reply_method_return(m, NULL);    r = bus_verify_polkit_async(            m,            CAP_SYS_ADMIN,            "org.freedesktop.hostname1.set-hostname",            NULL,            interactive,            UID_INVALID,            &c->polkit_registry,            error);    if (r < 0)        return r;    if (r == 0)        return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */    h = strdup(name);    if (!h)        return -ENOMEM;    free(c->data[PROP_HOSTNAME]);    c->data[PROP_HOSTNAME] = h;    r = context_update_kernel_hostname(c);    if (r < 0) {        log_error_errno(r, "Failed to set host name: %m");        return sd_bus_error_set_errnof(error, r, "Failed to set hostname: %s", strerror(-r));    }    log_info("Changed host name to '%s'", strna(c->data[PROP_HOSTNAME]));    (void) sd_bus_emit_properties_changed(sd_bus_message_get_bus(m), "/org/freedesktop/hostname1", "org.freedesktop.hostname1", "Hostname", NULL);    return sd_bus_reply_method_return(m, NULL);}

const char *dns_server_string(DnsServer *server) {        assert(server);        if (!server->server_string)                (void) in_addr_ifindex_to_string(server->family, &server->address, dns_server_ifindex(server), &server->server_string);        return strna(server->server_string);}

static int killall(int sig, Set *pids, bool send_sighup) {        _cleanup_closedir_ DIR *dir = NULL;        struct dirent *d;        dir = opendir("/proc");        if (!dir)                return -errno;        while ((d = readdir(dir))) {                pid_t pid;                int r;                if (d->d_type != DT_DIR &&                    d->d_type != DT_UNKNOWN)                        continue;                if (parse_pid(d->d_name, &pid) < 0)                        continue;                if (ignore_proc(pid, sig == SIGKILL && !in_initrd()))                        continue;                if (sig == SIGKILL) {                        _cleanup_free_ char *s = NULL;                        get_process_comm(pid, &s);                        log_notice("Sending SIGKILL to PID "PID_FMT" (%s).", pid, strna(s));                }                if (kill(pid, sig) >= 0) {                        if (pids) {                                r = set_put(pids, PID_TO_PTR(pid));                                if (r < 0)                                        log_oom();                        }                } else if (errno != ENOENT)                        log_warning_errno(errno, "Could not kill %d: %m", pid);                if (send_sighup) {                        /* Optionally, also send a SIGHUP signal, but                        only if the process has a controlling                        tty. This is useful to allow handling of                        shells which ignore SIGTERM but react to                        SIGHUP. We do not send this to processes that                        have no controlling TTY since we don't want to                        trigger reloads of daemon processes. Also we                        make sure to only send this after SIGTERM so                        that SIGTERM is always first in the queue. */                        if (get_ctty_devnr(pid, NULL) >= 0)                                kill(pid, SIGHUP);                }        }        return set_size(pids);}

static int frame_callback(Dwfl_Frame *frame, void *userdata) {        struct stack_context *c = userdata;        Dwarf_Addr pc, pc_adjusted, bias = 0;        _cleanup_free_ Dwarf_Die *scopes = NULL;        const char *fname = NULL, *symbol = NULL;        Dwfl_Module *module;        bool is_activation;        assert(frame);        assert(c);        if (c->n_frame >= FRAMES_MAX)                return DWARF_CB_ABORT;        if (!dwfl_frame_pc(frame, &pc, &is_activation))                return DWARF_CB_ABORT;        pc_adjusted = pc - (is_activation ? 0 : 1);        module = dwfl_addrmodule(c->dwfl, pc_adjusted);        if (module) {                Dwarf_Die *s, *cudie;                int n;                cudie = dwfl_module_addrdie(module, pc_adjusted, &bias);                if (cudie) {                        n = dwarf_getscopes(cudie, pc_adjusted - bias, &scopes);                        for (s = scopes; s < scopes + n; s++) {                                if (IN_SET(dwarf_tag(s), DW_TAG_subprogram, DW_TAG_inlined_subroutine, DW_TAG_entry_point)) {                                        Dwarf_Attribute *a, space;                                        a = dwarf_attr_integrate(s, DW_AT_MIPS_linkage_name, &space);                                        if (!a)                                                a = dwarf_attr_integrate(s, DW_AT_linkage_name, &space);                                        if (a)                                                symbol = dwarf_formstring(a);                                        if (!symbol)                                                symbol = dwarf_diename(s);                                        if (symbol)                                                break;                                }                        }                }                if (!symbol)                        symbol = dwfl_module_addrname(module, pc_adjusted);                fname = dwfl_module_info(module, NULL, NULL, NULL, NULL, NULL, NULL, NULL);        }        fprintf(c->f, "#%-2u 0x%016" PRIx64 " %s (%s)/n", c->n_frame, (uint64_t) pc, strna(symbol), strna(fname));        c->n_frame ++;        return DWARF_CB_OK;}

static bool ignore_proc(pid_t pid, bool warn_rootfs) {        _cleanup_fclose_ FILE *f = NULL;        char c;        const char *p;        size_t count;        uid_t uid;        int r;        /* We are PID 1, let's not commit suicide */        if (pid == 1)                return true;        r = get_process_uid(pid, &uid);        if (r < 0)                return true; /* not really, but better safe than sorry */        /* Non-root processes otherwise are always subject to be killed */        if (uid != 0)                return false;        p = procfs_file_alloca(pid, "cmdline");        f = fopen(p, "re");        if (!f)                return true; /* not really, but has the desired effect */        count = fread(&c, 1, 1, f);        /* Kernel threads have an empty cmdline */        if (count <= 0)                return true;        /* Processes with argv[0][0] = '@' we ignore from the killing         * spree.         *         * http://www.freedesktop.org/wiki/Software/systemd/RootStorageDaemons */        if (c == '@' && warn_rootfs) {                _cleanup_free_ char *comm = NULL;                r = pid_from_same_root_fs(pid);                if (r < 0)                        return true;                get_process_comm(pid, &comm);                if (r)                        log_notice("Process " PID_FMT " (%s) has been been marked to be excluded from killing. It is "                                   "running from the root file system, and thus likely to block re-mounting of the "                                   "root file system to read-only. Please consider moving it into an initrd file "                                   "system instead.", pid, strna(comm));                return true;        } else if (c == '@')                return true;        return false;}

static void device_dump(Unit *u, FILE *f, const char *prefix) {        Device *d = DEVICE(u);        assert(d);        fprintf(f,                "%sDevice State: %s/n"                "%sSysfs Path: %s/n",                prefix, device_state_to_string(d->state),                prefix, strna(d->sysfs));}

static int load_env_file_push_pairs(                const char *filename, unsigned line,                const char *key, char *value,                void *userdata,                int *n_pushed) {        char ***m = userdata;        int r;        if (!utf8_is_valid(key)) {                _cleanup_free_ char *t = utf8_escape_invalid(key);                log_error("%s:%u: invalid UTF-8 for key '%s', ignoring.", strna(filename), line, t);                return -EINVAL;        }        if (value && !utf8_is_valid(value)) {                _cleanup_free_ char *t = utf8_escape_invalid(value);                log_error("%s:%u: invalid UTF-8 value for key %s: '%s', ignoring.", strna(filename), line, key, t);                return -EINVAL;        }        r = strv_extend(m, key);        if (r < 0)                return -ENOMEM;        if (!value) {                r = strv_extend(m, "");                if (r < 0)                        return -ENOMEM;        } else {                r = strv_push(m, value);                if (r < 0)                        return r;        }        if (n_pushed)                (*n_pushed)++;        return 0;}

static int mount_one(const MountPoint *p, bool relabel) {        int r;        assert(p);        if (p->condition_fn && !p->condition_fn())                return 0;        /* Relabel first, just in case */        if (relabel)                (void) label_fix(p->where, true, true);        r = path_is_mount_point(p->where, NULL, AT_SYMLINK_FOLLOW);        if (r < 0 && r != -ENOENT) {                log_full_errno((p->mode & MNT_FATAL) ? LOG_ERR : LOG_DEBUG, r, "Failed to determine whether %s is a mount point: %m", p->where);                return (p->mode & MNT_FATAL) ? r : 0;        }        if (r > 0)                return 0;        /* Skip securityfs in a container */        if (!(p->mode & MNT_IN_CONTAINER) && detect_container() > 0)                return 0;        /* The access mode here doesn't really matter too much, since         * the mounted file system will take precedence anyway. */        if (relabel)                (void) mkdir_p_label(p->where, 0755);        else                (void) mkdir_p(p->where, 0755);        log_debug("Mounting %s to %s of type %s with options %s.",                  p->what,                  p->where,                  p->type,                  strna(p->options));        if (mount(p->what,                  p->where,                  p->type,                  p->flags,                  p->options) < 0) {                log_full_errno((p->mode & MNT_FATAL) ? LOG_ERR : LOG_DEBUG, errno, "Failed to mount %s at %s: %m", p->type, p->where);                return (p->mode & MNT_FATAL) ? -errno : 0;        }        /* Relabel again, since we now mounted something fresh here */        if (relabel)                (void) label_fix(p->where, false, false);        return 1;}

static int check_utf8ness_and_warn(                const char *filename, unsigned line,                const char *key, char *value) {        if (!utf8_is_valid(key)) {                _cleanup_free_ char *p = NULL;                p = utf8_escape_invalid(key);                log_error("%s:%u: invalid UTF-8 in key '%s', ignoring.", strna(filename), line, p);                return -EINVAL;        }        if (value && !utf8_is_valid(value)) {                _cleanup_free_ char *p = NULL;                p = utf8_escape_invalid(value);                log_error("%s:%u: invalid UTF-8 value for key %s: '%s', ignoring.", strna(filename), line, key, p);                return -EINVAL;        }        return 0;}

int main(int argc, char *argv[]) {        _cleanup_(loop_device_unrefp) LoopDevice *d = NULL;        _cleanup_(dissected_image_unrefp) DissectedImage *m = NULL;        int r, i;        log_set_max_level(LOG_DEBUG);        if (argc < 2) {                log_error("Requires one command line argument.");                return EXIT_FAILURE;        }        r = loop_device_make_by_path(argv[1], O_RDONLY, &d);        if (r < 0) {                log_error_errno(r, "Failed to set up loopback device: %m");                return EXIT_FAILURE;        }        r = dissect_image(d->fd, NULL, 0, &m);        if (r < 0) {                log_error_errno(r, "Failed to dissect image: %m");                return EXIT_FAILURE;        }        for (i = 0; i < _PARTITION_DESIGNATOR_MAX; i++) {                if (!m->partitions[i].found)                        continue;                printf("Found %s partition, %s of type %s at #%i (%s)/n",                       partition_designator_to_string(i),                       m->partitions[i].rw ? "writable" : "read-only",                       strna(m->partitions[i].fstype),                       m->partitions[i].partno,                       strna(m->partitions[i].node));        }        return EXIT_SUCCESS;}