// 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/qemud/android_qemud_multiplexer.h"

#include "android/emulation/qemud/android_qemud_common.h"
#include "android/utils/bufprint.h"

/* the global multiplexer state */
static QemudMultiplexer mutliplexer_instance;
QemudMultiplexer* const qemud_multiplexer = &mutliplexer_instance;

/* this is the serial_recv callback that is called
 * whenever an incoming message arrives through the serial port
 */
void qemud_multiplexer_serial_recv(void* opaque,
                                   int channel,
                                   uint8_t* msg,
                                   int msglen) {
    QemudMultiplexer* m = (QemudMultiplexer*) opaque;
    // Note: A lock is not needed here.
    QemudClient* c = m->clients;

    /* dispatch to an existing client if possible
     * note that channel 0 is handled by a special
     * QemudClient that is setup in qemud_multiplexer_init()
     */
    for (; c != NULL; c = c->next) {
        if (!qemud_is_pipe_client(c) && c->ProtocolSelector.Serial.channel == channel) {
            qemud_client_recv(c, msg, msglen);
            return;
        }
    }

    D("%s: ignoring %d bytes for unknown channel %d",
      __FUNCTION__, msglen, channel);
}

/* handle a new connection attempt. This returns 0 on
 * success, -1 if the service name is unknown, or -2
 * if the service's maximum number of clients has been
 * reached.
 */
int qemud_multiplexer_connect(QemudMultiplexer* m,
                              const char* service_name,
                              int channel_id) {
    android::base::AutoLock _lock(m->lock);

    /* find the corresponding registered service by name */
    QemudService* sv = qemud_service_find(m->services, service_name);
    if (sv == NULL) {
        D("%s: no registered '%s' service", __FUNCTION__, service_name);
        return -1;
    }

    /* check service's client count */
    if (sv->max_clients > 0 && sv->num_clients >= sv->max_clients) {
        D("%s: registration failed for '%s' service: too many clients (%d)",
          __FUNCTION__, service_name, sv->num_clients);
        return -2;
    }

    /* connect a new client to the service on the given channel */
    if (qemud_service_connect_client(sv, channel_id, NULL) == NULL) {
        return -1;
    }

    return 0;
}

/* disconnect a given client from its channel id */
void qemud_multiplexer_disconnect(QemudMultiplexer* m,
                                  int channel) {
    QemudClient* c;

    /* find the client by its channel id, then disconnect it */
    for (c = m->clients; c; c = c->next) {
        if (!qemud_is_pipe_client(c) && c->ProtocolSelector.Serial.channel == channel) {
            D("%s: disconnecting client %d",
              __FUNCTION__, channel);
            /* note thatt this removes the client from
             * m->clients automatically.
             */
            c->ProtocolSelector.Serial.channel = -1; /* no need to send disconnect:<id> */
            qemud_client_disconnect(c, 0);
            return;
        }
    }
    D("%s: disconnecting unknown channel %d",
      __FUNCTION__, channel);
}

/* disconnects all channels, except for the control channel, without informing
 * the daemon in the guest that disconnection has occurred.
 *
 * Used to silently kill clients when restoring emulator state snapshots.
 */
void qemud_multiplexer_disconnect_noncontrol(QemudMultiplexer* m) {
    QemudClient* c;
    QemudClient* next = m->clients;

    while (next) {
        c = next;
        next = c->next;  /* disconnect frees c, remember next in advance */

        if (!qemud_is_pipe_client(c) && c->ProtocolSelector.Serial.channel > 0) {
            /* skip control channel */
            D("%s: disconnecting client %d",
              __FUNCTION__, c->ProtocolSelector.Serial.channel);
            D("%s: disconnecting client %d\n",
              __FUNCTION__, c->ProtocolSelector.Serial.channel);
            c->ProtocolSelector.Serial.channel = -1; /* do not send disconnect:<id> */
            qemud_client_disconnect(c, 0);
        }
    }
}

/* handle control messages. This is used as the receive
 * callback for the special QemudClient setup to manage
 * channel 0.
 *
 * note that the message is zero-terminated for convenience
 * (i.e. msg[msglen] is a valid memory read that returns '\0')
 */
