// Copyright 2015 The Android Open Source Project
//
// This software is licensed under the terms of the GNU General Public
// License version 2, as published by the Free Software Foundation, and
// may be copied, distributed, and modified under those terms.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

#include "android/emulation/android_qemud.h"

#include "android/utils/looper.h"
#include "android/utils/misc.h"
#include "android/utils/panic.h"

#include "android/emulation/android_pipe_host.h"
#include "android/emulation/qemud/android_qemud_client.h"
#include "android/emulation/qemud/android_qemud_common.h"
#include "android/emulation/qemud/android_qemud_multiplexer.h"
#include "android/emulation/qemud/android_qemud_service.h"

#include <assert.h>
#include <stdlib.h>

/* Initializes QEMUD serial interface.
 */
static void _android_qemud_serial_init(CSerialLine* sl) {
    // guard against double initialization
    static CSerialLine* qemud_serial_line = NULL;

    if (qemud_serial_line != NULL) {
        return;
    }

    qemud_serial_line = sl;
    qemud_multiplexer_init(qemud_multiplexer, sl);
}

/*------------------------------------------------------------------------------
 *
 * QEMUD PIPE service callbacks
 *
 * ----------------------------------------------------------------------------*/

/* Saves pending pipe message to the snapshot file. */
static void _save_pipe_message(Stream* f, QemudPipeMessage* msg) {
    stream_put_be32(f, msg->size);
    stream_put_be32(f, msg->offset);
    stream_write(f, msg->message, msg->size);
}

/* Loads pending pipe messages from the snapshot file.
 * Return:
 *  List of pending pipe messages loaded from snapshot, or NULL if snapshot didn't
 *  contain saved messages.
 */
static QemudPipeMessage* _load_pipe_message(Stream* f, QemudPipeMessage** last) {
    QemudPipeMessage* ret = NULL;
    QemudPipeMessage** next = &ret;
    *last = NULL;

    uint32_t size = stream_get_be32(f);
    while (size != 0) {
        QemudPipeMessage* wrk =
                static_cast<QemudPipeMessage*>(android_alloc0(sizeof(*wrk)));
        *last = *next = wrk;
        wrk->size = size;
        wrk->offset = stream_get_be32(f);
        wrk->message = static_cast<uint8_t*>(malloc(wrk->size));
        if (wrk->message == NULL) {
            APANIC("Unable to allocate buffer for pipe's pending message.");
        }
        stream_read(f, wrk->message, wrk->size);
        next = &wrk->next;
        *next = NULL;
        size = stream_get_be32(f);
    }

    return ret;
}

/* This is a callback that gets invoked when guest is connecting to the service.
 *
 * Here we will create a new client as well as pipe descriptor representing new
 * connection.
 */
static void*
_qemudPipe_init(void* hwpipe, void* _looper, const char* args) {
    QemudMultiplexer* m = qemud_multiplexer;
    QemudService* sv = m->services;
    QemudClient* client;
    QemudPipe* pipe = NULL;
    char service_name[512];
    const char* client_args;
    size_t srv_name_len;

    /* 'args' passed in this callback represents name of the service the guest is
     * connecting to. It can't be NULL. */
    if (args == NULL) {
        D("%s: Missing address!", __FUNCTION__);
        return NULL;
    }

    /* 'args' contain service name, and optional parameters for the client that
     * is about to be created in this call. The parameters are separated from the
     * service name wit ':'. Separate service name from the client param. */
    client_args = strchr(args, ':');
    if (client_args != NULL) {
        srv_name_len = min(client_args - args, (intptr_t) sizeof(service_name) - 1);
        client_args++;  // Past the ':'
        if (*client_args == '\0') {
            /* No actual parameters. */
            client_args = NULL;
        }
    } else {
        srv_name_len = min(strlen(args), sizeof(service_name) - 1);
    }
    memcpy(service_name, args, srv_name_len);
    service_name[srv_name_len] = '\0';

    /* Lookup registered service by its name. */
    while (sv != NULL && strcmp(sv->name, service_name)) {
        sv = sv->next;
    }
    if (sv == NULL) {
        D("%s: Service '%s' has not been registered!", __FUNCTION__, service_name);
        return NULL;
    }

    /* Create a client for this connection. -1 as a channel ID signals that this
     * is a pipe client. */
    client = qemud_service_connect_client(sv, -1, client_args);
    if (client != NULL) {
        pipe = static_cast<QemudPipe*>(android_alloc0(sizeof(*pipe)));
        pipe->hwpipe = hwpipe;
        pipe->looper = _looper;
        pipe->service = sv;
        pipe->client = client;
        client->ProtocolSelector.Pipe.qemud_pipe = pipe;
    }

    return pipe;
}

