X86 Socket 通信

struct txd_socket_handler_t {
    int fd;
};

txd_socket_handler_t *txd_tcp_socket_create() {
    txd_socket_handler_t *sock = (txd_socket_handler_t*)txd_malloc(sizeof(txd_socket_handler_t));
    return sock;
}

int32_t txd_tcp_socket_destroy(txd_socket_handler_t *sock) {
    if (sock) {
        txd_free(sock);
    }
    return 0;
}

int32_t txd_tcp_connect(txd_socket_handler_t *sock, uint8_t *ip, uint16_t port, uint32_t timeout_ms) {
    struct sockaddr_in addr;
    struct timeval tv;
    fd_set wfds;
    int retval;
    socklen_t optlen;
    tv.tv_sec = timeout_ms / 1000;
    tv.tv_usec = (timeout_ms % 1000) * 1000;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_pton(AF_INET, (char *)ip, &addr.sin_addr);

    // 创建socket，并设置为非阻塞（阻塞也是可以的）
    sock->fd = socket(AF_INET, SOCK_STREAM, 0);
    fcntl(sock->fd, F_SETFL, fcntl(sock->fd, F_GETFL) | O_NONBLOCK);

    // 尝试连接，返回0表示连接成功，否则判断errno，
    // 如果errno被设为EINPROGRESS，表示connect仍旧在进行
    if (connect(sock->fd, (struct sockaddr*)&addr, sizeof(addr)) == 0) {
        return 0;
    }
    if (errno != EINPROGRESS) {
        return -1;
    }

    FD_ZERO(&wfds);
    FD_SET(sock->fd, &wfds);

    // 设置timeout，判断socket是否可写，如果可写，
    // 则用getsockopt得到error的值，若error值为0，表示connect成功
    retval = select(sock->fd + 1, NULL, &wfds, NULL, &tv);
    if (retval <= 0) {
        return -1;
    }
    optlen = sizeof(int);
    if (getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &retval, &optlen) < 0) {
        return -1;
    }
    if (0 == retval) {
        return 0;
    }

    return -1;
}

int32_t txd_tcp_disconnect(txd_socket_handler_t *sock) {
    close(sock->fd);
    return 0;
}

int32_t txd_tcp_recv(txd_socket_handler_t *sock, uint8_t *buf, uint32_t len, uint32_t timeout_ms) {
    struct timeval tv;
    fd_set rfds;
    int retval;
    tv.tv_sec = timeout_ms / 1000;
    tv.tv_usec = (timeout_ms % 1000) * 1000;
    FD_ZERO(&rfds);
    FD_SET(sock->fd, &rfds);

    retval = select(sock->fd + 1, &rfds, NULL, NULL, &tv);
    if (retval < 0) {
        return -1;
    }
    else if (0 == retval) {
        return 0;
    }

    // 不能保证全部读完，需要在上一层根据自己的协议做缓存
    retval = recv(sock->fd, buf, len, 0);
    if (retval <= 0 && errno != 0) {
        printf("========recv: retval[%d],  errno[%d]======\n", retval, errno);
        return -1;
    }
    return retval;
}

int32_t txd_tcp_send(txd_socket_handler_t *sock, uint8_t *buf, uint32_t len, uint32_t timeout_ms) {
    struct timeval tv;
    fd_set wfds;
    int retval;
    tv.tv_sec = timeout_ms / 1000;
    tv.tv_usec = (timeout_ms % 1000) * 1000;
    FD_ZERO(&wfds);
    FD_SET(sock->fd, &wfds);

    retval = select(sock->fd + 1, NULL, &wfds, NULL, &tv);
    if (retval < 0) {
        return -1;
    }
    else if (0 == retval) {
        return 0;
    }

    // 尽量将数据全部写到发送缓冲区
    uint32_t totlen = 0, n = len;
    while (totlen < n) {
        retval = send(sock->fd, buf + totlen, n - totlen, 0);
        if (retval < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                continue;      // 发送缓冲区阻塞，选择continue或者break
            }
            else if (errno == EINTR) {  // 中断错误，继续写
                continue;
            }
            return -1;
        }
        totlen += retval;
    }
    return totlen;
}