libuv学习笔记（12）

最新推荐文章于 2024-03-13 14:57:57 发布
最新推荐文章于 2024-03-13 14:57:57 发布
阅读量3.7k 收藏 2
点赞数
分类专栏： libuv学习笔记 文章标签： libuv uv-tcp-t
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/paohui0134/article/details/51691078
版权

libuv学习笔记（12）

uv_tcp_t数据结构与相关函数(1)

数据结构

typedef struct uv_tcp_s uv_tcp_t;
struct uv_tcp_s {
  UV_HANDLE_FIELDS//uv_handle_t的成员
  UV_STREAM_FIELDS//stream的成员
  //UV_TCP_PRIVATE_FIELDS展开如下：
  SOCKET socket;                                                              
  int delayed_error;                                                          
  union {                                                                    
    struct {
     uv_tcp_accept_t* accept_reqs;//接受请求列表                                              
     unsigned int processed_accepts;                                           
     uv_tcp_accept_t* pending_accepts;//等待处理的接受请求 
     LPFN_ACCEPTEX func_acceptex;//accetpex的函数指针
    } serv;                                     
    struct {
     uv_buf_t read_buffer; //读取数据的缓存
     LPFN_CONNECTEX func_connectex;//connectex函数指针
    } conn;                                
  } tcp;
};

相关的请求

  typedef struct uv_tcp_accept_s {                                          
    UV_REQ_FIELDS//uv_req_t的成员                                                        
    SOCKET accept_socket;                                                
    char accept_buffer[sizeof(struct sockaddr_storage) * 2 + 32];        
    HANDLE event_handle;                                                 
    HANDLE wait_handle;                                                  
    struct uv_tcp_accept_s* next_pending;                              
  } uv_tcp_accept_t;

相关函数

初始化。导出函数，在uv.h中声明，在tcp.c中定义
int uv_tcp_init(uv_loop_t* loop, uv_tcp_t* handle) {
  return uv_tcp_init_ex(loop, handle, AF_UNSPEC);//
}
初始化扩展函数。导出函数，在uv.h中声明，在tcp.c中定义
int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* handle, unsigned int flags) {
  int domain;
  //使用flags的低八位
  domain = flags & 0xFF;
  //只能是一下三种中的一种，其中AF_UNSPEC并不会做任何操作
  if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
    return UV_EINVAL;
  if (flags & ~0xFF)//高八位有值，返回错误
    return UV_EINVAL;
  //初始化stream，handle加入loop的handle列表
  uv_stream_init(loop, (uv_stream_t*) handle, UV_TCP);
  handle->tcp.serv.accept_reqs = NULL;
  handle->tcp.serv.pending_accepts = NULL;
  handle->socket = INVALID_SOCKET;
  handle->reqs_pending = 0;
  handle->tcp.serv.func_acceptex = NULL;
  handle->tcp.conn.func_connectex = NULL;
  handle->tcp.serv.processed_accepts = 0;
  handle->delayed_error = 0;

  //在下面的流程中如果发生错误，那么需要移除loop中的本handle
  if (domain != AF_UNSPEC) {
    SOCKET sock;
    DWORD err;
    sock = socket(domain, SOCK_STREAM, 0);//新建socket
    if (sock == INVALID_SOCKET) {//失败
      err = WSAGetLastError();
      QUEUE_REMOVE(&handle->handle_queue);
      return uv_translate_sys_error(err);
    }
    //将申请的socket与loop的iocp端口联系起来
    err = uv_tcp_set_socket(handle->loop, handle, sock, domain, 0);
    if (err) {//失败
      closesocket(sock);
      QUEUE_REMOVE(&handle->handle_queue);
      return uv_translate_sys_error(err);
    }

  }
  return 0;
}

将tcp socket与iocp端口绑定

