rockbox/utils/hwstub/lib/hwstub_net.cpp

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2016 by Amaury Pouly
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/
#include "hwstub_net.hpp"
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <cstddef>
#include <arpa/inet.h>
#include <sys/types.h>
#include <netdb.h>

namespace hwstub {
namespace net {

/**
 * Context
 */
context::context()
    :m_state(state::HELLO), m_error(error::SUCCESS)
{
}

context::~context()
{
}

std::shared_ptr<context> context::create_socket(int socket_fd)
{
    // NOTE: can't use make_shared() because of the protected ctor */
    return std::shared_ptr<socket_context>(new socket_context(socket_fd));
}

std::string context::default_unix_path()
{
    return "hwstub";
}

std::string context::default_tcp_domain()
{
    return "localhost";
}

std::string context::default_tcp_port()
{
    return "6666";
}

namespace
{
    /* len is the total length, including a 0 character if any */
    int create_unix_low(bool abstract, const char *path, size_t len, bool conn,
        std::string *error)
    {
        struct sockaddr_un address;
        if(len > sizeof(address.sun_path))
        {
            if(error)
                *error = "unix path is too long";
            return -1;
        }
        int socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
        if(socket_fd < 0)
        {
            if(error)
                *error = "socket() failed";
            return -1;
        }
        memset(&address, 0, sizeof(struct sockaddr_un));
        address.sun_family = AF_UNIX;
        /* NOTE memcpy, we don't want to add a extra 0 at the end */
        memcpy(address.sun_path, path, len);
        /* for abstract name, replace first character by 0 */
        if(abstract)
            address.sun_path[0] = 0;
        /* NOTE sun_path is the last field of the structure */
        size_t sz = offsetof(struct sockaddr_un, sun_path) + len;
        /* NOTE don't give sizeof(address) because for abstract names it would contain
         * extra garbage */
        if(conn)
        {
            if(connect(socket_fd, (struct sockaddr *)&address,  sz) != 0)
            {
                close(socket_fd);
                if(error)
                    *error = "connect() failed";
                return -1;
            }
            else
                return socket_fd;
        }
        else
        {
            if(bind(socket_fd, (struct sockaddr *)&address,  sz) != 0)
            {
                close(socket_fd);
                if(error)
                    *error = "bind() failed";
                return -1;
            }
            else
                return socket_fd;
        }
    }

