app/storage/client_tipc.c

/*
 * Copyright (C) 2013-2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "client_tipc.h"

#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <interface/storage/storage.h>
#include <lib/tipc/tipc.h>
#include <openssl/mem.h>
#include <uapi/err.h>

#include "client.h"
#include "client_session.h"
#include "client_session_tipc.h"
#include "ipc.h"
#include "storage_limits.h"
#include "tipc_service.h"

/* macros to help manage debug output */
#define SS_ERR(args...) fprintf(stderr, "ss: " args)
#define SS_DBG_IO(args...) \
    do {                   \
    } while (0)

#if 0
/* this can generate alot of spew on debug builds */
#define SS_INFO(args...) fprintf(stderr, "ss: " args)
#else
#define SS_INFO(args...) \
    do {                 \
    } while (0)
#endif

static int client_handle_msg(struct ipc_channel_context* ctx,
                             void* msg,
                             size_t msg_size);
static void client_disconnect(struct ipc_channel_context* context);
static int send_response(struct storage_tipc_client_session* tipc_session,
                         enum storage_err result,
                         struct storage_msg* msg,
                         void* out,
                         size_t out_size);
static int send_result(struct storage_tipc_client_session* tipc_session,
                       struct storage_msg* msg,
                       enum storage_err result);

static struct storage_op_flags extract_storage_op_flags(uint32_t msg_flags) {
    return (struct storage_op_flags){
            .allow_repaired = msg_flags & STORAGE_MSG_FLAG_FS_REPAIRED_ACK,
            .complete_transaction =
                    msg_flags & STORAGE_MSG_FLAG_TRANSACT_COMPLETE,
            .update_checkpoint =
                    msg_flags & STORAGE_MSG_FLAG_TRANSACT_CHECKPOINT,
    };
}

static enum storage_err storage_tipc_file_delete(
        struct storage_client_session* session,
        struct storage_msg* msg,
        struct storage_file_delete_req* req,
        size_t req_size) {
    if (req_size < sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return STORAGE_ERR_NOT_VALID;
    }

    if ((req->flags & ~STORAGE_FILE_DELETE_MASK) != 0) {
        SS_ERR("%s: unexpected flags (0x%" PRIx32 ")\n", __func__, req->flags);
        return STORAGE_ERR_NOT_VALID;
    }

    return storage_file_delete(session, req->name, req_size - sizeof(*req),
                               extract_storage_op_flags(msg->flags));
}

static enum storage_err storage_tipc_file_move(
        struct storage_client_session* session,
        struct storage_msg* msg,
        struct storage_file_move_req* req,
        size_t req_size) {
    if (req_size < sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return STORAGE_ERR_NOT_VALID;
    }

    if ((req->flags & ~STORAGE_FILE_MOVE_MASK) != 0) {
        SS_ERR("invalid move flags 0x%" PRIx32 "\n", req->flags);
        return STORAGE_ERR_NOT_VALID;
    }

    size_t names_combined_len = req_size - sizeof(*req);
    size_t src_len = req->old_name_len;
    if (src_len >= names_combined_len) {
        SS_ERR("%s: invalid src filename length %zu >= %zu\n", __func__,
               src_len, names_combined_len);
        return STORAGE_ERR_NOT_VALID;
    }

    enum file_create_mode file_create_mode;
    if (req->flags & STORAGE_FILE_MOVE_CREATE) {
        file_create_mode = req->flags & STORAGE_FILE_MOVE_CREATE_EXCLUSIVE
                                   ? FILE_OPEN_CREATE_EXCLUSIVE
                                   : FILE_OPEN_CREATE;
    } else {
        file_create_mode = FILE_OPEN_NO_CREATE;
    }

    return storage_file_move(
            session, req->handle, req->flags & STORAGE_FILE_MOVE_OPEN_FILE,
            req->old_new_name, src_len, req->old_new_name + src_len,
            names_combined_len - src_len, file_create_mode,
            extract_storage_op_flags(msg->flags));
}