static int uv_tcp_set_socket(uv_loop_t* loop,
                             uv_tcp_t* handle,
                             SOCKET socket,
                             int family,
                             int imported) {
  DWORD yes = 1;
  int non_ifs_lsp;
  int err;
  if (handle->socket != INVALID_SOCKET)
    return UV_EBUSY;
  //将socket设置为非阻塞模式
  if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {
    return WSAGetLastError();
  }
  //使socket句柄无法被继承
  if (!SetHandleInformation((HANDLE) socket, HANDLE_FLAG_INHERIT, 0))
    return GetLastError();
  //与iocp端口关联起来，并将socket作为key
  if (CreateIoCompletionPort((HANDLE)socket,
                             loop->iocp,
                             (ULONG_PTR)socket,
                             0) == NULL) {
    //在uv_tcp_open中为打开一个已有socket中，imported为1
    if (imported) {
      handle->flags |= UV_HANDLE_EMULATE_IOCP;
    } else {
      return GetLastError();
    }
  }

  if (family == AF_INET6) {
    //uv_tcp_non_ifs_lsp_ipv6 = 1表示IPPROTO_IP协议使用真正地操作系统句柄，没有lsp封装
    non_ifs_lsp = uv_tcp_non_ifs_lsp_ipv6;
  } else {
    //同理
    non_ifs_lsp = uv_tcp_non_ifs_lsp_ipv4;
  }

  if (pSetFileCompletionNotificationModes &&
      !(handle->flags & UV_HANDLE_EMULATE_IOCP) && !non_ifs_lsp) {
    if (pSetFileCompletionNotificationModes((HANDLE) socket,
        FILE_SKIP_SET_EVENT_ON_HANDLE |
        FILE_SKIP_COMPLETION_PORT_ON_SUCCESS))//如果操作立刻完成，不再向iocp发送通知 
    {
      handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;
    } else if (GetLastError() != ERROR_INVALID_FUNCTION) {
      return GetLastError();
    }
  }
  //取消使用Nagle算法
  if (handle->flags & UV_HANDLE_TCP_NODELAY) {
    err = uv__tcp_nodelay(handle, socket, 1);
    if (err)
      return err;
  }
  //使用保持存活
  if (handle->flags & UV_HANDLE_TCP_KEEPALIVE) {
    err = uv__tcp_keepalive(handle, socket, 1, 60);
    if (err)
      return err;
  }
  handle->socket = socket;

  if (family == AF_INET6) {
    handle->flags |= UV_HANDLE_IPV6;
  } else {
    assert(!(handle->flags & UV_HANDLE_IPV6));
  }

  return 0;
}
通过一个socket作为uv_tcp_t。导出函数，在uv.h中声明，在tcp.c中定义
int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {
  WSAPROTOCOL_INFOW protocol_info;
  int opt_len;
  int err;

  //获取地址的类型
  opt_len = (int) sizeof protocol_info;
  //获取协议信息
  if (getsockopt(sock,
                 SOL_SOCKET,
                 SO_PROTOCOL_INFOW,
                 (char*) &protocol_info,
                 &opt_len) == SOCKET_ERROR) {
    return uv_translate_sys_error(GetLastError());
  }
  //将socket与loop的iocp端口联系起来
  //根据handle的标记设置socket。
  err = uv_tcp_set_socket(handle->loop,
                          handle,
                          sock,
                          protocol_info.iAddressFamily,
                          1);
  if (err) {
    return uv_translate_sys_error(err);
  }

  return 0;
}
获取地址。导出函数，在uv.h中声明，在tcp.c中定义
int uv_tcp_getsockname(const uv_tcp_t* handle,
                       struct sockaddr* name,
                       int* namelen) 
{
  int result;
  if (handle->socket == INVALID_SOCKET) {
    return UV_EINVAL;
  }
  if (handle->delayed_error) {//之前的操作出现错误，比如bind操作
    return uv_translate_sys_error(handle->delayed_error);
  }
  result = getsockname(handle->socket, name, namelen);//调用API
  if (result != 0) {
    return uv_translate_sys_error(WSAGetLastError());
  }
  return 0;
}
获取连接对象的地址。导出函数，在uv.h中声明，在tcp.c中定义
int uv_tcp_getpeername(const uv_tcp_t* handle,
                       struct sockaddr* name,
                       int* namelen) {
  int result;

  if (handle->socket == INVALID_SOCKET) {
    return UV_EINVAL;
  }

  if (handle->delayed_error) {
    return uv_translate_sys_error(handle->delayed_error);
  }

  result = getpeername(handle->socket, name, namelen);//调用API
  if (result != 0) {
    return uv_translate_sys_error(WSAGetLastError());
  }
  return 0;
}
建立连接。导出函数，在uv.h中声明，在tcp.c中定义
int uv_tcp_connect(uv_connect_t* req,
                   uv_tcp_t* handle,
                   const struct sockaddr* addr,
                   uv_connect_cb cb) {
  unsigned int addrlen;
  if (handle->type != UV_TCP)
    return UV_EINVAL;
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
  return uv__tcp_connect(req, handle, addr, addrlen, cb);//调用内部函数处理
}