    int create_tcp_low(const std::string& domain, const std::string& _port, bool server, std::string *error)
    {
        std::string port = _port.size() != 0 ? _port : context::default_tcp_port();
        int socket_fd = -1;
        struct addrinfo hints;
        memset(&hints, 0, sizeof(struct addrinfo));
        hints.ai_family = AF_UNSPEC; /* allow IPv4 or IPv6 */
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_flags = 0;
        hints.ai_protocol = 0; /* any protocol */

        struct addrinfo *result;
        int err = getaddrinfo(domain.c_str(), port.c_str(), &hints, &result);
        if(err != 0)
        {
            freeaddrinfo(result);
            if(error)
                *error = std::string("getaddrinfo failed: ") + gai_strerror(err);
            return -1;
        }

        /* getaddrinfo() returns a list of address structures.
        * Try each address until we successfully connect(2).
        * If socket(2) (or connect(2)/bind(2)) fails, we (close the socket
        * and) try the next address. */
        for(struct addrinfo *rp = result; rp != nullptr; rp = rp->ai_next)
        {
            socket_fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
            if(socket_fd == -1)
                continue;

            int err = 0;
            if(server)
                err = bind(socket_fd, rp->ai_addr, rp->ai_addrlen);
            else
                err = connect(socket_fd, rp->ai_addr, rp->ai_addrlen);
            if(err < 0)
            {
                close(socket_fd);
                socket_fd = -1;
            }
            else
                break; /* success */
        }
        freeaddrinfo(result);
        /* no address was tried */
        if(socket_fd < 0 && error)
            *error = "getaddrinfo() returned no usable result (socket()/connect()/bind() failed)";
        return socket_fd;
    }
}

std::shared_ptr<context> context::create_tcp(const std::string& domain,
    const std::string& port, std::string *error)
{
    int fd = create_tcp_low(domain, port, false, error);
    if(fd >= 0)
        return context::create_socket(fd);
    else
        return std::shared_ptr<context>();
}

std::shared_ptr<context> context::create_unix(const std::string& path, std::string *error)
{
    int fd = create_unix_low(false, path.c_str(), path.size() + 1, true, error);
    if(fd >= 0)
        return context::create_socket(fd);
    else
        return std::shared_ptr<context>();
}

std::shared_ptr<context> context::create_unix_abstract(const std::string& path, std::string *error)
{
    std::string fake_path = "#" + path; /* the # will be overriden by 0 */
    int fd = create_unix_low(true, fake_path.c_str(), fake_path.size(), true, error);
    if(fd >= 0)
        return context::create_socket(fd);
    else
        return std::shared_ptr<context>();
}

uint32_t context::from_ctx_dev(ctx_dev_t dev)
{
    return (uint32_t)(uintptr_t)dev; /* NOTE safe because it was originally a 32-bit int */
}

hwstub::context::ctx_dev_t context::to_ctx_dev(uint32_t dev)
{
    return (ctx_dev_t)(uintptr_t)dev; /* NOTE assume that sizeof(void *)>=sizeof(uint32_t) */
}

error context::fetch_device_list(std::vector<ctx_dev_t>& list, void*& ptr)
{
    (void) ptr;
    delayed_init();
    if(m_state == state::DEAD)
        return m_error;
    uint32_t args[HWSTUB_NET_ARGS] = {0};
    uint8_t *data = nullptr;
    size_t data_sz = 0;
    debug() << "[net::ctx] --> GET_DEV_LIST\n";
    error err = send_cmd(HWSERVER_GET_DEV_LIST, args, nullptr, 0, &data, &data_sz);
    debug() << "[net::ctx] <-- GET_DEV_LIST ";
    if(err != error::SUCCESS)
    {
        debug() << "failed: " << error_string(err) << "\n";
        return err;
    }
    /* sanity check on size */
    if(data_sz % 4)
    {
        debug() << "failed: invalid list size\n";
        delete[] data;
        return error::PROTOCOL_ERROR;
    }
    debug() << "\n";
    list.clear();
    /* each entry is a 32-bit ID in network order size */
    uint32_t *data_list = (uint32_t *)data;
    for(size_t i = 0; i < data_sz / 4; i++)
        list.push_back(to_ctx_dev(from_net_order(data_list[i])));
    delete[] data;
    return error::SUCCESS;
}

void context::destroy_device_list(void *ptr)
{
    (void)ptr;
}

error context::create_device(ctx_dev_t dev, std::shared_ptr<hwstub::device>& hwdev)
{
    // NOTE: can't use make_shared() because of the protected ctor */
    hwdev.reset(new device(shared_from_this(), from_ctx_dev(dev)));
    return error::SUCCESS;
}

bool context::match_device(ctx_dev_t dev, std::shared_ptr<hwstub::device> hwdev)
{
    device *udev = dynamic_cast<device*>(hwdev.get());
    return udev != nullptr && udev->device_id() == from_ctx_dev(dev);
}

uint32_t context::to_net_order(uint32_t u)
{
    return htonl(u);
}

uint32_t context::from_net_order(uint32_t u)
{
    return ntohl(u);
}

error context::send_cmd(uint32_t cmd, uint32_t args[HWSTUB_NET_ARGS], uint8_t *send_data,
    size_t send_size, uint8_t **recv_data, size_t *recv_size)
{
    /* make sure with have the lock, this function might be called concurrently
     * by the different threads */
    std::unique_lock<std::recursive_mutex> lock(m_mutex);

    if(m_state == state::DEAD)
        return m_error;
    /* do a delayed init, unless we are doing a HELLO */
    if(m_state == state::HELLO && cmd != HWSERVER_HELLO)
        delayed_init();
    /* build header */
    struct hwstub_net_hdr_t hdr;
    hdr.magic = to_net_order(HWSERVER_MAGIC);
    hdr.cmd = to_net_order(cmd);
    for(size_t i = 0; i < HWSTUB_NET_ARGS; i++)
        hdr.args[i] = to_net_order(args[i]);
    hdr.length = to_net_order((uint32_t)send_size);
    /* send header */
    size_t sz = sizeof(hdr);
    error err = send((void *)&hdr, sz);
    if(err != error::SUCCESS)
    {
        m_state = state::DEAD;
        m_error = err;
        return err;
    }
    if(sz != sizeof(hdr))
    {
        m_state = state::DEAD;
        m_error = error::PROTOCOL_ERROR;
    }
    /* send data */
    if(send_size > 0)
    {
        sz = send_size;
        err = send((void *)send_data, sz);
        if(err != error::SUCCESS)
        {
            m_state = state::DEAD;
            m_error = err;
            return err;
        }
        if(sz != send_size)
        {
            m_state = state::DEAD;
            m_error = error::PROTOCOL_ERROR;
        }
    }
    /* receive header */
    sz = sizeof(hdr);
    err = recv((void *)&hdr, sz);
    if(err != error::SUCCESS)
    {
        m_state = state::DEAD;
        m_error = err;
        return err;
    }
    if(sz != sizeof(hdr))
    {
        m_state = state::DEAD;
        m_error = error::PROTOCOL_ERROR;
        return m_error;
    }
    /* correct byte order */
    hdr.magic = from_net_order(hdr.magic);
    hdr.cmd = from_net_order(hdr.cmd);
    hdr.length = from_net_order(hdr.length);
    /* copy arguments */
    for(size_t i = 0; i < HWSTUB_NET_ARGS; i++)
        args[i] = from_net_order(hdr.args[i]);
    /* check header */
    if(hdr.magic != HWSERVER_MAGIC)
    {
        m_state = state::DEAD;
        m_error = error::PROTOCOL_ERROR;
        return m_error;
    }
    /* check NACK */
    if(hdr.cmd == HWSERVER_NACK(cmd))
    {
        /* translate error */
        switch(args[0])
        {
            case HWERR_FAIL: err = error::ERROR; break;
            case HWERR_INVALID_ID: err = error::ERROR; break; /* should not happen */
            case HWERR_DISCONNECTED: err = error::DISCONNECTED; break;
        }
        return err;
    }
    /* check not ACK */
    if(hdr.cmd != HWSERVER_ACK(cmd))
    {
        m_state = state::DEAD;
        m_error = error::PROTOCOL_ERROR;
        return m_error;
    }
    /* receive additional data */
    uint8_t *data = nullptr;
    if(hdr.length > 0)
    {
        data = new uint8_t[hdr.length];
        sz = hdr.length;
        err = recv((void *)data, sz);
        if(err != error::SUCCESS)
        {
            m_state = state::DEAD;
            m_error = err;
            return err;
        }
        if(sz != hdr.length)
        {
            m_state = state::DEAD;
            m_error = error::PROTOCOL_ERROR;
            return m_error;
        }
    }
    /* copy data if user want it */
    if(recv_data)
    {
        if(*recv_data == nullptr)
        {
            *recv_data = data;
            *recv_size = hdr.length;
        }
        else if(*recv_size < hdr.length)
        {
            delete[] data;
            return error::OVERFLW;
        }
        else
        {
            *recv_size = hdr.length;
            memcpy(*recv_data, data, *recv_size);
            delete[] data;
        }
    }
    /* throw it away otherwise */
    else
    {
        delete[] data;
    }
    return error::SUCCESS;
}

void context::delayed_init()
{
    /* only do HELLO if we haven't do it yet */
    if(m_state != state::HELLO)
        return;
    debug() << "[net::ctx] --> HELLO " << HWSTUB_VERSION_MAJOR << "."
        << HWSTUB_VERSION_MINOR << "\n";
    /* send HELLO with our version and see what the server is up to */
    uint32_t args[HWSTUB_NET_ARGS] = {0};
    args[0] = HWSTUB_VERSION_MAJOR << 8 | HWSTUB_VERSION_MINOR;
    error err = send_cmd(HWSERVER_HELLO, args, nullptr, 0, nullptr, nullptr);
    if(err != error::SUCCESS)
    {
        debug() << "[net::ctx] <-- HELLO failed: " << error_string(err) << "\n";
        m_state = state::DEAD;
        m_error = err;
        return;
    }
    /* check the server is running the same version */
    debug() << "[net::ctx] <-- HELLO " << ((args[0] & 0xff00) >> 8) << "." << (args[0] & 0xff) << "";
    if(args[0] != (HWSTUB_VERSION_MAJOR << 8 | HWSTUB_VERSION_MINOR))
    {
        debug() << " (mismatch)\n";
        m_state = state::DEAD;
        m_error = error::SERVER_MISMATCH;
    }
    debug() << " (good)\n";
    /* good, we can now send commands */
    m_state = state::IDLE;
}

void context::stop_context()
{
    /* make sure with have the lock, this function might be called asynchronously */
    std::unique_lock<std::recursive_mutex> lock(m_mutex);
    /* if dead, don't do anything */
    if(m_state == state::DEAD)
        return;
    /* only send BYE if we are initialized */
    if(m_state == state::IDLE)
    {
        debug() << "[net::ctx] --> BYE\n";
        /* send BYE */
        uint32_t args[HWSTUB_NET_ARGS] = {0};
        error err = send_cmd(HWSERVER_BYE, args, nullptr, 0, nullptr, nullptr);
        if(err != error::SUCCESS)
        {
            debug() << "[net::ctx] <-- BYE failed: " << error_string(err) << "\n";
            m_state = state::DEAD;
            m_error = err;
            return;
        }
        debug() << "[net::ctx] <-- BYE\n";
    }
    /* now we are dead */
    m_state = state::DEAD;
    m_error = error::SERVER_DISCONNECTED;
}

/**
 * Socket context
 */
socket_context::socket_context(int socket_fd)
    :m_socketfd(socket_fd)
{
    set_timeout(std::chrono::milliseconds(1000));
}

socket_context::~socket_context()
{
    stop_context();
    close(m_socketfd);
}

void socket_context::set_timeout(std::chrono::milliseconds ms)
{
    struct timeval tv;
    tv.tv_usec = 1000 * (ms.count() % 1000);
    tv.tv_sec = ms.count() / 1000;
     /* set timeout for the client operations */
    setsockopt(m_socketfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));
    setsockopt(m_socketfd, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv));
}