static enum storage_err storage_tipc_file_open(
        struct storage_tipc_client_session* tipc_session,
        struct storage_msg* msg,
        struct storage_file_open_req* req,
        size_t req_size) {
    if (req_size < sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return send_result(tipc_session, msg, STORAGE_ERR_NOT_VALID);
    }

    if ((req->flags & ~STORAGE_FILE_OPEN_MASK) != 0) {
        SS_ERR("%s: invalid flags 0x%" PRIx32 "\n", __func__, req->flags);
        return send_result(tipc_session, msg, STORAGE_ERR_NOT_VALID);
    }

    enum file_create_mode file_create_mode;
    if (req->flags & STORAGE_FILE_OPEN_CREATE) {
        file_create_mode = req->flags & STORAGE_FILE_OPEN_CREATE_EXCLUSIVE
                                   ? FILE_OPEN_CREATE_EXCLUSIVE
                                   : FILE_OPEN_CREATE;
    } else {
        file_create_mode = FILE_OPEN_NO_CREATE;
    }

    struct storage_file_open_resp resp;
    enum storage_err result = storage_file_open(
            &tipc_session->session, req->name, req_size - sizeof(*req),
            file_create_mode, req->flags & STORAGE_FILE_OPEN_TRUNCATE,
            extract_storage_op_flags(msg->flags), &resp.handle);
    if (result != STORAGE_NO_ERROR) {
        return send_result(tipc_session, msg, result);
    }
    return send_response(tipc_session, result, msg, &resp, sizeof(resp));
}

static enum storage_err storage_tipc_file_close(
        struct storage_client_session* session,
        struct storage_msg* msg,
        struct storage_file_close_req* req,
        size_t req_size) {
    if (req_size != sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return STORAGE_ERR_NOT_VALID;
    }
    return storage_file_close(session, req->handle,
                              extract_storage_op_flags(msg->flags));
}

static enum storage_err storage_tipc_file_write(
        struct storage_client_session* session,
        struct storage_msg* msg,
        struct storage_file_write_req* req,
        size_t req_size) {
    if (req_size <= sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return STORAGE_ERR_NOT_VALID;
    }
    return storage_file_write(session, req->handle, req->offset, req->data,
                              req_size - sizeof(*req),
                              extract_storage_op_flags(msg->flags));
}

static enum storage_err storage_tipc_file_read(
        struct storage_tipc_client_session* tipc_session,
        struct storage_msg* msg,
        struct storage_file_read_req* req,
        size_t req_size) {
    if (req_size != sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return send_result(tipc_session, msg, STORAGE_ERR_NOT_VALID);
    }

    /*
     * After getting the args out of req, we still need `*msg`, but won't need
     * the rest of the buffer anymore. We can reuse that space to hold the
     * response.
     */
    uint8_t* resp = (uint8_t*)(msg + 1);
    size_t resp_len = STORAGE_MAX_BUFFER_SIZE - sizeof(*msg);

    enum storage_err result = storage_file_read(
            &tipc_session->session, req->handle, req->size, req->offset,
            extract_storage_op_flags(msg->flags), resp, &resp_len);
    if (result != STORAGE_NO_ERROR) {
        return send_result(tipc_session, msg, result);
    }
    return send_response(tipc_session, result, msg, resp, resp_len);
}

struct storage_tipc_file_iter_data {
    char resp_buf[1024];
    size_t buf_used;
};

static bool buf_has_space(void* self, size_t max_path_len) {
    struct storage_tipc_file_iter_data* this = self;
    /* One extra byte for flags plus one for the path's nul terminator */
    size_t max_resp_size = max_path_len + 2;
    return this->buf_used + max_resp_size <= sizeof(this->resp_buf);
}

static void write_to_buf(void* self,
                         enum storage_file_list_flag flags,
                         const char* path,
                         size_t path_len) {
    struct storage_tipc_file_iter_data* this = self;
    struct storage_file_list_resp* resp =
            (void*)(this->resp_buf + this->buf_used);

    resp->flags = flags;
    this->buf_used++;

    if (path) {
        strncpy(resp->name, path, path_len);
        resp->name[path_len] = '\0';
        this->buf_used += path_len + 1;
    }
}