connect的内部处理

int uv__tcp_connect(uv_connect_t* req,
                    uv_tcp_t* handle,
                    const struct sockaddr* addr,
                    unsigned int addrlen,
                    uv_connect_cb cb) {
  int err;
  err = uv_tcp_try_connect(req, handle, addr, addrlen, cb);
  if (err)
    return uv_translate_sys_error(err);
  return 0;
}
static int uv_tcp_try_connect(uv_connect_t* req,
                              uv_tcp_t* handle,
                              const struct sockaddr* addr,
                              unsigned int addrlen,
                              uv_connect_cb cb) {
  uv_loop_t* loop = handle->loop;
  const struct sockaddr* bind_addr;
  BOOL success;
  DWORD bytes;
  int err;
  if (handle->delayed_error) {
    return handle->delayed_error;
  }
  //没有绑定本地地址，使用默认地址绑定
  if (!(handle->flags & UV_HANDLE_BOUND)) {
    if (addrlen == sizeof(uv_addr_ip4_any_)) {
      bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
    } else if (addrlen == sizeof(uv_addr_ip6_any_)) {
      bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
    } else {
      abort();
    }
    err = uv_tcp_try_bind(handle, bind_addr, addrlen, 0);
    if (err)
      return err;
    if (handle->delayed_error)
      return handle->delayed_error;
  }

  if (!handle->tcp.conn.func_connectex) { 
    //根据具体的socket获取connectex函数指针
    if (!uv_get_connectex_function(handle->socket, &handle->tcp.conn.func_connectex))   
    {
      return WSAEAFNOSUPPORT;
    }
  }
  //初始化connect请求
  uv_req_init(loop, (uv_req_t*) req);
  req->type = UV_CONNECT;
  req->handle = (uv_stream_t*) handle;
  req->cb = cb;
  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
  //调用connectex函数，异步链接，成功或者失败会通知iocp端口
  success = handle->tcp.conn.func_connectex(handle->socket,
                                           addr,
                                           addrlen,
                                           NULL,
                                           0,
                                           &bytes,
                                           &req->u.io.overlapped);

  if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {
    //未能成功，直接将请求添加到loop的请求列表进行处理
    handle->reqs_pending++;
    REGISTER_HANDLE_REQ(loop, handle, req);
    uv_insert_pending_req(loop, (uv_req_t*)req);
  } else if (UV_SUCCEEDED_WITH_IOCP(success)) {
    //通过iocp处理，req将会在收到iocp消息时添加到loop的请求列表
    handle->reqs_pending++;
    REGISTER_HANDLE_REQ(loop, handle, req);
  } else {
    return WSAGetLastError();
  }
  return 0;
}

对于通过iocp的connect请求处理，在uv_run轮询时，会获取连接的消息，并通过overlapped获取对应的req，将其添加到loop的请求列表，在下一个循环迭代loop会调用uv_process_reqs进行处理

case UV_CONNECT:
        DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle);
        break;

最终调用uv_process_tcp_connect_req，处理tcp connect请求

