libuv学习笔记（16）

uv_udp_t数据结构与相关函数

数据结构

typedef struct uv_udp_s uv_udp_t;struct uv_udp_s {  UV_HANDLE_FIELDS//uv_handt_t的成员  //目前等待发送的数据  size_t send_queue_size;  //等待处理的发送请求  size_t send_queue_count;  //UV_UDP_PRIVATE_FIELDS展开如下：  SOCKET socket;                                                                unsigned int reqs_pending;                                                    int activecnt;                                                                uv_req_t recv_req;//接收请求                                                            uv_buf_t recv_buffer;//接收的数据                                                         struct sockaddr_storage recv_from;//数据来源的地址信息                                            int recv_from_len;                                                            uv_udp_recv_cb recv_cb;                                                       uv_alloc_cb alloc_cb;                                                         LPFN_WSARECV func_wsarecv;//异步函数指针                                                    LPFN_WSARECVFROM func_wsarecvfrom;//异步函数指针};

相关函数

初始化，导出函数，uv.h中声明，udp.c中定义

int uv_udp_init_ex(uv_loop_t* loop, uv_udp_t* handle, unsigned int flags) {  int domain;  //只是用低八位  domain = flags & 0xFF;  if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)    return UV_EINVAL;  if (flags & ~0xFF)    return UV_EINVAL;  //初始化handle，将handle添加到loop的handle队列  uv__handle_init(loop, (uv_handle_t*) handle, UV_UDP);  handle->socket = INVALID_SOCKET;  handle->reqs_pending = 0;  handle->activecnt = 0;  handle->func_wsarecv = WSARecv;  handle->func_wsarecvfrom = WSARecvFrom;  handle->send_queue_size = 0;  handle->send_queue_count = 0;  uv_req_init(loop, (uv_req_t*) &(handle->recv_req));//初始化接收请求  handle->recv_req.type = UV_UDP_RECV;  handle->recv_req.data = handle;  //如果有错误，移除loophandle队列中的本handle  if (domain != AF_UNSPEC) {//不支持AF_UNSPEC    SOCKET sock;    DWORD err;    sock = socket(domain, SOCK_DGRAM, 0);//获取一个socket    if (sock == INVALID_SOCKET) {      err = WSAGetLastError();      QUEUE_REMOVE(&handle->handle_queue);      return uv_translate_sys_error(err);    }    err = uv_udp_set_socket(handle->loop, handle, sock, domain);    if (err) {      closesocket(sock);      QUEUE_REMOVE(&handle->handle_queue);      return uv_translate_sys_error(err);    }  }  return 0;}

打开一个socket作为uv_udp_t，导出函数，uv.h中声明，udp.c中定义

int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {  WSAPROTOCOL_INFOW protocol_info;  int opt_len;  int err;  //获取socket地址类型  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与uv_udp_t联系起来  err = uv_udp_set_socket(handle->loop,                          handle,                          sock,                          protocol_info.iAddressFamily);  return uv_translate_sys_error(err);}

static int uv_udp_set_socket(uv_loop_t* loop, uv_udp_t* handle, SOCKET socket,    int family) {  DWORD yes = 1;  WSAPROTOCOL_INFOW info;  int opt_len;  if (handle->socket != INVALID_SOCKET)    return UV_EBUSY;  //socket设置为非阻塞模式   if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {    return WSAGetLastError();  }  if (!SetHandleInformation((HANDLE)socket, HANDLE_FLAG_INHERIT, 0)) {    return GetLastError();  }  //与iocp端口联系起来  if (CreateIoCompletionPort((HANDLE)socket,                             loop->iocp,                             (ULONG_PTR)socket,                             0) == NULL) {    return GetLastError();  }  if (pSetFileCompletionNotificationModes) {    //只能在原生的udp socket上使用SetFileCompletionNotificationModes函数    opt_len = (int) sizeof info;    if (getsockopt(socket,                   SOL_SOCKET,                   SO_PROTOCOL_INFOW,                   (char*) &info,                   &opt_len) == SOCKET_ERROR) {      return GetLastError();    }    if (info.ProtocolChain.ChainLen == 1) {//lsp链长度为1      if (pSetFileCompletionNotificationModes((HANDLE)socket,          FILE_SKIP_SET_EVENT_ON_HANDLE |//并不会改变socket句柄的状态（signal）          FILE_SKIP_COMPLETION_PORT_ON_SUCCESS)) {//不要将以同步方式完成的异步请求添加到与设                                                  //备相关联的完成端口中。        handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;        handle->func_wsarecv = uv_wsarecv_workaround;        handle->func_wsarecvfrom = uv_wsarecvfrom_workaround;      } else if (GetLastError() != ERROR_INVALID_FUNCTION) {        return GetLastError();      }    }  }  handle->socket = socket;//与uv_udp_t联系起来  if (family == AF_INET6) {    handle->flags |= UV_HANDLE_IPV6;  } else {    assert(!(handle->flags & UV_HANDLE_IPV6));  }  return 0;}

绑定，导出函数，uv.h中声明，udp.c中定义

int uv_udp_bind(uv_udp_t* handle,                const struct sockaddr* addr,                unsigned int flags) {  unsigned int addrlen;  if (handle->type != UV_UDP)    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__udp_bind(handle, addr, addrlen, flags);}

uv__udp_bind调用uv_udp_maybe_bind

static int uv_udp_maybe_bind(uv_udp_t* handle,                             const struct sockaddr* addr,                             unsigned int addrlen,                             unsigned int flags) {  int r;  int err;  DWORD no = 0;  if (handle->flags & UV_HANDLE_BOUND)    return 0;  if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6) {    //地址类型错误    return ERROR_INVALID_PARAMETER;  }  if (handle->socket == INVALID_SOCKET) {//没有socket就创建    SOCKET sock = socket(addr->sa_family, SOCK_DGRAM, 0);    if (sock == INVALID_SOCKET) {      return WSAGetLastError();    }    //socket与handle以及iocp端口联系起来    err = uv_udp_set_socket(handle->loop, handle, sock, addr->sa_family);    if (err) {      closesocket(sock);      return err;    }  }  if (flags & UV_UDP_REUSEADDR) {    DWORD yes = 1;    /* Set SO_REUSEADDR on the socket. */    if (setsockopt(handle->socket,                   SOL_SOCKET,                   SO_REUSEADDR,//允许重复绑定                   (char*) &yes,                   sizeof yes) == SOCKET_ERROR) {      err = WSAGetLastError();      return err;    }  }  if (addr->sa_family == AF_INET6)    handle->flags |= UV_HANDLE_IPV6;  if (addr->sa_family == AF_INET6 && !(flags & UV_UDP_IPV6ONLY)) {    setsockopt(handle->socket,               IPPROTO_IPV6,               IPV6_V6ONLY,               (char*) &no,               sizeof no);  }  /绑定  r = bind(handle->socket, addr, addrlen);  if (r == SOCKET_ERROR) {    return WSAGetLastError();  }  handle->flags |= UV_HANDLE_BOUND;  return 0;}

发送数据

int uv__udp_send(uv_udp_send_t* req,                 uv_udp_t* handle,                 const uv_buf_t bufs[],                 unsigned int nbufs,                 const struct sockaddr* addr,                 unsigned int addrlen,                 uv_udp_send_cb send_cb) {  const struct sockaddr* bind_addr;  int err;  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_udp_maybe_bind(handle, bind_addr, addrlen, 0);    if (err)      return uv_translate_sys_error(err);  }  err = uv__send(req, handle, bufs, nbufs, addr, addrlen, send_cb);  if (err)    return uv_translate_sys_error(err);  return 0;}

发送的内部处理函数

static int uv__send(uv_udp_send_t* req,                    uv_udp_t* handle,                    const uv_buf_t bufs[],                    unsigned int nbufs,                    const struct sockaddr* addr,                    unsigned int addrlen,                    uv_udp_send_cb cb) {  uv_loop_t* loop = handle->loop;  DWORD result, bytes;  //初始化发送请求  uv_req_init(loop, (uv_req_t*) req);  req->type = UV_UDP_SEND;  req->handle = handle;  req->cb = cb;  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));  //异步发送  result = WSASendTo(handle->socket,                     (WSABUF*)bufs,                     nbufs,                     &bytes,                     0,                     addr,                     addrlen,                     &req->u.io.overlapped,                     NULL);  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {    //不使用iocp，直接将请求添加到loop的请求列表    req->u.io.queued_bytes = 0;    handle->reqs_pending++;    handle->send_queue_size += req->u.io.queued_bytes;    handle->send_queue_count++;    REGISTER_HANDLE_REQ(loop, handle, req);    uv_insert_pending_req(loop, (uv_req_t*)req);  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {    //使用iocp    req->u.io.queued_bytes = uv__count_bufs(bufs, nbufs);//本次发送的数据    handle->reqs_pending++;    handle->send_queue_size += req->u.io.queued_bytes;//等待发送的数据    handle->send_queue_count++;//等待处理的发送请求    REGISTER_HANDLE_REQ(loop, handle, req);//注册请求  } else {    return WSAGetLastError();  }  return 0;}

对发送请求的处理：

void uv_process_udp_send_req(uv_loop_t* loop, uv_udp_t* handle,    uv_udp_send_t* req) {  int err;  assert(handle->type == UV_UDP);  assert(handle->send_queue_size >= req->u.io.queued_bytes);  assert(handle->send_queue_count >= 1);  handle->send_queue_size -= req->u.io.queued_bytes;//等待发送的数据  handle->send_queue_count--;//等待处理的请求  UNREGISTER_HANDLE_REQ(loop, handle, req);//取消请求的注册  if (req->cb) {    err = 0;    if (!REQ_SUCCESS(req)) {      err = GET_REQ_SOCK_ERROR(req);    }    req->cb(req, uv_translate_sys_error(err));//回调函数  }  DECREASE_PENDING_REQ_COUNT(handle);//handle活动请求递减，如果处于closing状态且活动请求为0，关闭handle}

开始读取

内部调用uv__udp_recv_start

int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,    uv_udp_recv_cb recv_cb) {  uv_loop_t* loop = handle->loop;  int err;  if (handle->flags & UV_HANDLE_READING) {    return WSAEALREADY;  }  //没绑定就绑定默认的地址  err = uv_udp_maybe_bind(handle,                          (const struct sockaddr*) &uv_addr_ip4_any_,                          sizeof(uv_addr_ip4_any_),                          0);  if (err)    return err;  handle->flags |= UV_HANDLE_READING;  INCREASE_ACTIVE_COUNT(loop, handle);  loop->active_udp_streams++;  handle->recv_cb = recv_cb;  handle->alloc_cb = alloc_cb;  if (!(handle->flags & UV_HANDLE_READ_PENDING))    uv_udp_queue_recv(loop, handle);//投递接收数据的请求  return 0;}

投递请求

static void uv_udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) {  uv_req_t* req;  uv_buf_t buf;  DWORD bytes, flags;  int result;  assert(handle->flags & UV_HANDLE_READING);  assert(!(handle->flags & UV_HANDLE_READ_PENDING));  req = &handle->recv_req;  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));  //uv_active_udp_streams_threshold为0，不再需要预分配了  if (loop->active_udp_streams < uv_active_udp_streams_threshold) {    ...  } else {    handle->flags |= UV_HANDLE_ZERO_READ;    buf.base = (char*) uv_zero_;    buf.len = 0;    flags = MSG_PEEK;    result = handle->func_wsarecv(handle->socket,                                  (WSABUF*) &buf,                                  1,                                  &bytes,                                  &flags,                                  &req->u.io.overlapped,                                  NULL);    if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {      //不使用iocp      handle->flags |= UV_HANDLE_READ_PENDING;      req->u.io.overlapped.InternalHigh = bytes;      handle->reqs_pending++;      uv_insert_pending_req(loop, req);    } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {      //使用iocp      handle->flags |= UV_HANDLE_READ_PENDING;      handle->reqs_pending++;    } else {      //出错      SET_REQ_ERROR(req, WSAGetLastError());      uv_insert_pending_req(loop, req);      handle->reqs_pending++;    }  }}

对读取请求的处理

void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,    uv_req_t* req) {  uv_buf_t buf;  int partial;  assert(handle->type == UV_UDP);  handle->flags &= ~UV_HANDLE_READ_PENDING;  if (!REQ_SUCCESS(req)) {//未成功读取    DWORD err = GET_REQ_SOCK_ERROR(req);    if (err == WSAEMSGSIZE) {      //包数据比缓存大    } else if (err == WSAECONNRESET || err == WSAENETRESET) {      if (!(handle->flags & UV_HANDLE_ZERO_READ)) {        goto done;      }    } else {      //真正的错误      if (handle->flags & UV_HANDLE_READING) {        uv_udp_recv_stop(handle);//停止接受        buf = (handle->flags & UV_HANDLE_ZERO_READ) ?              uv_buf_init(NULL, 0) : handle->recv_buffer;        handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);      }      goto done;    }  }  if (!(handle->flags & UV_HANDLE_ZERO_READ)) {    //成功读取    partial = !REQ_SUCCESS(req);    handle->recv_cb(handle,                    req->u.io.overlapped.InternalHigh,                    &handle->recv_buffer,                    (const struct sockaddr*) &handle->recv_from,                    partial ? UV_UDP_PARTIAL : 0);  } else if (handle->flags & UV_HANDLE_READING) {    DWORD bytes, err, flags;    struct sockaddr_storage from;    int from_len;    handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);    if (buf.len == 0) {      handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);      goto done;    }    assert(buf.base != NULL);    memset(&from, 0, sizeof from);    from_len = sizeof from;    flags = 0;    if (WSARecvFrom(handle->socket,                    (WSABUF*)&buf,                    1,                    &bytes,                    &flags,                    (struct sockaddr*) &from,                    &from_len,                    NULL,                    NULL) != SOCKET_ERROR) {      handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0);    } else {      err = WSAGetLastError();      if (err == WSAEMSGSIZE) {        handle->recv_cb(handle,                        bytes,                        &buf,                        (const struct sockaddr*) &from,                        UV_UDP_PARTIAL);      } else if (err == WSAEWOULDBLOCK) {        handle->recv_cb(handle, 0, &buf, NULL, 0);      } else if (err == WSAECONNRESET || err == WSAENETRESET) {        handle->recv_cb(handle, 0, &buf, NULL, 0);      } else {        uv_udp_recv_stop(handle);        handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);      }    }  }done:  /* Post another read if still reading and not closing. */  if ((handle->flags & UV_HANDLE_READING) &&      !(handle->flags & UV_HANDLE_READ_PENDING)) {    uv_udp_queue_recv(loop, handle);//继续投递读取请求  }  DECREASE_PENDING_REQ_COUNT(handle);}

停止读取

内部调用uv__udp_recv_stop

int uv__udp_recv_stop(uv_udp_t* handle) {  if (handle->flags & UV_HANDLE_READING) {    handle->flags &= ~UV_HANDLE_READING;//取消接受标记    handle->loop->active_udp_streams--;    DECREASE_ACTIVE_COUNT(loop, handle);  }  return 0;}

libuv还提供了一些组播相关的API，可以参考以下文章：
http://blog.csdn.net/langeldep/article/details/6167137