static enum storage_err storage_tipc_file_list(
        struct storage_tipc_client_session* tipc_session,
        struct storage_msg* msg,
        struct storage_file_list_req* req,
        size_t req_size) {
    if (req_size < sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return send_result(tipc_session, msg, STORAGE_ERR_NOT_VALID);
    }

    struct storage_tipc_file_iter_data callback_data = {
            .buf_used = 0,
    };

    enum storage_err result = storage_file_list(
            &tipc_session->session, req->max_count,
            req->flags & STORAGE_FILE_LIST_STATE_MASK, req->name,
            req_size - sizeof(*req), extract_storage_op_flags(msg->flags),
            buf_has_space, write_to_buf, &callback_data);
    if (result != STORAGE_NO_ERROR) {
        return send_result(tipc_session, msg, result);
    }
    return send_response(tipc_session, result, msg, callback_data.resp_buf,
                         callback_data.buf_used);
}

static enum storage_err storage_tipc_file_get_size(
        struct storage_tipc_client_session* tipc_session,
        struct storage_msg* msg,
        struct storage_file_get_size_req* req,
        size_t req_size) {
    if (req_size != sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return send_result(tipc_session, msg, STORAGE_ERR_NOT_VALID);
    }

    struct storage_file_get_size_resp resp;
    enum storage_err result = storage_file_get_size(
            &tipc_session->session, req->handle,
            extract_storage_op_flags(msg->flags), &resp.size);
    if (result != STORAGE_NO_ERROR) {
        return send_result(tipc_session, msg, result);
    }
    return send_response(tipc_session, result, msg, &resp, sizeof(resp));
}

static enum storage_err storage_tipc_file_set_size(
        struct storage_client_session* session,
        struct storage_msg* msg,
        struct storage_file_set_size_req* req,
        size_t req_size) {
    if (req_size != sizeof(*req)) {
        SS_ERR("%s: invalid request size (%zu)\n", __func__, req_size);
        return STORAGE_ERR_NOT_VALID;
    }
    return storage_file_set_size(session, req->handle, req->size,
                                 extract_storage_op_flags(msg->flags));
}

static struct storage_tipc_client_session* chan_context_to_client_session(
        struct ipc_channel_context* ctx) {
    assert(ctx != NULL);
    struct storage_tipc_client_session* tipc_session;

    tipc_session =
            containerof(ctx, struct storage_tipc_client_session, chan_ctx);
    assert(tipc_session->session.magic == STORAGE_CLIENT_SESSION_MAGIC);
    return tipc_session;
}

static struct client_port_context* port_context_to_client_port_context(
        struct ipc_port_context* context) {
    assert(context != NULL);

    return containerof(context, struct client_port_context, client_ctx);
}

static void client_channel_ops_init(struct ipc_channel_ops* ops) {
    ops->on_handle_msg = client_handle_msg;
    ops->on_disconnect = client_disconnect;
}

static struct ipc_channel_context* client_connect(
        struct ipc_port_context* parent_ctx,
        const uuid_t* peer_uuid,
        handle_t chan_handle) {
    struct client_port_context* client_port_context;
    struct storage_tipc_client_session* client_tipc_session;

    client_port_context = port_context_to_client_port_context(parent_ctx);

    client_tipc_session = calloc(1, sizeof(*client_tipc_session));
    if (client_tipc_session == NULL) {
        SS_ERR("out of memory allocating client session\n");
        return NULL;
    }

    struct storage_client_session* client_session =
            &client_tipc_session->session;
    storage_client_session_init(client_session, client_port_context->tr_state,
                                peer_uuid);

    client_channel_ops_init(&client_tipc_session->chan_ctx.ops);
    return &client_tipc_session->chan_ctx;
}

static void client_disconnect(struct ipc_channel_context* context) {
    struct storage_tipc_client_session* tipc_session =
            chan_context_to_client_session(context);

    storage_client_session_destroy(&tipc_session->session);
    OPENSSL_cleanse(tipc_session, sizeof(struct storage_tipc_client_session));
    free(tipc_session);
}