void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,
    uv_connect_t* req) {
  int err;
  assert(handle->type == UV_TCP);
  //handle的活动计数减一，如果为零则停止handle（loop活动handle减一，handle状态变为非Active）
  //loop的active_req列表中删除req
  //因为connect请求到此处处理完就结束了，而对应的uv_tcp_t则应该回归停止状态
  UNREGISTER_HANDLE_REQ(loop, handle, req);
  err = 0;
  if (REQ_SUCCESS(req)) {//链接成功，更新socket状态
    if (setsockopt(handle->socket,
                    SOL_SOCKET,
                    SO_UPDATE_CONNECT_CONTEXT,
                    NULL,
                    0) == 0) {
      uv_connection_init((uv_stream_t*)handle);
      handle->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
      loop->active_tcp_streams++;//活动的tcp流计数加一
    } else {
      err = WSAGetLastError();
    }
  } else {
    err = GET_REQ_SOCK_ERROR(req);
  }
  req->cb(req, uv_translate_sys_error(err));//调用回调
  //DECREASE_PENDING_REQ_COUNT(handle);展开：
  do { 
      assert(handle->reqs_pending > 0);  
      handle->reqs_pending--;/等待处理的请求数减一                                        
      if (handle->flags & UV__HANDLE_CLOSING && 
        handle->reqs_pending == 0) {//正在关闭状态
        uv_want_endgame(loop, (uv_handle_t*)handle); 
      }                                               
  } while (0)
}
读取数据的请求。导出函数，在uv.h中声明，在stream.c中定义
//对于uv_tcp_t类型的stream，调用下面的处理
switch (handle->type) {
    case UV_TCP:
      err = uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
      break;

uv_tcp_read_start，tcp开始读取

int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
    uv_read_cb read_cb) {
  uv_loop_t* loop = handle->loop;
  handle->flags |= UV_HANDLE_READING;//状态变为reading
  handle->read_cb = read_cb;
  handle->alloc_cb = alloc_cb;
  //activecnt++，如果之前activecnt为0，那么就start  handle
  INCREASE_ACTIVE_COUNT(loop, handle);
  //如果读取被中断，那么就再次开始
  if (!(handle->flags & UV_HANDLE_READ_PENDING)) {
    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
        !handle->read_req.event_handle) {
      //模拟iocp的情况下，创建事件
      handle->read_req.event_handle = CreateEvent(NULL, 0, 0, NULL);
      if (!handle->read_req.event_handle) {
        uv_fatal_error(GetLastError(), "CreateEvent");
      }
    }
    //将读取请求放到队列
    uv_tcp_queue_read(loop, handle);
  }
  return 0;
}

读取请求放到队列

static void uv_tcp_queue_read(uv_loop_t* loop, uv_tcp_t* handle) {
  uv_read_t* req;
  uv_buf_t buf;
  int result;
  DWORD bytes, flags;
  assert(handle->flags & UV_HANDLE_READING);
  assert(!(handle->flags & UV_HANDLE_READ_PENDING));//在等待读取的过程中不应该再次发起读取请
                                                    //求
  req = &handle->read_req;
  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));

  //预分配读取缓存，目前uv_active_tcp_streams_threshold值为0
  if (loop->active_tcp_streams < uv_active_tcp_streams_threshold) {
    handle->flags &= ~UV_HANDLE_ZERO_READ;
    handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->tcp.conn.read_buffer);
    if (handle->tcp.conn.read_buffer.len == 0) {
      handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &handle->tcp.conn.read_buffer);
      return;
    }
    assert(handle->tcp.conn.read_buffer.base != NULL);
    buf = handle->tcp.conn.read_buffer;
  } 
  else {//没有预分配
    handle->flags |= UV_HANDLE_ZERO_READ;
    buf.base = (char*) &uv_zero_;
    buf.len = 0;
  }
  //初始化重叠结构体
  memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {//非原生socket等因素导致与iocp端口绑定失败的情况下
    assert(req->event_handle);
    req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
  }
  flags = 0;
  //异步接收数据
  result = WSARecv(handle->socket,
                   (WSABUF*)&buf,
                   1,
                   &bytes,
                   &flags,
                   &req->u.io.overlapped,
                   NULL);

  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
    //不通过iocp处理请求，直接添加到loop的请求列表
    handle->flags |= UV_HANDLE_READ_PENDING;
    req->u.io.overlapped.InternalHigh = bytes;
    handle->reqs_pending++;
    uv_insert_pending_req(loop, (uv_req_t*)req);
  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
    //通过iocp处理请求
    handle->flags |= UV_HANDLE_READ_PENDING;//修改状态
    handle->reqs_pending++;//活动请求加一
    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&//socket与iocp绑定失败
        req->wait_handle == INVALID_HANDLE_VALUE &&
        !RegisterWaitForSingleObject(&req->wait_handle,//注册等待事件
          req->event_handle, post_completion, (void*) req,
          INFINITE, WT_EXECUTEINWAITTHREAD)) {
      SET_REQ_ERROR(req, GetLastError());
      uv_insert_pending_req(loop, (uv_req_t*)req);//读请求添加到loop的请求列表
    }
  } else {
    //记录错误信息
    SET_REQ_ERROR(req, WSAGetLastError());
    uv_insert_pending_req(loop, (uv_req_t*)req);
    handle->reqs_pending++;
  }
}