void qemud_multiplexer_control_recv(void* opaque,
                                    uint8_t* msg,
                                    int msglen,
                                    QemudClient* client) {
    QemudMultiplexer* mult = (QemudMultiplexer*) opaque;
    android::base::AutoLock(mult->lock);
    uint8_t* msgend = msg + msglen;
    char tmp[64], * p = tmp, * end = p + sizeof(tmp);

    /* handle connection attempts.
     * the client message must be "connect:<service-name>:<id>"
     * where <id> is a 2-char hexadecimal string, which must be > 0
     */
    if (msglen > 8 && !memcmp(msg, "connect:", 8)) {
        char* service_name = (char*) msg + 8;
        int channel, ret;
        char* q = strchr(service_name, ':');
        if (q == NULL || q + 3 != (char*) msgend) {
            D("%s: malformed connect message: '%.*s' (offset=%d)",
              __FUNCTION__, msglen, (const char*) msg, q ? q - (char*) msg : -1);
            return;
        }
        *q++ = 0;  /* zero-terminate service name */
        channel = hex2int((uint8_t*) q, 2);
        if (channel <= 0) {
            D("%s: malformed channel id '%.*s",
              __FUNCTION__, 2, q);
            return;
        }

        ret = qemud_multiplexer_connect(mult, service_name, channel);
        /* the answer can be one of:
         *    ok:connect:<id>
         *    ko:connect:<id>:<reason-for-failure>
         */
        if (ret < 0) {
            if (ret == -1) {
                /* could not connect */
                p = bufprint(tmp, end, "ko:connect:%02x:unknown service", channel);
            } else {
                p = bufprint(tmp, end, "ko:connect:%02x:service busy", channel);
            }
        }
        else {
            p = bufprint(tmp, end, "ok:connect:%02x", channel);
        }
        qemud_serial_send(mult->serial, 0, 0, (uint8_t*) tmp, p - tmp);
        return;
    }

    /* handle client disconnections,
     * this message arrives when the client has closed the connection.
     * format: "disconnect:<id>" where <id> is a 2-hex channel id > 0
     */
    if (msglen == 13 && !memcmp(msg, "disconnect:", 11)) {
        int channel_id = hex2int(msg + 11, 2);
        if (channel_id <= 0) {
            D("%s: malformed disconnect channel id: '%.*s'",
              __FUNCTION__, 2, msg + 11);
            return;
        }
        qemud_multiplexer_disconnect(mult, channel_id);
        return;
    }

#if SUPPORT_LEGACY_QEMUD
    /* an ok:connect:<service>:<id> message can be received if we're
     * talking to a legacy qemud daemon, i.e. one running in a 1.0 or
     * 1.1 system image.
     *
     * we should treat is as a normal "connect:" attempt, except that
     * we must not send back any acknowledgment.
     */
    if (msglen > 11 && !memcmp(msg, "ok:connect:", 11)) {
        char*  service_name = (char*)msg + 11;
        char*        q            = strchr(service_name, ':');
        int          channel;

        if (q == NULL || q+3 != (char*)msgend) {
            D("%s: malformed legacy connect message: '%.*s' (offset=%d)",
              __FUNCTION__, msglen, (const char*)msg, q ? q-(char*)msg : -1);
            return;
        }
        *q++ = 0;  /* zero-terminate service name */
        channel = hex2int((uint8_t*)q, 2);
        if (channel <= 0) {
            D("%s: malformed legacy channel id '%.*s",
              __FUNCTION__, 2, q);
            return;
        }

        switch (mult->serial->version) {
        case QEMUD_VERSION_UNKNOWN:
            mult->serial->version = QEMUD_VERSION_LEGACY;
            D("%s: legacy qemud daemon detected.", __FUNCTION__);
            break;

        case QEMUD_VERSION_LEGACY:
            /* nothing unusual */
            break;

        default:
            D("%s: weird, ignoring legacy qemud control message: '%.*s'",
              __FUNCTION__, msglen, msg);
            return;
        }

        /* "hw-control" was called "control" in 1.0/1.1 */
        if (!strcmp(service_name,"control")) {
            // it's safe here: no one will modify the string
            service_name = const_cast<char*>("hw-control");
        }

        qemud_multiplexer_connect(mult, service_name, channel);
        return;
    }

    /* anything else, don't answer for legacy */
    if (mult->serial->version == QEMUD_VERSION_LEGACY) {
        return;
    }
#endif /* SUPPORT_LEGACY_QEMUD */

    /* anything else is a problem */
    p = bufprint(tmp, end, "ko:unknown command");
    qemud_serial_send(mult->serial, 0, 0, (uint8_t*) tmp, p - tmp);
}