static int send_response(struct storage_tipc_client_session* tipc_session,
                         enum storage_err result,
                         struct storage_msg* msg,
                         void* out,
                         size_t out_size) {
    size_t resp_buf_count = 1;
    if (result == STORAGE_NO_ERROR && out != NULL && out_size != 0) {
        ++resp_buf_count;
    }

    struct iovec resp_bufs[2];

    msg->cmd |= STORAGE_RESP_BIT;
    msg->flags = 0;
    msg->size = sizeof(struct storage_msg) + out_size;
    msg->result = result;

    resp_bufs[0].iov_base = msg;
    resp_bufs[0].iov_len = sizeof(struct storage_msg);

    if (resp_buf_count == 2) {
        resp_bufs[1].iov_base = out;
        resp_bufs[1].iov_len = out_size;
    }

    struct ipc_msg resp_ipc_msg = {
            .iov = resp_bufs,
            .num_iov = resp_buf_count,
    };

    return send_msg(tipc_session->chan_ctx.common.handle, &resp_ipc_msg);
}

static int send_result(struct storage_tipc_client_session* tipc_session,
                       struct storage_msg* msg,
                       enum storage_err result) {
    return send_response(tipc_session, result, msg, NULL, 0);
}

static int client_handle_msg(struct ipc_channel_context* ctx,
                             void* msg_buf,
                             size_t msg_size) {
    struct storage_tipc_client_session* tipc_session;
    struct storage_client_session* session;
    struct storage_msg* msg = msg_buf;
    size_t payload_len;
    enum storage_err result;
    void* payload;

    tipc_session = chan_context_to_client_session(ctx);
    session = &tipc_session->session;

    if (msg_size < sizeof(struct storage_msg)) {
        SS_ERR("%s: invalid message of size (%zu)\n", __func__, msg_size);
        struct storage_msg err_msg = {.cmd = STORAGE_RESP_MSG_ERR};
        send_result(tipc_session, &err_msg, STORAGE_ERR_NOT_VALID);
        return ERR_NOT_VALID; /* would force to close connection */
    }

    payload_len = msg_size - sizeof(struct storage_msg);
    payload = msg->payload;

    switch (msg->cmd) {
    case STORAGE_FILE_DELETE:
        result = storage_tipc_file_delete(session, msg, payload, payload_len);
        break;
    case STORAGE_FILE_MOVE:
        result = storage_tipc_file_move(session, msg, payload, payload_len);
        break;
    case STORAGE_FILE_OPEN:
        return storage_tipc_file_open(tipc_session, msg, payload, payload_len);
    case STORAGE_FILE_CLOSE:
        result = storage_tipc_file_close(session, msg, payload, payload_len);
        break;
    case STORAGE_FILE_WRITE:
        result = storage_tipc_file_write(session, msg, payload, payload_len);
        break;
    case STORAGE_FILE_READ:
        return storage_tipc_file_read(tipc_session, msg, payload, payload_len);
    case STORAGE_FILE_LIST:
        return storage_tipc_file_list(tipc_session, msg, payload, payload_len);
    case STORAGE_FILE_GET_SIZE:
        return storage_tipc_file_get_size(tipc_session, msg, payload,
                                          payload_len);
    case STORAGE_FILE_SET_SIZE:
        result = storage_tipc_file_set_size(session, msg, payload, payload_len);
        break;
    case STORAGE_END_TRANSACTION:
        result = storage_transaction_end(session,
                                         extract_storage_op_flags(msg->flags));
        break;
    default:
        SS_ERR("%s: unsupported command 0x%" PRIx32 "\n", __func__, msg->cmd);
        result = STORAGE_ERR_UNIMPLEMENTED;
        break;
    }

    return send_result(tipc_session, msg, result);
}

int client_create_port(struct tipc_hset* hset,
                       struct ipc_port_context* client_ctx,
                       const char* port_name) {
    int ret;
    uint32_t flags = IPC_PORT_ALLOW_TA_CONNECT;
#if TEST_BUILD
    flags |= IPC_PORT_ALLOW_NS_CONNECT;
#endif

    /* start accepting client connections */
    client_ctx->ops.on_connect = client_connect;
    ret = ipc_port_create(hset, client_ctx, port_name, 1,
                          STORAGE_MAX_BUFFER_SIZE, flags);
    if (ret < 0) {
        SS_ERR("%s: failure initializing client port (%d)\n", __func__, ret);
        return ret;
    }
    return 0;
}