error socket_context::send(void *buffer, size_t& sz)
{
    debug() << "[net::ctx::sock] send(" << sz << "): ";
    int ret = ::send(m_socketfd, buffer, sz, MSG_NOSIGNAL);
    if(ret >= 0)
    {
        debug() << "good(" << ret << ")\n";
        sz = (size_t)ret;
        return error::SUCCESS;
    }
    /* convert some errors */
    debug() << "fail(" << errno << "," << strerror(errno) << ")\n";
    switch(errno)
    {
#if EAGAIN != EWOULDBLOCK
        case EAGAIN:
#endif
        case EWOULDBLOCK: return error::TIMEOUT;
        case ECONNRESET: case EPIPE: return error::SERVER_DISCONNECTED;
        default: return error::NET_ERROR;
    }
}

error socket_context::recv(void *buffer, size_t& sz)
{
    debug() << "[net::ctx::sock] recv(" << sz << "): ";
    int ret = ::recv(m_socketfd, buffer, sz, MSG_WAITALL);
    if(ret > 0)
    {
        debug() << "good(" << ret << ")\n";
        sz = (size_t)ret;
        return error::SUCCESS;
    }
    if(ret == 0)
    {
        debug() << "disconnected\n";
        return error::SERVER_DISCONNECTED;
    }
    debug() << "fail(" << errno << "," << strerror(errno) << ")\n";
    switch(errno)
    {
#if EAGAIN != EWOULDBLOCK
        case EAGAIN:
#endif
        case EWOULDBLOCK: return error::TIMEOUT;
        default: return error::NET_ERROR;
    }
}

/**
 * Device
 */
device::device(std::shared_ptr<hwstub::context> ctx, uint32_t devid)
    :hwstub::device(ctx), m_device_id(devid)
{
}

device::~device()
{
}

uint32_t device::device_id()
{
    return m_device_id;
}

error device::open_dev(std::shared_ptr<hwstub::handle>& handle)
{
    std::shared_ptr<hwstub::context> hctx = get_context();
    if(!hctx)
        return error::NO_CONTEXT;
    context *ctx = dynamic_cast<context*>(hctx.get());
    ctx->debug() << "[net::dev] --> DEV_OPEN(" << m_device_id << ")\n";
    /* ask the server to open the device, note that the device ID may not exists
     * anymore */
    uint32_t args[HWSTUB_NET_ARGS] = {0};
    args[0] = m_device_id;
    error err = ctx->send_cmd(HWSERVER_DEV_OPEN, args, nullptr, 0, nullptr, nullptr);
    if(err != error::SUCCESS)
    {
        ctx->debug() << "[net::ctx::dev] <-- DEV_OPEN failed: " << error_string(err) << "\n";
        return err;
    }
    ctx->debug() << "[net::ctx::dev] <-- DEV_OPEN: handle = " << args[0] << "\n";
    // NOTE: can't use make_shared() because of the protected ctor */
    handle.reset(new hwstub::net::handle(shared_from_this(), args[0]));
    return error::SUCCESS;
}

bool device::has_multiple_open() const
{
    return false;
}

