Subversion Repositories riscv_vhdl

/**

 * @file

 * @copyright  Copyright 2017 GNSS Sensor Ltd. All right reserved.

 * @author     Sergey Khabarov - sergeykhbr@gmail.com

 * @brief      Remote access to debugger via TCP connection. Server side.

 */

#include "tcpserver.h"

namespace debugger {

/** Class registration in the Core */

REGISTER_CLASS(TcpServer)

TcpServer::TcpServer(const char *name) : IService(name) {

    registerInterface(static_cast<IThread *>(this));

    registerAttribute("Enable", &isEnable_);

    registerAttribute("Timeout", &timeout_);

    registerAttribute("BlockingMode", &blockmode_);

    registerAttribute("HostIP", &hostIP_);

    registerAttribute("HostPort", &hostPort_);

}

void TcpServer::postinitService() {

    createServerSocket();

    if (listen(hsock_, 1) < 0)  {

        RISCV_error("listen() failed", 0);

        return;

    }

    /** By default socket was created with Blocking mode */

    if (!blockmode_.to_bool()) {

        setBlockingMode(false);

    }

    if (isEnable_.to_bool()) {

        if (!run()) {

            RISCV_error("Can't create thread.", NULL);

            return;

        }

    }

}

void TcpServer::busyLoop() {

    socket_def client_sock;

    int err;

    fd_set readSet;

    timeval timeout;

    timeout.tv_sec = 0;

    timeout.tv_usec = 400000;   // 400 ms

    int idx = 0;

    char tname[64];

    IClass *icls;

    IService *isrv;

    while (isEnabled()) {

        FD_ZERO(&readSet);

        FD_SET(hsock_, &readSet);

        err = select(hsock_ + 1, &readSet, NULL, NULL, &timeout);

        if (err > 0) {

            client_sock = accept(hsock_, 0, 0);

            setRcvTimeout(client_sock, timeout_.to_int());

            RISCV_sprintf(tname, sizeof(tname), "client%d", idx++);

            icls = static_cast<IClass *>(RISCV_get_class("TcpClientClass"));

            isrv = icls->createService(tname);

            AttributeType lst, item;

            lst.make_list(0);

            item.make_list(2);

            item[0u].make_string("LogLevel");

            item[1].make_int64(4);

            lst.add_to_list(&item);

            item[0u].make_string("Enable");

            item[1].make_boolean(true);

            lst.add_to_list(&item);

            isrv->initService(&lst);

            IThread *ithrd =

                static_cast<IThread *>(isrv->getInterface(IFACE_THREAD));

            ithrd->setExtArgument(&client_sock);

            isrv->postinitService();

            RISCV_info("TCP %s %p started", isrv->getObjName(), client_sock);

        } else if (err == 0) {

            // timeout

        } else {

            RISCV_info("TCP server thread accept() failed", 0);

            loopEnable_.state = false;

        }

    }

    closeServerSocket();

}

int TcpServer::createServerSocket() {

    char hostName[256];

    if (gethostname(hostName, sizeof(hostName)) < 0) {

        return -1;

    }

    struct addrinfo hints;

    memset(&hints, 0, sizeof(hints));

    hints.ai_family = AF_UNSPEC;

    hints.ai_socktype = SOCK_STREAM;

    hints.ai_protocol = IPPROTO_TCP;

    /**

     * Check availability of IPv4 address assigned via attribute 'hostIP'.

     * If it woudn't be found use the last avaialble IP address.

     */

    int retval;

    struct addrinfo *result = NULL;

    struct addrinfo *ptr = NULL;

    retval = getaddrinfo(hostName, "0", &hints, &result);

    if (retval != 0) {

        return -1;

    }

    if (hostIP_.size() == 0 || hostIP_.is_equal("127.0.0.1")) {

        memset(&sockaddr_ipv4_, 0, sizeof(struct sockaddr_in));

        sockaddr_ipv4_.sin_family = AF_INET;

        sockaddr_ipv4_.sin_addr.s_addr = inet_addr("127.0.0.1");

    } else {

        for (ptr = result; ptr != NULL; ptr = ptr->ai_next) {

            // Find only IPV4 address, ignore others.

            if (ptr->ai_family != AF_INET) {

                continue;

            }

            sockaddr_ipv4_ = *((struct sockaddr_in *)ptr->ai_addr);

            if (hostIP_.is_equal(inet_ntoa(sockaddr_ipv4_.sin_addr))) {

                break;

            }

        }

    }

    sockaddr_ipv4_.sin_port = htons(static_cast<uint16_t>(hostPort_.to_int()));

    RISCV_info("Selected Host IPv4 %s:%d",

                inet_ntoa(sockaddr_ipv4_.sin_addr),

                hostPort_.to_uint32());

    hsock_ = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (hsock_ < 0) {

        RISCV_error("%s", "Error: socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)");

        return -1;

    }

    int res = bind(hsock_,

                   reinterpret_cast<struct sockaddr *>(&sockaddr_ipv4_),

                   sizeof(sockaddr_ipv4_));

    if (res != 0) {

        RISCV_error("Error: bind(hsock_, \"%s\", ...)", hostIP_.to_string());

        return -1;

    }

    addr_size_t addr_sz = sizeof(sockaddr_ipv4_);

    res = getsockname(hsock_,

                      reinterpret_cast<struct sockaddr *>(&sockaddr_ipv4_),

                      &addr_sz);

    RISCV_info("IPv4 address %s:%d . . . opened",

                inet_ntoa(sockaddr_ipv4_.sin_addr),

                ntohs(sockaddr_ipv4_.sin_port));

    return 0;

}

void TcpServer::setRcvTimeout(socket_def skt, int timeout_ms) {

    if (!timeout_ms) {

        return;

    }

    struct timeval tv;

#if defined(_WIN32) || defined(__CYGWIN__)

    /** On windows timeout of the setsockopt() function is the DWORD

        * size variable in msec, so we use only the first field in timeval

        * struct and directly assgign argument.

        */

    tv.tv_sec = timeout_ms;

    tv.tv_usec = 0;

#else

    tv.tv_usec = (timeout_ms % 1000) * 1000;

    tv.tv_sec = timeout_ms / 1000;

#endif

    setsockopt(skt, SOL_SOCKET, SO_RCVTIMEO,

                    reinterpret_cast<char *>(&tv), sizeof(struct timeval));

}

bool TcpServer::setBlockingMode(bool mode) {

    int ret;

#if defined(_WIN32) || defined(__CYGWIN__)

    // 0 = disable non-blocking mode

    // 1 = enable non-blocking mode

    u_long arg = mode ? 0 : 1;

    ret = ioctlsocket(hsock_, FIONBIO, &arg);

    if (ret == SOCKET_ERROR) {

        RISCV_error("Set non-blocking socket failed", 0);

    }

#else

    int flags = fcntl(hsock_, F_GETFL, 0);

    if (flags < 0) {

        return false;

    }

    flags = mode ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK);

    ret = fcntl(hsock_, F_SETFL, flags);

#endif

    if (ret == 0) {

        // success

        blockmode_.make_boolean(mode);

        return true;

    }

    return false;

}

void TcpServer::closeServerSocket() {

    if (hsock_ < 0) {

        return;

    }

#if defined(_WIN32) || defined(__CYGWIN__)

    closesocket(hsock_);

#else

    shutdown(hsock_, SHUT_RDWR);

    close(hsock_);

#endif

    hsock_ = -1;

}

}  // namespace debugger