loop对读请求的处理最终会调用到以下函数：

void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
    uv_req_t* req) {
  DWORD bytes, flags, err;
  uv_buf_t buf;
  assert(handle->type == UV_TCP);
  handle->flags &= ~UV_HANDLE_READ_PENDING;//去掉等待处理标记
  if (!REQ_SUCCESS(req)) {
    //读取发生错误
    if ((handle->flags & UV_HANDLE_READING) ||
        !(handle->flags & UV_HANDLE_ZERO_READ)) 
    {
      handle->flags &= ~UV_HANDLE_READING;
      DECREASE_ACTIVE_COUNT(loop, handle);//活动计数减一
      buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
            uv_buf_init(NULL, 0) : handle->tcp.conn.read_buffer;
      err = GET_REQ_SOCK_ERROR(req);
      if (err == WSAECONNABORTED) {
        err = WSAECONNRESET;
      }
      //调用读取回调，传入错误信息
      handle->read_cb((uv_stream_t*)handle,
                      uv_translate_sys_error(err),
                      &buf);
    }
  } else {//成功
    if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
      if (req->u.io.overlapped.InternalHigh > 0) {
        //读取成功
        handle->read_cb((uv_stream_t*)handle,
                        req->u.io.overlapped.InternalHigh,
                        &handle->tcp.conn.read_buffer);
        //如果当前获取的数据长度与缓存长度相同，继续读取
        if (req->u.io.overlapped.InternalHigh < handle->tcp.conn.read_buffer.len) {
          goto done;
        }
      } else {
        //链接失败
        if (handle->flags & UV_HANDLE_READING) {
          handle->flags &= ~UV_HANDLE_READING;
          DECREASE_ACTIVE_COUNT(loop, handle);
        }
        handle->flags &= ~UV_HANDLE_READABLE;
        buf.base = 0;
        buf.len = 0;
        handle->read_cb((uv_stream_t*)handle, UV_EOF, &handle->tcp.conn.read_buffer);
        goto done;
      }
    }
    //持续读取
    while (handle->flags & UV_HANDLE_READING) {
      handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);//调用分配内存的回调
      if (buf.len == 0) {
        handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
        break;
      }
      assert(buf.base != NULL);
      flags = 0;
      if (WSARecv(handle->socket,
                  (WSABUF*)&buf,
                  1,
                  &bytes,
                  &flags,
                  NULL,
                  NULL) != SOCKET_ERROR) {
        if (bytes > 0) {
          //成功读取，调用读取回调
          handle->read_cb((uv_stream_t*)handle, bytes, &buf);
          //判断是否需要继续读取
          if (bytes < buf.len) {
            break;
          }
        } else {
          //链接被关闭了
          handle->flags &= ~(UV_HANDLE_READING | UV_HANDLE_READABLE);
          DECREASE_ACTIVE_COUNT(loop, handle);
          handle->read_cb((uv_stream_t*)handle, UV_EOF, &buf);
          break;
        }
      } else {//读取出错
        err = WSAGetLastError();
        if (err == WSAEWOULDBLOCK) {
          //读取缓存为空
          handle->read_cb((uv_stream_t*)handle, 0, &buf);
        } else {
          //出现了严重错误
          handle->flags &= ~UV_HANDLE_READING;
          DECREASE_ACTIVE_COUNT(loop, handle);
          if (err == WSAECONNABORTED) {
            err = WSAECONNRESET;
          }
          handle->read_cb((uv_stream_t*)handle,
                          uv_translate_sys_error(err),
                          &buf);
        }
        break;
      }
    }
done:
    //一个读取请求结束之后，如果没有停止读取，那么再次开启一个请求，持续读取
    if ((handle->flags & UV_HANDLE_READING) &&
        !(handle->flags & UV_HANDLE_READ_PENDING)) {
      uv_tcp_queue_read(loop, handle);
    }
  }
  DECREASE_PENDING_REQ_COUNT(handle);//handle等待处理的请求数量减一
}
停止读取请求。导出函数，在uv.h中声明，在stream.c中定义