/**
 * Handle
 */
handle::handle(std::shared_ptr<hwstub::device> dev, uint32_t hid)
    :hwstub::handle(dev), m_handle_id(hid)
{
}

handle::~handle()
{
    /* try to close the handle, if context is still accessible */
    std::shared_ptr<hwstub::context> hctx = get_device()->get_context();
    if(hctx)
    {
        context *ctx = dynamic_cast<context*>(hctx.get());
        ctx->debug() << "[net::handle] --> DEV_CLOSE(" << m_handle_id << ")\n";
        uint32_t args[HWSTUB_NET_ARGS] = {0};
        args[0] = m_handle_id;
        error err = ctx->send_cmd(HWSERVER_DEV_CLOSE, args, nullptr, 0, nullptr, nullptr);
        if(err != error::SUCCESS)
            ctx->debug() << "[net::handle] <-- DEV_CLOSE failed: " << error_string(err) << "\n";
        else
            ctx->debug() << "[net::handle] <-- DEV_CLOSE\n";
    }
}

error handle::read_dev(uint32_t addr, void *buf, size_t& sz, bool atomic)
{
    std::shared_ptr<hwstub::context> hctx = get_device()->get_context();
    if(!hctx)
        return error::NO_CONTEXT;

    context *ctx = dynamic_cast<context*>(hctx.get());
    ctx->debug() << "[net::handle] --> READ(" << m_handle_id << ",0x" << std::hex
        << addr << "," << sz << "," << atomic << ")\n";
    uint32_t args[HWSTUB_NET_ARGS] = {0};
    args[0] = m_handle_id;
    args[1] = addr;
    args[2] = sz;
    args[3] = atomic ? HWSERVER_RW_ATOMIC : 0;
    error err = ctx->send_cmd(HWSERVER_READ, args, nullptr, 0, (uint8_t **)&buf, &sz);
    if(err != error::SUCCESS)
    {
        ctx->debug() << "[net::handle] <-- READ failed: " << error_string(err) << "\n";
        return err;
    }
    ctx->debug() << "[net::handle] <-- READ\n";
    return error::SUCCESS;
}

error handle::write_dev(uint32_t addr, const void *buf, size_t& sz, bool atomic)
{
    std::shared_ptr<hwstub::context> hctx = get_device()->get_context();
    if(!hctx)
        return error::NO_CONTEXT;

    context *ctx = dynamic_cast<context*>(hctx.get());
    ctx->debug() << "[net::handle] --> WRITE(" << m_handle_id << ",0x" << std::hex
        << addr << "," << sz << "," << atomic << ")\n";
    uint32_t args[HWSTUB_NET_ARGS] = {0};
    args[0] = m_handle_id;
    args[1] = addr;
    args[2] = atomic ? HWSERVER_RW_ATOMIC : 0;
    error err = ctx->send_cmd(HWSERVER_WRITE, args, (uint8_t *)buf, sz, nullptr, nullptr);
    if(err != error::SUCCESS)
    {
        ctx->debug() << "[net::handle] <-- WRITE failed: " << error_string(err) << "\n";
        return err;
    }
    ctx->debug() << "[net::handle] <-- WRITE\n";
    return error::SUCCESS;
}

error handle::get_dev_desc(uint16_t desc, void *buf, size_t& buf_sz)
{
    std::shared_ptr<hwstub::context> hctx = get_device()->get_context();
    if(!hctx)
        return error::NO_CONTEXT;

    context *ctx = dynamic_cast<context*>(hctx.get());
    ctx->debug() << "[net::handle] --> GET_DESC(" << m_handle_id << ",0x" << std::hex
        << desc << "," << buf_sz << ")\n";
    uint32_t args[HWSTUB_NET_ARGS] = {0};
    args[0] = m_handle_id;
    args[1] = desc;
    args[2] = buf_sz;
    error err = ctx->send_cmd(HWSERVER_GET_DESC, args, nullptr, 0, (uint8_t **)&buf, &buf_sz);
    if(err != error::SUCCESS)
    {
        ctx->debug() << "[net::handle] <-- GET_DESC failed: " << error_string(err) << "\n";
        return err;
    }
    ctx->debug() << "[net::handle] <-- GET_DESC\n";
    return error::SUCCESS;
}

error handle::get_dev_log(void *buf, size_t& buf_sz)
{
    std::shared_ptr<hwstub::context> hctx = get_device()->get_context();
    if(!hctx)
        return error::NO_CONTEXT;

    context *ctx = dynamic_cast<context*>(hctx.get());
    ctx->debug() << "[net::handle] --> GET_LOG(" << buf_sz << ")\n";
    uint32_t args[HWSTUB_NET_ARGS] = {0};
    args[0] = m_handle_id;
    args[1] = buf_sz;
    error err = ctx->send_cmd(HWSERVER_GET_LOG, args, nullptr, 0, (uint8_t **)&buf, &buf_sz);
    if(err != error::SUCCESS)
    {
        ctx->debug() << "[net::handle] <-- GET_LOG failed: " << error_string(err) << "\n";
        return err;
    }
    ctx->debug() << "[net::handle] <-- GET_LOG\n";
    return error::SUCCESS;
}

error handle::exec_dev(uint32_t addr, uint16_t flags)
{
    std::shared_ptr<hwstub::context> hctx = get_device()->get_context();
    if(!hctx)
        return error::NO_CONTEXT;

    context *ctx = dynamic_cast<context*>(hctx.get());
    ctx->debug() << "[net::handle] --> EXEC(" << m_handle_id << ",0x" << std::hex
        << addr << ", 0x" << std::hex << flags << ")\n";
    uint32_t args[HWSTUB_NET_ARGS] = {0};
    args[0] = m_handle_id;
    args[1] = addr;
    args[2] = flags;
    error err = ctx->send_cmd(HWSERVER_EXEC, args, nullptr, 0, nullptr, nullptr);
    if(err != error::SUCCESS)
    {
        ctx->debug() << "[net::handle] <-- EXEC failed: " << error_string(err) << "\n";
        return err;
    }
    ctx->debug() << "[net::handle] <-- EXEC\n";
    return error::SUCCESS;
}

