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 ;
 }
 
 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 / ;
     tv.tv_usec = (timeout_ms % ) * ;
     memset(&addr, , 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, );
     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)) == ) {
         return ;
     }
     if (errno != EINPROGRESS) {
         return -;
     }
 
     FD_ZERO(&wfds);
     FD_SET(sock->fd, &wfds);
 
     // 设置timeout，判断socket是否可写，如果可写，
     // 则用getsockopt得到error的值，若error值为0，表示connect成功
     retval = select(sock->fd + , NULL, &wfds, NULL, &tv);
     if (retval <= ) {
         return -;
     }
     optlen = sizeof(int);
     if (getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &retval, &optlen) < ) {
         return -;
     }
     if ( == retval) {
         return ;
     }
 
     return -;
 }
 
 int32_t txd_tcp_disconnect(txd_socket_handler_t *sock) {
     close(sock->fd);
     return ;
 }
 
 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 / ;
     tv.tv_usec = (timeout_ms % ) * ;
     FD_ZERO(&rfds);
     FD_SET(sock->fd, &rfds);
 
     retval = select(sock->fd + , &rfds, NULL, NULL, &tv);
     if (retval < ) {
         return -;
     }
     else if ( == retval) {
         return ;
     }
 
     // 不能保证全部读完，需要在上一层根据自己的协议做缓存
     retval = recv(sock->fd, buf, len, );
     if (retval <=  && errno != ) {
         printf("========recv: retval[%d],  errno[%d]======\n", retval, errno);
         return -;
     }
     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 / ;
     tv.tv_usec = (timeout_ms % ) * ;
     FD_ZERO(&wfds);
     FD_SET(sock->fd, &wfds);
 
     retval = select(sock->fd + , NULL, &wfds, NULL, &tv);
     if (retval < ) {
         return -;
     }
     else if ( == retval) {
         return ;
     }
 
     // 尽量将数据全部写到发送缓冲区
     uint32_t totlen = , n = len;
     while (totlen < n) {
         retval = send(sock->fd, buf + totlen, n - totlen, );
         if (retval < ) {
             if (errno == EAGAIN || errno == EWOULDBLOCK) {
                 continue;      // 发送缓冲区阻塞，选择continue或者break
             }
             else if (errno == EINTR) {  // 中断错误，继续写
                 continue;
             }
             return -;
         }
         totlen += retval;
     }
     return totlen;
 }