/* initialize the global QemudMultiplexer.
 */
void qemud_multiplexer_init(QemudMultiplexer* mult, CSerialLine* serial_line) {
    /* initialize serial handler */
    qemud_serial_init(mult->serial, serial_line,
                      qemud_multiplexer_serial_recv,
                      mult);

    /* setup listener for channel 0 */
    qemud_client_alloc(0,
                       NULL,
                       mult,
                       qemud_multiplexer_control_recv,
                       NULL, NULL, NULL,
                       mult->serial,
                       &mult->clients);
}

/** SNAPSHOT SUPPORT
 **/

/* Saves the number of clients.
 */
static void qemud_client_save_count(Stream* f, QemudClient* c) {
    unsigned int client_count = 0;
    for (; c; c = c->next)   // walk over linked list
        /* skip control channel, which is not saved, and pipe channels that
         * are saved along with the pipe. */
        if (!qemud_is_pipe_client(c) && c->ProtocolSelector.Serial.channel > 0)
            client_count++;

    stream_put_be32(f, client_count);
}

/* Saves the number of services currently available.
 */
static void qemud_service_save_count(Stream* f, QemudService* s) {
    unsigned int service_count = 0;
    for (; s; s = s->next)  // walk over linked list
        service_count++;

    stream_put_be32(f, service_count);
}

/* Removes all active non-control clients, then creates new ones with state
 * taken from the snapshot.
 *
 * We do not send "disconnect" commands, over the channel. If we did, we might
 * stop clients in the restored guest, resulting in an incorrect restore.
 *
 * Instead, we silently replace the clients that were running before the
 * restore with new clients, whose state we copy from the snapshot. Since
 * everything is multiplexed over one link, only the multiplexer notices the
 * changes, there is no communication with the guest.
 */
static int qemud_load_clients(Stream* f, QemudMultiplexer* m, int version) {

    /* Remove all clients, except on the control channel.*/
    qemud_multiplexer_disconnect_noncontrol(m);

    /* Load clients from snapshot */
    int client_count = stream_get_be32(f);
    int i, ret;
    for (i = 0; i < client_count; i++) {
        if ((ret = qemud_serial_client_load(f, m->services, version))) {
            return ret;
        }
    }

    return 0;
}

/* Checks whether the same services are available at this point as when the
 * snapshot was made.
 */
static int qemud_load_services(Stream* f, QemudService* current_services) {
    int i, ret = 0;
    int service_count = stream_get_be32(f);
    for (i = 0; i < service_count; i++) {
        if ((ret = qemud_service_load(f, current_services))) {
            break;
        }
    }
    return ret;
}

int qemud_multiplexer_load(QemudMultiplexer* m,
                           Stream* stream,
                           int version) {
    int ret = 0;
    android::base::AutoLock(m->lock);

    ret = qemud_serial_load(stream, m->serial);
    if (!ret) {
        ret = qemud_load_services(stream, m->services);
        if (!ret) {
            ret = qemud_load_clients(stream, m, version);
        }
    }
    return ret;
}

void qemud_multiplexer_save(QemudMultiplexer* m, Stream* stream) {
    android::base::AutoLock(m->lock);

    /* save serial state if any */
    qemud_serial_save(stream, m->serial);

    /* save service states */
    qemud_service_save_count(stream, m->services);
    QemudService* s;
    for (s = m->services; s; s = s->next)
        qemud_service_save(stream, s);

    /* save client channels */
    qemud_client_save_count(stream, m->clients);
    QemudClient* c;
    for (c = m->clients; c; c = c->next) {
        /* skip control channel, and pipe clients */
        if (!qemud_is_pipe_client(c) && c->ProtocolSelector.Serial.channel > 0) {
            qemud_serial_client_save(stream, c);
        }
    }
}