error handle::cop_dev(uint8_t op, uint8_t args[HWSTUB_COP_ARGS],
    const void *out_data, size_t out_size, void *in_data, size_t *in_size)
{
    (void) op;
    (void) args;
    (void) out_data;
    (void) out_size;
    (void) in_data;
    (void) in_size;
    return error::UNIMPLEMENTED;
}

error handle::status() const
{
    return hwstub::handle::status();
}

size_t handle::get_buffer_size()
{
    return 2048;
}

/**
 * Server
 */
server::server(std::shared_ptr<hwstub::context> ctx)
    :m_context(ctx)
{
    clear_debug();
}

server::~server()
{
}

void server::stop_server()
{
    std::unique_lock<std::recursive_mutex> lock(m_mutex);
    /* ask all client threads to stop */
    for(auto& cl : m_client)
        cl.exit = true;
    /* wait for each thread to stop */
    for(auto& cl : m_client)
        cl.future.wait();
}

std::shared_ptr<server> server::create_unix(std::shared_ptr<hwstub::context> ctx,
    const std::string& path, std::string *error)
{
    int fd = create_unix_low(false, path.c_str(), path.size() + 1, false, error);
    if(fd >= 0)
        return socket_server::create_socket(ctx, fd);
    else
        return std::shared_ptr<server>();
}

std::shared_ptr<server> server::create_unix_abstract(std::shared_ptr<hwstub::context> ctx,
    const std::string& path, std::string *error)
{
    std::string fake_path = "#" + path; /* the # will be overriden by 0 */
    int fd = create_unix_low(true, fake_path.c_str(), fake_path.size(), false, error);
    if(fd >= 0)
        return socket_server::create_socket(ctx, fd);
    else
        return std::shared_ptr<server>();
}

std::shared_ptr<server> server::create_socket(std::shared_ptr<hwstub::context> ctx,
    int socket_fd)
{
    return socket_server::create(ctx, socket_fd);
}

std::shared_ptr<server> server::create_tcp(std::shared_ptr<hwstub::context> ctx,
    const std::string& domain, const std::string& port, std::string *error)
{
    int fd = create_tcp_low(domain, port, true, error);
    if(fd >= 0)
        return socket_server::create_socket(ctx, fd);
    else
        return std::shared_ptr<server>();
}

void server::set_debug(std::ostream& os)
{
    m_debug = &os;
}

std::ostream& server::debug()
{
    return *m_debug;
}

server::client_state::client_state(srv_client_t cl, std::future<void>&& f)
    :client(cl), future(std::move(f)), exit(false), next_dev_id(42),
    next_handle_id(19)
{
}

void server::client_thread2(server *s, client_state *cs)
{
    s->client_thread(cs);
}

uint32_t server::to_net_order(uint32_t u)
{
    return htonl(u);
}

uint32_t server::from_net_order(uint32_t u)
{
    return ntohl(u);
}

void server::client_thread(client_state *state)
{
    debug() << "[net::srv::client] start: " << state->client << "\n";
    while(!state->exit)
    {
        /* wait for some header */
        struct hwstub_net_hdr_t hdr;
        size_t sz = sizeof(hdr);
        error err;
        /* wait for some command, or exit flag */
        do
            err = recv(state->client, (void *)&hdr, sz);
        while(err == error::TIMEOUT && !state->exit);
        if(state->exit || err != error::SUCCESS || sz != sizeof(hdr))
            break;
        /* convert to host order */
        hdr.magic = from_net_order(hdr.magic);
        hdr.cmd = from_net_order(hdr.cmd);
        hdr.length = from_net_order(hdr.length);
        /* copy arguments */
        for(size_t i = 0; i < HWSTUB_NET_ARGS; i++)
            hdr.args[i] = from_net_order(hdr.args[i]);
        /* check header */
        if(hdr.magic != HWSERVER_MAGIC)
            break;
        /* receive data
         * FIXME check length here */
        uint8_t *data = nullptr;
        if(hdr.length > 0)
        {
            data = new uint8_t[hdr.length];
            sz = hdr.length;
            /* wait for some command, or exit flag */
            do
                err = recv(state->client, (void *)data, sz);
            while(err == error::TIMEOUT && !state->exit);
            if(state->exit || err != error::SUCCESS || sz != hdr.length)
            {
                delete[] data;
                break;
            }
        }
        /* hande command */
        uint8_t *send_data = nullptr;
        size_t send_size = 0;
        err = handle_cmd(state, hdr.cmd, hdr.args, data, hdr.length,
            send_data, send_size);
        /* free data */
        delete[] data;
        /* construct header */
        if(err != error::SUCCESS)
        {
            hdr.magic = to_net_order(HWSERVER_MAGIC);
            hdr.cmd = to_net_order(HWSERVER_NACK(hdr.cmd));
            hdr.length = to_net_order(0);
            hdr.args[0] = to_net_order(HWERR_FAIL);
            for(size_t i = 1; i < HWSTUB_NET_ARGS; i++)
                hdr.args[i] = to_net_order(0);
            send_size = 0;
        }
        else
        {
            hdr.magic = to_net_order(HWSERVER_MAGIC);
            hdr.cmd = to_net_order(HWSERVER_ACK(hdr.cmd));
            hdr.length = to_net_order(send_size);
            for(size_t i = 0; i < HWSTUB_NET_ARGS; i++)
                hdr.args[i] = to_net_order(hdr.args[i]);
        }
        /* send header */
        sz = sizeof(hdr);
        do
            err = send(state->client, (void *)&hdr, sz);
        while(err == error::TIMEOUT && !state->exit);
        if(state->exit || err != error::SUCCESS || sz != sizeof(hdr))
        {
            delete[] send_data;
            break;
        }
        /* send data if there is some */
        if(send_size > 0)
        {
            sz = send_size;
            do
                err = send(state->client, (void *)send_data, sz);
            while(err == error::TIMEOUT && !state->exit);
            delete[] send_data;
            if(state->exit || err != error::SUCCESS || sz != send_size)
                break;
        }
    }
    debug() << "[net::srv::client] stop: " << state->client << "\n";
    /* clean client state to avoid keeping references to objets */
    state->dev_map.clear();
    state->handle_map.clear();
    /* kill client */
    terminate_client(state->client);
}