并不会立刻停止，在调用该函数之后，会影响最近的一次读取请求处理，并且不会再次发送读取请求，依次达到停止效果。

int uv_read_stop(uv_stream_t* handle) {
  int err;
  if (!(handle->flags & UV_HANDLE_READING))//非读取状态，返回
    return 0;
  err = 0;
  if (handle->type == UV_TTY) {
    err = uv_tty_read_stop((uv_tty_t*) handle);
  } else {
    if (handle->type == UV_NAMED_PIPE) {
      uv__pipe_stop_read((uv_pipe_t*) handle);
    } else {
      handle->flags &= ~UV_HANDLE_READING;//TCP
    }
    DECREASE_ACTIVE_COUNT(handle->loop, handle);//handle的活动计数减一
  }
  return uv_translate_sys_error(err);
}

从uv_tcp_t的connet以及读取可以看出。
1.uv_tcp_t的激活状态主要是依靠请求，比如在connet请求处理完之后，如果没有再发送其他请求（比如read)，那么uv_tcp_t将会处于停止状态，loop不会在活动handle中记录该handle。
2.部分流相关的请求会记录在loop的请求列表中，比如connect以及write，个人推测是用户发出的请求会添加到loop的请求队列，而libuv自己处理中发出的请求则不会（比如uv_read_start,参数中并没有req，是使用的是stream内部的私有uv_read_t;）。
3.一些流相关的请求是会在处理之后自己再重复发起的，比如read，可以推测accept也是如此，不需要用户自己再去重复发送，但是需要用户去停止。

这里写代码片

通过uv_close关闭uv_tcp_t,会调用uv_tcp_close

void uv_tcp_close(uv_loop_t* loop, uv_tcp_t* tcp) {
  int close_socket = 1;
  if (tcp->flags & UV_HANDLE_READ_PENDING) {
    //等待读请求的处理。也就是调用了异步读取WSARecv，但是还未收到数据
    if (!(tcp->flags & UV_HANDLE_SHARED_TCP_SOCKET)) 
    {
      //非共享socket，直接shutdown。在uv_tcp_open的方式初始化uv_tcp_t时，会设置为
      //UV_HANDLE_SHARED_TCP_SOCKET
      shutdown(tcp->socket, SD_SEND);//关闭socket的写功能
    } else if (uv_tcp_try_cancel_io(tcp) == 0)  
    {//通过CancelIo  API取消
      //如果是共享的，那么尝试取消i/o请求。如果成功，并不立刻关闭socket，等读请求返回的时候关闭
      close_socket = 0;
    } else  
    {//共享socket，取消失败
      //只能关闭socket了。
    }
  } else if ((tcp->flags & UV_HANDLE_SHARED_TCP_SOCKET) &&
             tcp->tcp.serv.accept_reqs != NULL) {
    /* Under normal circumstances closesocket() will ensure that all pending */
    /* accept reqs are canceled. However, when the socket is shared the */
    /* presence of another reference to the socket in another process will */
    /* keep the accept reqs going, so we have to ensure that these are */
    /* canceled. */
    if (uv_tcp_try_cancel_io(tcp) != 0) {
      /* When cancellation is not possible, there is another option: we can */
      /* close the incoming sockets, which will also cancel the accept */
      /* operations. However this is not cool because we might inadvertently */
      /* close a socket that just accepted a new connection, which will */
      /* cause the connection to be aborted. */
      unsigned int i;
      for (i = 0; i < uv_simultaneous_server_accepts; i++) {
        uv_tcp_accept_t* req = &tcp->tcp.serv.accept_reqs[i];
        if (req->accept_socket != INVALID_SOCKET &&
            !HasOverlappedIoCompleted(&req->u.io.overlapped)) {
          closesocket(req->accept_socket);
          req->accept_socket = INVALID_SOCKET;
        }
      }
    }
  }

  if (tcp->flags & UV_HANDLE_READING) {
    tcp->flags &= ~UV_HANDLE_READING;//停止读取
    DECREASE_ACTIVE_COUNT(loop, tcp);
  }

  if (tcp->flags & UV_HANDLE_LISTENING) {
    tcp->flags &= ~UV_HANDLE_LISTENING;
    DECREASE_ACTIVE_COUNT(loop, tcp);
  }

  if (close_socket) {
    closesocket(tcp->socket);
    tcp->socket = INVALID_SOCKET;
    tcp->flags |= UV_HANDLE_TCP_SOCKET_CLOSED;
  }

  tcp->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
  uv__handle_closing(tcp);//状态改为closing
  //没有等待处理的请求了，关闭handle，否则需要等到处理请求时关闭
  if (tcp->reqs_pending == 0) {
    uv_want_endgame(tcp->loop, (uv_handle_t*)tcp);
  }
}