/* Called when the guest wants to close the channel.
*/
static void
_qemudPipe_closeFromGuest(void* opaque) {
    QemudPipe* pipe = static_cast<QemudPipe*>(opaque);
    QemudClient* client = pipe->client;
    D("%s", __FUNCTION__);
    if (client != NULL) {
        qemud_client_disconnect(client, 1);
    } else {
        D("%s: Unexpected NULL client", __FUNCTION__);
    }
}

/* Called when the guest has sent some data to the client.
 */
static int
_qemudPipe_sendBuffers(void* opaque,
                       const AndroidPipeBuffer* buffers,
                       int numBuffers) {
    QemudPipe* pipe = static_cast<QemudPipe*>(opaque);
    QemudClient* client = pipe->client;
    size_t transferred = 0;

    if (client == NULL) {
        D("%s: Unexpected NULL client", __FUNCTION__);
        return -1;
    }

    if (numBuffers == 1) {
        /* Simple case: all data are in one buffer. */
        D("%s: %s", __FUNCTION__, quote_bytes((char*) buffers->data, buffers->size));
        qemud_client_recv(client, buffers->data, buffers->size);
        transferred = buffers->size;
    } else {
        /* If there are multiple buffers involved, collect all data in one buffer
         * before calling the high level client. */
        uint8_t* msg, * wrk;
        int n;
        for (n = 0; n < numBuffers; n++) {
            transferred += buffers[n].size;
        }
        msg = static_cast<uint8_t*>(malloc(transferred));
        wrk = msg;
        for (n = 0; n < numBuffers; n++) {
            memcpy(wrk, buffers[n].data, buffers[n].size);
            wrk += buffers[n].size;
        }
        D("%s: %s", __FUNCTION__, quote_bytes((char*) msg, transferred));
        qemud_client_recv(client, msg, transferred);
        free(msg);
    }

    return transferred;
}

/* Called when the guest is reading data from the client.
 */
static int
_qemudPipe_recvBuffers(void* opaque, AndroidPipeBuffer* buffers, int numBuffers) {
    QemudPipe* pipe = static_cast<QemudPipe*>(opaque);
    QemudClient* client = pipe->client;
    QemudPipeMessage** msg_list;
    AndroidPipeBuffer* buff = buffers;
    AndroidPipeBuffer* endbuff = buffers + numBuffers;
    size_t sent_bytes = 0;
    size_t off_in_buff = 0;

    if (client == NULL) {
        D("%s: Unexpected NULL client", __FUNCTION__);
        return -1;
    }

    msg_list = &client->ProtocolSelector.Pipe.messages;
    if (*msg_list == NULL) {
        /* No data to send. Let it block until we wake it up with
         * PIPE_WAKE_READ when service sends data to the client. */
        return PIPE_ERROR_AGAIN;
    }

    /* Fill in goldfish buffers while they are still available, and there are
     * messages in the client's message list. */
    while (buff != endbuff && *msg_list != NULL) {
        QemudPipeMessage* msg = *msg_list;
        /* Message data fiting the current pipe's buffer. */
        size_t to_copy = min(msg->size - msg->offset, buff->size - off_in_buff);
        memcpy(buff->data + off_in_buff, msg->message + msg->offset, to_copy);
        /* Update offsets. */
        off_in_buff += to_copy;
        msg->offset += to_copy;
        sent_bytes += to_copy;
        if (msg->size == msg->offset) {
            /* We're done with the current message. Go to the next one. */
            *msg_list = msg->next;
            free(msg);
        }
        if (off_in_buff == buff->size) {
            /* Current pipe buffer is full. Continue with the next one. */
            buff++;
            off_in_buff = 0;
        }
    }

    if (!*msg_list) {
        client->ProtocolSelector.Pipe.last_msg = NULL;
    }

    D("%s: -> %u (of %u)", __FUNCTION__, sent_bytes, buffers->size);

    return sent_bytes;
}