void server::client_arrived(srv_client_t client)
{
    std::unique_lock<std::recursive_mutex> lock(m_mutex);
    debug() << "[net::srv] client arrived: " << client << "\n";
    /* the naive way would be to use a std::thread but this class is annoying
     * because it is impossible to check if a thread has exited, except by calling
     * join() which is blocking. Fortunately, std::packaged_task and std::future
     * provide a way around this */

    std::packaged_task<void(server*, client_state*)> task(&server::client_thread2);
    m_client.emplace_back(client, task.get_future());
    std::thread(std::move(task), this, &m_client.back()).detach();
}

void server::client_left(srv_client_t client)
{
    std::unique_lock<std::recursive_mutex> lock(m_mutex);
    debug() << "[net::srv] client left: " << client << "\n";
    /* find thread and set its exit flag, also cleanup threads that finished */
    for(auto it = m_client.begin(); it != m_client.end();)
    {
        /* check if thread has finished */
        if(it->future.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready)
        {
            it = m_client.erase(it);
            continue;
        }
        /* set exit flag if this our thread */
        if(it->client == client)
            it->exit = true;
        ++it;
    }
}

error server::handle_cmd(client_state *state, uint32_t cmd, uint32_t args[HWSTUB_NET_ARGS],
    uint8_t *recv_data, size_t recv_size, uint8_t*& send_data, size_t& send_size)
{
    send_data = nullptr;
    send_size = 0;
    /* NOTE: commands are serialized by the client thread, this function is thus
     * thread safe WITH RESPECT TO CLIENT DATA. If you need to use global data here,
     * protect it by a mutex or make sure it is safe (hwstub context is thread-safe) */

    /* HELLO */
    if(cmd == HWSERVER_HELLO)
    {
        debug() << "[net::srv::cmd] --> HELLO " << ((args[0] & 0xff00) >> 8)
            << "." << (args[0] & 0xff);
        if(args[0] != (HWSTUB_VERSION_MAJOR << 8 | HWSTUB_VERSION_MINOR))
        {
            debug() << " (mismatch)\n";
            return error::ERROR;
        }
        debug() << " (good)\n";
        debug() << "[net::srv::cmd] <-- HELLO " << HWSTUB_VERSION_MAJOR << "."
            << HWSTUB_VERSION_MINOR << "\n";
        /* send HELLO with our version */
        args[0] = HWSTUB_VERSION_MAJOR << 8 | HWSTUB_VERSION_MINOR;
        return error::SUCCESS;
    }
    /* BYE */
    else if(cmd == HWSERVER_BYE)
    {
        debug() << "[net::srv::cmd] --> BYE\n";
        /* ask client thread to exit after this */
        state->exit = true;
        debug() << "[net::srv::cmd] <-- BYE\n";
        return error::SUCCESS;
    }
    /* GET_DEV_LIST */
    else if(cmd == HWSERVER_GET_DEV_LIST)
    {
        debug() << "[net::srv::cmd] --> GET_DEV_LIST\n";
        /* fetch list again */
        std::vector<std::shared_ptr<hwstub::device>> list;
        error err = m_context->get_device_list(list);
        if(err != error::SUCCESS)
        {
            debug() << "[net::srv::cmd] cannot fetch list: " << hwstub::error_string(err) << "\n";
            debug() << "[net::srv::cmd] <-- GET_DEV_LIST (error)\n";
            return err;
        }
        /* update list: drop device that left */
        std::vector<uint32_t> to_drop;
        for(auto it : state->dev_map)
        {
            bool still_there = false;
            /* this has quadratic complexity, optimize this if needed */
            for(auto dev : list)
                if(it.second == dev)
                    still_there = true;
            if(!still_there)
                to_drop.push_back(it.first);
        }
        for(auto id : to_drop)
            state->dev_map.erase(state->dev_map.find(id));
        /* add new devices */
        std::vector<std::shared_ptr<hwstub::device>> to_add;
        for(auto dev : list)
        {
            bool already_there = false;
            for(auto it : state->dev_map)
                if(it.second == dev)
                    already_there = true;
            if(!already_there)
                to_add.push_back(dev);
        }
        for(auto dev : to_add)
            state->dev_map[state->next_dev_id++] = dev;
        /* create response list */
        send_size = sizeof(uint32_t) * state->dev_map.size();
        send_data = new uint8_t[send_size];
        uint32_t *p = (uint32_t *)send_data;
        for(auto it : state->dev_map)
            *p++ = to_net_order(it.first);
        debug() << "[net::srv::cmd] <-- GET_DEV_LIST\n";
        return error::SUCCESS;
    }
    /* DEV_OPEN */
    else if(cmd == HWSERVER_DEV_OPEN)
    {
        uint32_t devid = args[0];
        debug() << "[net::srv::cmd] --> DEV_OPEN(" << devid << ")\n";
        /* check ID is valid */
        auto it = state->dev_map.find(devid);
        if(it == state->dev_map.end())
        {
            debug() << "[net::srv::cmd] unknwon device ID\n";
            debug() << "[net::srv::cmd] <-- DEV_OPEN (error)\n";
            return error::ERROR;
        }
        /* good, now try to get a handle */
        std::shared_ptr<hwstub::handle> handle;
        error err = it->second->open(handle);
        if(err != error::SUCCESS)
        {
            debug() << "[net::srv::cmd] cannot open device: " << hwstub::error_string(err) << "\n";
            return err;
        }
        /* record ID and return it */
        args[0] = state->next_handle_id;
        state->handle_map[state->next_handle_id++] = handle;
        return error::SUCCESS;
    }
    /* DEV_CLOSE */
    else if(cmd == HWSERVER_DEV_CLOSE)
    {
        uint32_t hid = args[0];
        debug() << "[net::srv::cmd] --> DEV_CLOSE(" << hid << ")\n";
        /* check ID is valid */
        auto it = state->handle_map.find(hid);
        if(it == state->handle_map.end())
        {
            debug() << "[net::srv::cmd] unknwon handle ID\n";
            debug() << "[net::srv::cmd] <-- DEV_CLOSE (error)\n";
            return error::ERROR;
        }
        /* release ID and handle */
        state->handle_map.erase(it);
        debug() << "[net::srv::cmd] <-- DEV_CLOSE\n";
        return error::SUCCESS;
    }
    /* HWSERVER_GET_DESC */
    else if(cmd == HWSERVER_GET_DESC)
    {
        uint32_t hid = args[0];
        uint32_t did = args[1];
        uint32_t len = args[2];
        debug() << "[net::srv::cmd] --> GET_DESC(" << hid << ",0x" << std::hex << did
            << "," << len << ")\n";
        /* check ID is valid */
        auto it = state->handle_map.find(hid);
        if(it == state->handle_map.end())
        {
            debug() << "[net::srv::cmd] unknown handle ID\n";
            debug() << "[net::srv::cmd] <-- GET_DESC (error)\n";
            return error::ERROR;
        }
        /* query desc */
        send_size = len;
        send_data = new uint8_t[send_size];
        error err = it->second->get_desc(did, send_data, send_size);
        if(err != error::SUCCESS)
        {
            delete[] send_data;
            debug() << "[net::srv::cmd] cannot get descriptor: " << error_string(err) << "\n";
            debug() << "[net::srv::cmd] <-- GET_DESC (error)\n";
            return err;
        }
        debug() << "[net::srv::cmd] <-- GET_DESC\n";
        return error::SUCCESS;
    }
    /* HWSERVER_GET_LOG */
    else if(cmd == HWSERVER_GET_LOG)
    {
        uint32_t hid = args[0];
        uint32_t len = args[1];
        debug() << "[net::srv::cmd] --> GET_LOG(" << hid << "," << len << ")\n";
        /* check ID is valid */
        auto it = state->handle_map.find(hid);
        if(it == state->handle_map.end())
        {
            debug() << "[net::srv::cmd] unknown handle ID\n";
            debug() << "[net::srv::cmd] <-- GET_DESC (error)\n";
            return error::ERROR;
        }
        /* query log */
        send_size = len;
        send_data = new uint8_t[send_size];
        error err = it->second->get_log(send_data, send_size);
        if(err != error::SUCCESS)
        {
            delete[] send_data;
            debug() << "[net::srv::cmd] cannot get log: " << error_string(err) << "\n";
            debug() << "[net::srv::cmd] <-- GET_LOG (error)\n";
            return err;
        }
        if(send_size == 0)
            delete[] send_data;
        debug() << "[net::srv::cmd] <-- GET_LOG\n";
        return error::SUCCESS;
    }
    /* HWSERVER_READ */
    else if(cmd == HWSERVER_READ)
    {
        uint32_t hid = args[0];
        uint32_t addr = args[1];
        uint32_t len = args[2];
        uint32_t flags = args[3];
        debug() << "[net::srv::cmd] --> READ(" << hid << ",0x" << std::hex << addr << ","
            << len << ",0x" << std::hex << flags << ")\n";
        /* check ID is valid */
        auto it = state->handle_map.find(hid);
        if(it == state->handle_map.end())
        {
            debug() << "[net::srv::cmd] unknown handle ID\n";
            debug() << "[net::srv::cmd] <-- READ (error)\n";
            return error::ERROR;
        }
        /* read */
        send_size = len;
        send_data = new uint8_t[send_size];
        error err = it->second->read(addr, send_data, send_size, !!(flags & HWSERVER_RW_ATOMIC));
        if(err != error::SUCCESS)
        {
            delete[] send_data;
            debug() << "[net::srv::cmd] cannot read: " << error_string(err) << "\n";
            debug() << "[net::srv::cmd] <-- READ (error)\n";
            return err;
        }
        debug() << "[net::srv::cmd] <-- READ\n";
        return error::SUCCESS;
    }
    /* HWSERVER_WRITE */
    else if(cmd == HWSERVER_WRITE)
    {
        uint32_t hid = args[0];
        uint32_t addr = args[1];
        uint32_t flags = args[2];
        debug() << "[net::srv::cmd] --> WRITE(" << hid << ",0x" << std::hex << addr << ","
            << recv_size << ",0x" << std::hex << flags << ")\n";
        /* check ID is valid */
        auto it = state->handle_map.find(hid);
        if(it == state->handle_map.end())
        {
            debug() << "[net::srv::cmd] unknown handle ID\n";
            debug() << "[net::srv::cmd] <-- WRITE (error)\n";
            return error::ERROR;
        }
        /* write */
        error err = it->second->write(addr, recv_data, recv_size, !!(flags & HWSERVER_RW_ATOMIC));
        if(err != error::SUCCESS)
        {
            delete[] send_data;
            debug() << "[net::srv::cmd] cannot write: " << error_string(err) << "\n";
            debug() << "[net::srv::cmd] <-- WRITE (error)\n";
            return err;
        }
        debug() << "[net::srv::cmd] <-- WRITE\n";
        return error::SUCCESS;
    }
    /* HWSERVER_EXEC */
    else if(cmd == HWSERVER_EXEC)
    {
        uint32_t hid = args[0];
        uint32_t addr = args[1];
        uint32_t flags = args[2];
        debug() << "[net::srv::cmd] --> EXEC(" << hid << ",0x" << std::hex << addr << ","
            << "0x" << std::hex << flags << ")\n";
        /* check ID is valid */
        auto it = state->handle_map.find(hid);
        if(it == state->handle_map.end())
        {
            debug() << "[net::srv::cmd] unknown handle ID\n";
            debug() << "[net::srv::cmd] <-- EXEC (error)\n";
            return error::ERROR;
        }
        /* exec */
        error err = it->second->exec(addr, flags);
        if(err != error::SUCCESS)
        {
            debug() << "[net::srv::cmd] cannot write: " << error_string(err) << "\n";
            debug() << "[net::srv::cmd] <-- EXEC (error)\n";
            return err;
        }
        debug() << "[net::srv::cmd] <-- EXEC\n";
        return error::SUCCESS;
    }
    else
    {
        debug() << "[net::srv::cmd] <-> unknown cmd (0x" << std::hex << cmd << ")\n";
        return error::ERROR;
    }
}

