systemd/src/shared/storage-util.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "sd-varlink.h"

#include "alloc-util.h"
#include "fd-util.h"
#include "json-util.h"
#include "machine-util.h"
#include "path-lookup.h"
#include "path-util.h"
#include "runtime-scope.h"
#include "string-table.h"
#include "storage-util.h"

static const char *volume_type_table[_VOLUME_TYPE_MAX] = {
        [VOLUME_BLK] = "blk",
        [VOLUME_REG] = "reg",
        [VOLUME_DIR] = "dir",
};

static const char *create_mode_table[_CREATE_MODE_MAX] = {
        [CREATE_ANY]  = "any",
        [CREATE_NEW]  = "new",
        [CREATE_OPEN] = "open",
};

DEFINE_STRING_TABLE_LOOKUP(volume_type, VolumeType);
DEFINE_STRING_TABLE_LOOKUP(create_mode, CreateMode);

JSON_DISPATCH_ENUM_DEFINE(json_dispatch_volume_type, VolumeType, volume_type_from_string);
JSON_DISPATCH_ENUM_DEFINE(json_dispatch_create_mode, CreateMode, create_mode_from_string);

void storage_acquire_reply_done(StorageAcquireReply *reply) {
        if (!reply)
                return;

        reply->fd = safe_close(reply->fd);
}

int storage_acquire_volume(
                RuntimeScope scope,
                const BindVolume *bv,
                bool allow_interactive_auth,
                char **reterr_error_id,
                StorageAcquireReply *ret) {

        int r;

        assert(bv);
        assert(bv->provider);
        assert(bv->volume);
        assert(ret);

        /* Defense-in-depth: this is a libshared helper that may grow new callers; reject
         * provider names that could escape the StorageProvider runtime directory. */
        if (!storage_provider_name_is_valid(bv->provider))
                return -EINVAL;

        _cleanup_free_ char *socket_path = NULL;
        r = runtime_directory_generic(scope, "systemd/io.systemd.StorageProvider", &socket_path);
        if (r < 0)
                return r;

        if (!path_extend(&socket_path, bv->provider))
                return -ENOMEM;

        _cleanup_(sd_varlink_unrefp) sd_varlink *link = NULL;
        r = sd_varlink_connect_address(&link, socket_path);
        if (r < 0)
                return r;

        r = sd_varlink_set_allow_fd_passing_input(link, true);
        if (r < 0)
                return r;

        sd_json_variant *mreply = NULL;
        const char *merror_id = NULL;
        r = sd_varlink_callbo(
                        link,
                        "io.systemd.StorageProvider.Acquire",
                        &mreply,
                        &merror_id,
                        SD_JSON_BUILD_PAIR_STRING("name", bv->volume),
                        JSON_BUILD_PAIR_CONDITION_STRING(bv->create_mode >= 0, "createMode", create_mode_to_string(bv->create_mode)),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("template", bv->template),
                        JSON_BUILD_PAIR_TRISTATE_NON_NULL("readOnly", read_only_mode_to_tristate(bv->read_only)),
                        JSON_BUILD_PAIR_CONDITION_STRING(bv->request_as >= 0, "requestAs", volume_type_to_string(bv->request_as)),
                        JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("createSizeBytes", bv->create_size_bytes, UINT64_MAX),
                        SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", allow_interactive_auth));
        if (r < 0)
                return r;

        if (merror_id) {
                if (reterr_error_id) {
                        char *copy = strdup(merror_id);
                        if (!copy)
                                return -ENOMEM;
                        *reterr_error_id = copy;
                }

                r = sd_varlink_error_to_errno(merror_id, mreply);
                return r == -EBADR ? -EPROTO : r;
        }

        /* tmp.fd holds the JSON fd index until sd_varlink_take_fd() swaps it for the real fd. */
        StorageAcquireReply tmp = STORAGE_ACQUIRE_REPLY_INIT;

        static const sd_json_dispatch_field dispatch_table[] = {
                { "fileDescriptorIndex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int,         voffsetof(StorageAcquireReply, fd),        SD_JSON_MANDATORY },
                { "readOnly",            SD_JSON_VARIANT_BOOLEAN,       sd_json_dispatch_tristate,    voffsetof(StorageAcquireReply, read_only), 0                 },
                { "type",                SD_JSON_VARIANT_STRING,        json_dispatch_volume_type,    voffsetof(StorageAcquireReply, type),      SD_JSON_MANDATORY },
                { "baseUID",             _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uid_gid,     voffsetof(StorageAcquireReply, base_uid),  0                 },
                { "baseGID",             _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uid_gid,     voffsetof(StorageAcquireReply, base_gid),  0                 },
                {}
        };

        r = sd_json_dispatch(mreply, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &tmp);
        if (r < 0)
                return r;
        if (tmp.fd < 0)
                return -EBADMSG;

        _cleanup_close_ int fd = sd_varlink_take_fd(link, tmp.fd);
        if (fd < 0)
                return fd;

        tmp.fd = TAKE_FD(fd);
        *ret = tmp;
        return 0;
}