uv_tcp_t中有两个计数
1.reqs_pending，表示已经添加到loop中的请求，或者已经与iocp绑定的端口调用了i/o函数，可以通过iocp端口获取的请求，在请求处理结束之后减一，如果为0且处于UV_HANDLE_CLOSING状态，那么会将handle添加到关闭列表。
2.activecnt，调用了某一个请求后加一，在对应的处理函数中减一，为0并且正在关闭时stop handle
请求的调用与处理会引发两个计数的变化。

对于部分请求，比如connect与write，会添加到loop的active_reqs列表，请求处理完成之后，会从列表删除。该列表是判断loop alive的条件之一。

与tcp相关的还有accept与write操作，将在下一篇中分析

paohui0134
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libuv-dox, 记录libuv的类型和方法，主要是通过读取'uv.h'.zip
09-18
libuv-dox, 记录libuv的类型和方法，主要是通过读取'uv.h' libuv-dox记录 libuv的类型和方法，主要通过读取 uv.h 。组织在 uv.h 中找到的信息已经分为三个类别：类型：回调函数方法示例添加了用于说明如何使用API的示例。用户定义类型继承关系通过 : ( 换
libuv学习笔记（2）
paohui0134的博客
06-11 8064
libuv学习笔记（2） uv_loop_t结构体以及相关函数(windows平台)
libuv简介以及uv_handle_t 和 uv_stream_t
最新发布
日拱一卒，玉汝于成
03-13 1273
libuv的核心是事件循环（Event Loop），这是一个机制，它会持续监视各种类型的I/O资源和定时器，当这些资源准备好执行某种操作（如读写数据）或定时器到期时，事件循环将调用相应的回调函数来处理。在 libuv 库中，uv_stream_t 和 uv_handle_t 是两种基本的数据类型，它们是 libuv 的核心抽象概念，用于处理不同类型的异步 I/O 事件。监视器是一种特殊的句柄，用于监控特定事件的发生，如文件描述符的读写就绪、文件系统的变动、进程退出等。libuv 是一个强大的。
libuv之helloworld
JXES智能生态系统
05-16 1511
让我们开始写第一个libuv程序吧！它什么都没做，只是开启了一个loop，然后很快地退出了。 #include #include #include   //这是libuv非常重要的一个头文件，很多API都是在这里声明的，以及宏的声明 //这里ub.h注意我这里的写法与stdlib.h类似，因为我前面make install是默认安装的，也就是说都安装到系统/usr下面相应目录下了，所
Libuv库(探讨)---第四节:网络相关
knowledgebao的博客
08-31 2468
索引目录：https://blog.csdn.net/knowledgebao/article/details/84776754 目录 系列目录： Stream基类相关 TTY PIPE TCP UDP Networking in libuv is not much different from directly using the BSD socket interface, so...
libuv之基础（转载）
zhangatm的博客
09-11 425
原文地址：http://blog.csdn.net/pud_zha/article/details/8473514 TCP客户端连接步骤： ①  .连接方法 Uv_loop_t *loop = uv_default_loop();   uv_tcp_t *client = malloc…; uv_connect_t* connect_req = malloc…;   uv_tcp_init(l
libuv之开启tcp服务端监听，并获得客户端的ip及端口
闻道百
02-12 8822
libuv中处理tcp连接的handle叫做uv_tcp_t，可以认为它是uv_stream_t的子类，所以它是可以当作流来使用的，这篇主要内容不在这，其实主要介绍两个函数 UV_EXTERN int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name, int* namelen); UV_EXTERN int uv_tc
libuv学习文档
03-14
这本'书'是一小部分关于使用libuv作为高性能事件I / O库的教程 Windows和Unix上的API相同。 它旨在涵盖libuv的主要领域，但不是讨论每个功能和数据的综合参考 结构体。可以查阅官方libuv文档以获取完整详细信息。 这...
learning-libuv:学习libuv
05-18
libuv学习笔记libuv介绍背景​是一个跨平台的异步IO库实现，刚开始是为Node.js而开发，Node.js完全构建于libuv之上。跨平台构建支持平台WindowsUnixAndroidOS X 注：ios需要自己移植。支持构建工具：autotoolsVisual...
libuv中文学习指南
09-28
libuv中文入门学习书籍
libuv documentation.pdf
08-19
libuv documentation.pdf
libuv-java:Java的libuv绑定
05-26
libuv的java Java的libuv绑定。 是为提供支持的跨平台异步IO实现。 它支持UDP和TCP套接字，文件系统监视，TTY，管道和其他异步原语，例如计时器，检查，准备和空闲。支持的Java版本Oracle和OpenJDK Java 8、11，...
基于libuv的tcp端口转发（keepalive和超时设置）
whojoe的博客
07-27 1184
基于libuv的tcp端口转发（keepalive和超时设置）前言代码参考文章 前言 网上关于libuv的代码示例较少，官方文档和代码中的示例都只是给了简单的例子，实际使用的时候可能会遇到很多内存泄漏和指针异常的问题 代码 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <uv.h> #define CRTDBG_MAP_ALLOC #include "crtdbg.h"
uv_tcp_t — TCP 句柄
xinqingwuji的博客
11-28 1538
TCP句柄用于表示TCP流和服务器 uv_tcp_t是uv_stream_t的子类。 数据类型 uv_tcp_t TCP句柄类型。 API intuv_tcp_init(uv_loop_t*loop,uv_tcp_t*handle) 初始化句柄。到目前为止尚未创建套接字。 intuv_tcp_init_ex(uv_loop_t*loop,uv_tcp_t*h...
libuv学习笔记（3）
paohui0134的博客
06-11 3636
libuv学习笔记（3） uv_handle_t结构体以及相关函数
断开连接后只能通过_通过源码理解http层和tcp层的keepalive
weixin_39685024的博客
11-28 91
前言：最近在研究websocket和keep-alive。而websocket涉及到长连接，过多无用的长连接对系统来说是负担，是否可以尽快发现对端是否已经掉线，从而释放这个连接来减少系统压力呢，就这个初衷，通过wireshark和nodejs调试一下心跳机制。引发了一些研究和思考。我们知道建立tcp连接的代价是比较昂贵的，每次连接需要三次握手，还有慢开始，或者建立一个连接只为了传少量数据...
Libuv 各个回调（异步）事件的调用时机
田螺姑娘的博客
10-31 688
下面有一个应用场景，与uv_close的调用时机有关，服务端有一个心跳检测机制，判断连接上来每个会话（Session）是否具有活性。其中，ClientHeartCheck是一个定时器事件，定时时间为3000。
关于 .NET 运行时 Sockets Datagram Socket，大量 Socket 缓冲区内存问题
liulilittle的博客
01-03 2039
本文解决的问题如上所示，Datagram（数据报）类型的 Socket，这包含 “ICMP、UDP”、“RAW IP”等，那么为什么会发生这样的问题？ 我们在阻塞模式下是不存在这个问题，但本文描述的问题仅仅包含在以下几个 Socket 异步接口实现上面。 以下为发生故障的 .NET API： 1、System::Net::Sockets::Socket::BeginSendTo 2、System::Net::Sockets::Socket::BeginReceiveFrom 3、System::N
libuv学习笔记（5）
paohui0134的博客
06-12 3308
libuv学习笔记（5） uv_timer_t 定时器的数据结构与相关API
libhv libuv
09-01
libhv和libuv都是开源的跨平台网络库，用于处理网络编程中的底层操作。它们的主要功能是封装对操作系统提供的异步IO接口，使开发者能更加方便地编写高性能的网络应用程序。 libhv是基于C语言的网络库，提供了一套...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值