/*
 * Socket server
 */
socket_server::socket_server(std::shared_ptr<hwstub::context> contex, int socket_fd)
    :server(contex), m_socketfd(socket_fd)
{
    m_discovery_exit = false;
    set_timeout(std::chrono::milliseconds(1000));
    m_discovery_thread = std::thread(&socket_server::discovery_thread1, this);
}

socket_server::~socket_server()
{
    /* first stop discovery thread to make sure no more clients are created */
    m_discovery_exit = true;
    m_discovery_thread.join();
    close(m_socketfd);
    /* ask server to do a clean stop */
    stop_server();
}

std::shared_ptr<server> socket_server::create(std::shared_ptr<hwstub::context> ctx,
    int socket_fd)
{
    // NOTE: can't use make_shared() because of the protected ctor */
    return std::shared_ptr<socket_server>(new socket_server(ctx, socket_fd));
}

void socket_server::set_timeout(std::chrono::milliseconds ms)
{
    m_timeout.tv_usec = 1000 * (ms.count() % 1000);
    m_timeout.tv_sec = ms.count() / 1000;
}

int socket_server::from_srv_client(srv_client_t cli)
{
    return (int)(intptr_t)cli;
}

socket_server::srv_client_t socket_server::to_srv_client(int fd)
{
    return (srv_client_t)(intptr_t)fd;
}