static unsigned
_qemudPipe_poll(void* opaque) {
    QemudPipe* pipe = static_cast<QemudPipe*>(opaque);
    QemudClient* client = pipe->client;
    unsigned ret = 0;

    if (client != NULL) {
        ret |= PIPE_POLL_OUT;
        if (client->ProtocolSelector.Pipe.messages != NULL) {
            ret |= PIPE_POLL_IN;
        }
    } else {
        D("%s: Unexpected NULL client", __FUNCTION__);
    }

    return ret;
}

static void
_qemudPipe_wakeOn(void* opaque, int flags) {
    QemudPipe* qemud_pipe = (QemudPipe*) opaque;
    QemudClient* c = qemud_pipe->client;
    D("%s: -> %X", __FUNCTION__, flags);
    if (flags & PIPE_WAKE_READ) {
        if (c->ProtocolSelector.Pipe.messages != NULL) {
            android_pipe_host_signal_wake(
                    c->ProtocolSelector.Pipe.qemud_pipe->hwpipe,
                    PIPE_WAKE_READ);
        }
    }
}

static void _qemudPipe_save(void* opaque, Stream* f) {
    QemudPipe* qemud_pipe = (QemudPipe*) opaque;
    QemudClient* c = qemud_pipe->client;
    QemudPipeMessage* msg = c->ProtocolSelector.Pipe.messages;

    /* save generic information */
    qemud_service_save_name(f, c->service);
    stream_put_string(f, c->param);

    /* Save pending messages. */
    while (msg != NULL) {
        _save_pipe_message(f, msg);
        msg = msg->next;
    }
    /* End of pending messages. */
    stream_put_be32(f, 0);

    /* save client-specific state */
    if (c->clie_save)
        c->clie_save(f, c, c->clie_opaque);

    /* save framing configuration */
    stream_put_be32(f, c->framing);
    if (c->framing) {
        stream_put_be32(f, c->need_header);
        /* header sink always connected to c->header0, no need to save */
        stream_put_be32(f, FRAME_HEADER_SIZE);
        stream_write(f, c->header0, FRAME_HEADER_SIZE);
        /* payload sink */
        qemud_sink_save(f, c->payload);
        stream_write(f, c->payload->buff, c->payload->size);
    }
}