void socket_server::discovery_thread1(socket_server *s)
{
    s->discovery_thread();
}

void socket_server::terminate_client(srv_client_t client)
{
    debug() << "[net::srv::sock] terminate client: " << client << "\n";
    /* simply close connection */
    close(from_srv_client(client));
}

error socket_server::send(srv_client_t client, void *buffer, size_t& sz)
{
    debug() << "[net::ctx::sock] send(" << client << ", " << sz << "): ";
    int ret = ::send(from_srv_client(client), buffer, sz, MSG_NOSIGNAL);
    if(ret >= 0)
    {
        debug() << "good(" << ret << ")\n";
        sz = (size_t)ret;
        return error::SUCCESS;
    }
    /* convert some errors */
    debug() << "fail(" << errno << "," << strerror(errno) << ")\n";
    switch(errno)
    {
#if EAGAIN != EWOULDBLOCK
        case EAGAIN:
#endif
        case EWOULDBLOCK: return error::TIMEOUT;
        case ECONNRESET: case EPIPE: return error::SERVER_DISCONNECTED;
        default: return error::NET_ERROR;
    }
}

error socket_server::recv(srv_client_t client, void *buffer, size_t& sz)
{
    debug() << "[net::ctx::sock] recv(" << client << ", " << sz << "): ";
    int ret = ::recv(from_srv_client(client), buffer, sz, MSG_WAITALL);
    if(ret > 0)
    {
        debug() << "good(" << ret << ")\n";
        sz = (size_t)ret;
        return error::SUCCESS;
    }
    if(ret == 0)
    {
        debug() << "disconnected\n";
        return error::SERVER_DISCONNECTED;
    }
    debug() << "fail(" << errno << "," << strerror(errno) << ")\n";
    switch(errno)
    {
#if EAGAIN != EWOULDBLOCK
        case EAGAIN:
#endif
        case EWOULDBLOCK: return error::TIMEOUT;
        default: return error::NET_ERROR;
    }
}

void socket_server::discovery_thread()
{
    debug() << "[net::srv:sock::discovery] start\n";
    /* begin listening to incoming connections */
    if(listen(m_socketfd, LISTEN_QUEUE_SIZE) < 0)
    {
        debug() << "[net::srv::sock::discovery] listen() failed: " << errno << "\n";
        return;
    }

    /* handle connections */
    while(!m_discovery_exit)
    {
        /* since accept() is blocking, use select to ensure a timeout */
        struct timeval tmo = m_timeout; /* NOTE select() can overwrite timeout */
        fd_set set;
        FD_ZERO(&set);
        FD_SET(m_socketfd, &set);
        /* wait for some activity */
        int ret = select(m_socketfd + 1, &set, nullptr, nullptr, &tmo);
        if(ret < 0 || !FD_ISSET(m_socketfd, &set))
            continue;
        int clifd = accept(m_socketfd, nullptr, nullptr);
        if(clifd >= 0)
        {
            debug() << "[net::srv::sock::discovery] new client\n";
            /* set timeout for the client operations */
            setsockopt(clifd, SOL_SOCKET, SO_RCVTIMEO, (char *)&m_timeout, sizeof(m_timeout));
            setsockopt(clifd, SOL_SOCKET, SO_SNDTIMEO, (char *)&m_timeout, sizeof(m_timeout));
            client_arrived(to_srv_client(clifd));
        }
    }
    debug() << "[net::srv:sock::discovery] stop\n";
}

} // namespace net
} // namespace hwstub