static void* _qemudPipe_load(void* hwpipe,
                             void* pipeOpaque,
                             const char* args,
                             Stream* f) {
    QemudPipe* qemud_pipe = NULL;
    char* param;
    char* service_name = qemud_service_load_name(f);
    if (service_name == NULL)
        return NULL;
    /* get service instance for the loading client*/
    QemudService* sv = qemud_service_find(qemud_multiplexer->services,
                                          service_name);
    if (sv == NULL) {
        D("%s: load failed: unknown service \"%s\"\n",
          __FUNCTION__, service_name);
        return NULL;
    }

    /* Load saved parameters. */
    param = stream_get_string(f);

    /* re-connect client */
    QemudClient* c = qemud_service_connect_client(sv, -1, param);
    if (c == NULL)
        return NULL;

    /* Load pending messages. */
    c->ProtocolSelector.Pipe.messages =
            _load_pipe_message(f, &c->ProtocolSelector.Pipe.last_msg);

    /* load client-specific state */
    if (c->clie_load && c->clie_load(f, c, c->clie_opaque)) {
        /* load failure */
        return NULL;
    }

    /* load framing configuration */
    c->framing = stream_get_be32(f);
    if (c->framing) {

        /* header buffer */
        c->need_header = stream_get_be32(f);
        int header_size = stream_get_be32(f);
        if (header_size > FRAME_HEADER_SIZE) {
            D("%s: load failed: payload buffer requires %d bytes, %d available\n",
              __FUNCTION__, header_size, FRAME_HEADER_SIZE);
            return NULL;
        }
        int ret;
        if ((ret = stream_read(f, c->header0, header_size)) != header_size) {
            D("%s: frame header buffer load failed: expected %d bytes, got %d\n",
              __FUNCTION__, header_size, ret);
            return NULL;
        }

        /* payload sink */
        if ((ret = qemud_sink_load(f, c->payload)))
            return NULL;

        /* replace payload buffer by saved data */
        if (c->payload->buff) {
            AFREE(c->payload->buff);
        }

        /* +1 for terminating zero */
        c->payload->buff = static_cast<uint8_t*>(
                _android_array_alloc(sizeof(*c->payload->buff), c->payload->size + 1));
        if ((ret = stream_read(f, c->payload->buff, c->payload->size)) !=
            c->payload->size) {
            D("%s: frame payload buffer load failed: expected %d bytes, got %d\n",
              __FUNCTION__, c->payload->size, ret);
            AFREE(c->payload->buff);
            return NULL;
        }
    }

    /* Associate the client with the pipe. */
    qemud_pipe = static_cast<QemudPipe*>(android_alloc0(sizeof(*qemud_pipe)));
    qemud_pipe->hwpipe = hwpipe;
    qemud_pipe->looper = pipeOpaque;
    qemud_pipe->service = sv;
    qemud_pipe->client = c;
    c->ProtocolSelector.Pipe.qemud_pipe = qemud_pipe;

    return qemud_pipe;
}

/* QEMUD pipe functions.
 */
static const AndroidPipeFuncs _qemudPipe_funcs = {
        _qemudPipe_init,
        _qemudPipe_closeFromGuest,
        _qemudPipe_sendBuffers,
        _qemudPipe_recvBuffers,
        _qemudPipe_poll,
        _qemudPipe_wakeOn,
        _qemudPipe_save,
        _qemudPipe_load,
};

/* Initializes QEMUD pipe interface.
 */
static void _android_qemud_pipe_init(void) {
    static bool _qemud_pipe_initialized = false;

    if (!_qemud_pipe_initialized) {
        android_pipe_add_type("qemud", looper_getForThread(), &_qemudPipe_funcs);
        _qemud_pipe_initialized = true;
    }
}

static bool isInited = false;

void android_qemud_init(CSerialLine* sl) {
    D("%s", __FUNCTION__);
    /* We don't know in advance whether the guest system supports qemud pipes,
     * so we will initialize both qemud machineries, the legacy (over serial
     * port), and the new one (over qemu pipe). Then we let the guest to connect
     * via one, or the other. */
    _android_qemud_serial_init(sl);
    _android_qemud_pipe_init();
    isInited = true;
}

QemudService* qemud_service_register(const char* service_name,
                                     int max_clients,
                                     void* serv_opaque,
                                     QemudServiceConnect serv_connect,
                                     QemudServiceSave serv_save,
                                     QemudServiceLoad serv_load) {
    assert(isInited);

    QemudService* const sv =
            qemud_service_new(service_name,
                              max_clients,
                              serv_opaque,
                              serv_connect,
                              serv_save,
                              serv_load,
                              &qemud_multiplexer->services);
    D("Registered QEMUD service %s", service_name);
    return sv;
}