udp.c File Reference

#include <assert.h>
#include <stdlib.h>
#include "uv.h"
#include "internal.h"
#include "handle-inl.h"
#include "stream-inl.h"
#include "req-inl.h"

Go to the source code of this file.

Macros
#define	SOCKOPT_SETTER(name, option4, option6, validate)
#define	VALIDATE_TTL(value)   ((value) >= 1 && (value) <= 255)
#define	VALIDATE_MULTICAST_TTL(value)   ((value) >= -1 && (value) <= 255)
#define	VALIDATE_MULTICAST_LOOP(value)   (1)

Functions
int	uv_udp_getpeername (const uv_udp_t *handle, struct sockaddr *name, int *namelen)
int	uv_udp_getsockname (const uv_udp_t *handle, struct sockaddr *name, int *namelen)
static int	uv_udp_set_socket (uv_loop_t *loop, uv_udp_t *handle, SOCKET socket, int family)
int	uv__udp_init_ex (uv_loop_t *loop, uv_udp_t *handle, unsigned flags, int domain)
void	uv_udp_close (uv_loop_t *loop, uv_udp_t *handle)
void	uv_udp_endgame (uv_loop_t *loop, uv_udp_t *handle)
int	uv_udp_using_recvmmsg (const uv_udp_t *handle)
static int	uv_udp_maybe_bind (uv_udp_t *handle, const struct sockaddr *addr, unsigned int addrlen, unsigned int flags)
static void	uv_udp_queue_recv (uv_loop_t *loop, uv_udp_t *handle)
int	uv__udp_recv_start (uv_udp_t *handle, uv_alloc_cb alloc_cb, uv_udp_recv_cb recv_cb)
int	uv__udp_recv_stop (uv_udp_t *handle)
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)
void	uv_process_udp_recv_req (uv_loop_t *loop, uv_udp_t *handle, uv_req_t *req)
void	uv_process_udp_send_req (uv_loop_t *loop, uv_udp_t *handle, uv_udp_send_t *req)
static int	uv__udp_set_membership4 (uv_udp_t *handle, const struct sockaddr_in *multicast_addr, const char *interface_addr, uv_membership membership)
int	uv__udp_set_membership6 (uv_udp_t *handle, const struct sockaddr_in6 *multicast_addr, const char *interface_addr, uv_membership membership)
static int	uv__udp_set_source_membership4 (uv_udp_t *handle, const struct sockaddr_in *multicast_addr, const char *interface_addr, const struct sockaddr_in *source_addr, uv_membership membership)
int	uv__udp_set_source_membership6 (uv_udp_t *handle, const struct sockaddr_in6 *multicast_addr, const char *interface_addr, const struct sockaddr_in6 *source_addr, uv_membership membership)
int	uv_udp_set_membership (uv_udp_t *handle, const char *multicast_addr, const char *interface_addr, uv_membership membership)
int	uv_udp_set_source_membership (uv_udp_t *handle, const char *multicast_addr, const char *interface_addr, const char *source_addr, uv_membership membership)
int	uv_udp_set_multicast_interface (uv_udp_t *handle, const char *interface_addr)
int	uv_udp_set_broadcast (uv_udp_t *handle, int value)
int	uv__udp_is_bound (uv_udp_t *handle)
int	uv_udp_open (uv_udp_t *handle, uv_os_sock_t sock)
	SOCKOPT_SETTER (ttl, IP_TTL, IPV6_HOPLIMIT, VALIDATE_TTL)
int	uv__udp_connect (uv_udp_t *handle, const struct sockaddr *addr, unsigned int addrlen)
int	uv__udp_disconnect (uv_udp_t *handle)
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)
int	uv__udp_try_send (uv_udp_t *handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr *addr, unsigned int addrlen)

Variables
const unsigned int	uv_active_udp_streams_threshold = 0
static char	uv_zero_ [] = ""

Macro Definition Documentation

SOCKOPT_SETTER

#define SOCKOPT_SETTER	(		name,
			option4,
			option6,
			validate
	)

Definition at line 982 of file udp.c.

VALIDATE_MULTICAST_LOOP

#define VALIDATE_MULTICAST_LOOP

(

value

)

(1)

Definition at line 1017 of file udp.c.

VALIDATE_MULTICAST_TTL

#define VALIDATE_MULTICAST_TTL

(

value

)

((value) >= -1 && (value) <= 255)

Definition at line 1016 of file udp.c.

VALIDATE_TTL

#define VALIDATE_TTL

(

value

)

((value) >= 1 && (value) <= 255)

Definition at line 1015 of file udp.c.

Function Documentation

SOCKOPT_SETTER()

SOCKOPT_SETTER	(	ttl	,
		IP_TTL	,
		IPV6_HOPLIMIT	,
		VALIDATE_TTL
	)

Definition at line 1019 of file udp.c.

                                     {
  int err;
 
  err = uv_udp_maybe_bind(handle, addr, addrlen, flags);
  if (err)
    return uv_translate_sys_error(err);
 
  return 0;
}

References addr, addrlen, err, flags, handle, uv_translate_sys_error(), and uv_udp_maybe_bind().

uv__send()

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  )

static

Definition at line 404 of file udp.c.

                                       {
  uv_loop_t* loop = handle->loop;
  DWORD result, bytes;
 
  UV_REQ_INIT(req, 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)) {
    /* Request completed immediately. */
    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)) {
    /* Request queued by the kernel. */
    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 {
    /* Send failed due to an error. */
    return WSAGetLastError();
  }
 
  return 0;
}

References addr, addrlen, bufs, bytes, cb, DWORD, handle, loop, memset(), NULL, REGISTER_HANDLE_REQ, req, uv__count_bufs(), uv_insert_pending_req(), UV_REQ_INIT, UV_SUCCEEDED_WITH_IOCP, and UV_SUCCEEDED_WITHOUT_IOCP.

Referenced by uv__udp_send().

uv__udp_connect()

int uv__udp_connect	(	uv_udp_t *	handle,
		const struct sockaddr *	addr,
		unsigned int	addrlen
	)

Definition at line 1055 of file udp.c.

                                          {
  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
      return UV_EINVAL;
 
    err = uv_udp_maybe_bind(handle, bind_addr, addrlen, 0);
    if (err)
      return uv_translate_sys_error(err);
  }
 
  err = connect(handle->socket, addr, addrlen);
  if (err)
    return uv_translate_sys_error(WSAGetLastError());
 
  handle->flags |= UV_HANDLE_UDP_CONNECTED;
 
  return 0;
}

References addr, addrlen, err, handle, uv_addr_ip4_any_, uv_addr_ip6_any_, UV_HANDLE_BOUND, UV_HANDLE_UDP_CONNECTED, uv_translate_sys_error(), and uv_udp_maybe_bind().

uv__udp_disconnect()

int uv__udp_disconnect

(

uv_udp_t *

handle

)

Definition at line 1084 of file udp.c.

                                         {
    int err;
    struct sockaddr addr;
 
    memset(&addr, 0, sizeof(addr));
 
    err = connect(handle->socket, &addr, sizeof(addr));
    if (err)
      return uv_translate_sys_error(WSAGetLastError());
 
    handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
    return 0;
}

References addr, err, handle, memset(), UV_HANDLE_UDP_CONNECTED, and uv_translate_sys_error().

uv__udp_init_ex()

int uv__udp_init_ex	(	uv_loop_t *	loop,
		uv_udp_t *	handle,
		unsigned	flags,
		int	domain
	)

Definition at line 128 of file udp.c.

                                {
  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(&handle->recv_req, UV_UDP_RECV);
  handle->recv_req.data = handle;
 
  /* If anything fails beyond this point we need to remove the handle from
   * the handle queue, since it was added by uv__handle_init.
   */
 
  if (domain != AF_UNSPEC) {
    SOCKET sock;
    DWORD err;
 
    sock = socket(domain, SOCK_DGRAM, 0);
    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;
}

References AF_UNSPEC, domain, DWORD, err, handle, loop, QUEUE_REMOVE, SOCK_DGRAM, socket, uv__handle_init, UV_REQ_INIT, uv_translate_sys_error(), and uv_udp_set_socket().

uv__udp_is_bound()

int uv__udp_is_bound

(

uv_udp_t *

handle

)

Definition at line 938 of file udp.c.

                                       {
  struct sockaddr_storage addr;
  int addrlen;
 
  addrlen = sizeof(addr);
  if (uv_udp_getsockname(handle, (struct sockaddr*) &addr, &addrlen) != 0)
    return 0;
 
  return addrlen > 0;
}

References addr, addrlen, handle, and uv_udp_getsockname().

Referenced by uv_udp_open().

uv__udp_recv_start()

int uv__udp_recv_start	(	uv_udp_t *	handle,
		uv_alloc_cb	alloc_cb,
		uv_udp_recv_cb	recv_cb
	)

Definition at line 361 of file udp.c.

                            {
  uv_loop_t* loop = handle->loop;
  int err;
 
  if (handle->flags & UV_HANDLE_READING) {
    return UV_EALREADY;
  }
 
  err = uv_udp_maybe_bind(handle,
                          (const struct sockaddr*) &uv_addr_ip4_any_,
                          sizeof(uv_addr_ip4_any_),
                          0);
  if (err)
    return uv_translate_sys_error(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 reading was stopped and then started again, there could still be a recv
   * request pending. */
  if (!(handle->flags & UV_HANDLE_READ_PENDING))
    uv_udp_queue_recv(loop, handle);
 
  return 0;
}

References err, handle, INCREASE_ACTIVE_COUNT, loop, uv_addr_ip4_any_, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, uv_translate_sys_error(), uv_udp_maybe_bind(), and uv_udp_queue_recv().

uv__udp_recv_stop()

int uv__udp_recv_stop

(

uv_udp_t *

handle

)

Definition at line 393 of file udp.c.

                                        {
  if (handle->flags & UV_HANDLE_READING) {
    handle->flags &= ~UV_HANDLE_READING;
    handle->loop->active_udp_streams--;
    DECREASE_ACTIVE_COUNT(loop, handle);
  }
 
  return 0;
}

References DECREASE_ACTIVE_COUNT, handle, loop, and UV_HANDLE_READING.

uv__udp_send()

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
	)

Definition at line 1102 of file udp.c.

                                         {
  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
      return UV_EINVAL;
 
    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;
}

References addr, addrlen, bufs, err, handle, req, uv__send(), uv_addr_ip4_any_, uv_addr_ip6_any_, UV_HANDLE_BOUND, uv_translate_sys_error(), and uv_udp_maybe_bind().

uv__udp_set_membership4()

static int uv__udp_set_membership4 ( uv_udp_t *  handle, const struct sockaddr_in *  multicast_addr, const char *  interface_addr, uv_membership  membership  )

static

Definition at line 589 of file udp.c.

                                                             {
  int err;
  int optname;
  struct ip_mreq mreq;
 
  if (handle->flags & UV_HANDLE_IPV6)
    return UV_EINVAL;
 
  /* If the socket is unbound, bind to inaddr_any. */
  err = uv_udp_maybe_bind(handle,
                          (const struct sockaddr*) &uv_addr_ip4_any_,
                          sizeof(uv_addr_ip4_any_),
                          UV_UDP_REUSEADDR);
  if (err)
    return uv_translate_sys_error(err);
 
  memset(&mreq, 0, sizeof mreq);
 
  if (interface_addr) {
    err = uv_inet_pton(AF_INET, interface_addr, &mreq.imr_interface.s_addr);
    if (err)
      return err;
  } else {
    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
  }
 
  mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;
 
  switch (membership) {
    case UV_JOIN_GROUP:
      optname = IP_ADD_MEMBERSHIP;
      break;
    case UV_LEAVE_GROUP:
      optname = IP_DROP_MEMBERSHIP;
      break;
    default:
      return UV_EINVAL;
  }
 
  if (setsockopt(handle->socket,
                 IPPROTO_IP,
                 optname,
                 (char*) &mreq,
                 sizeof mreq) == SOCKET_ERROR) {
    return uv_translate_sys_error(WSAGetLastError());
  }
 
  return 0;
}

References AF_INET, err, handle, memset(), in_addr::s_addr, sockaddr_in::sin_addr, uv_addr_ip4_any_, UV_HANDLE_IPV6, uv_inet_pton(), UV_JOIN_GROUP, UV_LEAVE_GROUP, uv_translate_sys_error(), uv_udp_maybe_bind(), and UV_UDP_REUSEADDR.

Referenced by uv_udp_set_membership().

uv__udp_set_membership6()

int uv__udp_set_membership6	(	uv_udp_t *	handle,
		const struct sockaddr_in6 *	multicast_addr,
		const char *	interface_addr,
		uv_membership	membership
	)

Definition at line 643 of file udp.c.

                                                      {
  int optname;
  int err;
  struct ipv6_mreq mreq;
  struct sockaddr_in6 addr6;
 
  if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
    return UV_EINVAL;
 
  err = uv_udp_maybe_bind(handle,
                          (const struct sockaddr*) &uv_addr_ip6_any_,
                          sizeof(uv_addr_ip6_any_),
                          UV_UDP_REUSEADDR);
 
  if (err)
    return uv_translate_sys_error(err);
 
  memset(&mreq, 0, sizeof(mreq));
 
  if (interface_addr) {
    if (uv_ip6_addr(interface_addr, 0, &addr6))
      return UV_EINVAL;
    mreq.ipv6mr_interface = addr6.sin6_scope_id;
  } else {
    mreq.ipv6mr_interface = 0;
  }
 
  mreq.ipv6mr_multiaddr = multicast_addr->sin6_addr;
 
  switch (membership) {
  case UV_JOIN_GROUP:
    optname = IPV6_ADD_MEMBERSHIP;
    break;
  case UV_LEAVE_GROUP:
    optname = IPV6_DROP_MEMBERSHIP;
    break;
  default:
    return UV_EINVAL;
  }
 
  if (setsockopt(handle->socket,
                 IPPROTO_IPV6,
                 optname,
                 (char*) &mreq,
                 sizeof mreq) == SOCKET_ERROR) {
    return uv_translate_sys_error(WSAGetLastError());
  }
 
  return 0;
}

References err, handle, memset(), sockaddr_in6::sin6_addr, sockaddr_in6::sin6_scope_id, uv_addr_ip6_any_, UV_HANDLE_BOUND, UV_HANDLE_IPV6, uv_ip6_addr(), UV_JOIN_GROUP, UV_LEAVE_GROUP, uv_translate_sys_error(), uv_udp_maybe_bind(), and UV_UDP_REUSEADDR.

Referenced by uv_udp_set_membership().

uv__udp_set_source_membership4()

static int uv__udp_set_source_membership4 ( uv_udp_t *  handle, const struct sockaddr_in *  multicast_addr, const char *  interface_addr, const struct sockaddr_in *  source_addr, uv_membership  membership  )

static

Definition at line 698 of file udp.c.

                                                                    {
  struct ip_mreq_source mreq;
  int optname;
  int err;
 
  if (handle->flags & UV_HANDLE_IPV6)
    return UV_EINVAL;
 
  /* If the socket is unbound, bind to inaddr_any. */
  err = uv_udp_maybe_bind(handle,
                          (const struct sockaddr*) &uv_addr_ip4_any_,
                          sizeof(uv_addr_ip4_any_),
                          UV_UDP_REUSEADDR);
  if (err)
    return uv_translate_sys_error(err);
 
  memset(&mreq, 0, sizeof(mreq));
 
  if (interface_addr != NULL) {
    err = uv_inet_pton(AF_INET, interface_addr, &mreq.imr_interface.s_addr);
    if (err)
      return err;
  } else {
    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
  }
 
  mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;
  mreq.imr_sourceaddr.s_addr = source_addr->sin_addr.s_addr;
 
  if (membership == UV_JOIN_GROUP)
    optname = IP_ADD_SOURCE_MEMBERSHIP;
  else if (membership == UV_LEAVE_GROUP)
    optname = IP_DROP_SOURCE_MEMBERSHIP;
  else
    return UV_EINVAL;
 
  if (setsockopt(handle->socket,
                 IPPROTO_IP,
                 optname,
                 (char*) &mreq,
                 sizeof(mreq)) == SOCKET_ERROR) {
    return uv_translate_sys_error(WSAGetLastError());
  }
 
  return 0;
}

References AF_INET, err, handle, memset(), NULL, in_addr::s_addr, sockaddr_in::sin_addr, uv_addr_ip4_any_, UV_HANDLE_IPV6, uv_inet_pton(), UV_JOIN_GROUP, UV_LEAVE_GROUP, uv_translate_sys_error(), uv_udp_maybe_bind(), and UV_UDP_REUSEADDR.

Referenced by uv_udp_set_source_membership().

uv__udp_set_source_membership6()

int uv__udp_set_source_membership6	(	uv_udp_t *	handle,
		const struct sockaddr_in6 *	multicast_addr,
		const char *	interface_addr,
		const struct sockaddr_in6 *	source_addr,
		uv_membership	membership
	)

Definition at line 750 of file udp.c.

                                                             {
  struct group_source_req mreq;
  struct sockaddr_in6 addr6;
  int optname;
  int err;
 
  STATIC_ASSERT(sizeof(mreq.gsr_group) >= sizeof(*multicast_addr));
  STATIC_ASSERT(sizeof(mreq.gsr_source) >= sizeof(*source_addr));
 
  if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
    return UV_EINVAL;
 
  err = uv_udp_maybe_bind(handle,
                          (const struct sockaddr*) &uv_addr_ip6_any_,
                          sizeof(uv_addr_ip6_any_),
                          UV_UDP_REUSEADDR);
 
  if (err)
    return uv_translate_sys_error(err);
 
  memset(&mreq, 0, sizeof(mreq));
 
  if (interface_addr != NULL) {
    err = uv_ip6_addr(interface_addr, 0, &addr6);
    if (err)
      return err;
    mreq.gsr_interface = addr6.sin6_scope_id;
  } else {
    mreq.gsr_interface = 0;
  }
 
  memcpy(&mreq.gsr_group, multicast_addr, sizeof(*multicast_addr));
  memcpy(&mreq.gsr_source, source_addr, sizeof(*source_addr));
 
  if (membership == UV_JOIN_GROUP)
    optname = MCAST_JOIN_SOURCE_GROUP;
  else if (membership == UV_LEAVE_GROUP)
    optname = MCAST_LEAVE_SOURCE_GROUP;
  else
    return UV_EINVAL;
 
  if (setsockopt(handle->socket,
                 IPPROTO_IPV6,
                 optname,
                 (char*) &mreq,
                 sizeof(mreq)) == SOCKET_ERROR) {
    return uv_translate_sys_error(WSAGetLastError());
  }
 
  return 0;
}

References err, handle, MCAST_JOIN_SOURCE_GROUP, MCAST_LEAVE_SOURCE_GROUP, memcpy(), memset(), NULL, sockaddr_in6::sin6_scope_id, STATIC_ASSERT, uv_addr_ip6_any_, UV_HANDLE_BOUND, UV_HANDLE_IPV6, uv_ip6_addr(), UV_JOIN_GROUP, UV_LEAVE_GROUP, uv_translate_sys_error(), uv_udp_maybe_bind(), and UV_UDP_REUSEADDR.

Referenced by uv_udp_set_source_membership().

uv__udp_try_send()

int uv__udp_try_send	(	uv_udp_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		const struct sockaddr *	addr,
		unsigned int	addrlen
	)

Definition at line 1133 of file udp.c.

                                           {
  DWORD bytes;
  const struct sockaddr* bind_addr;
  struct sockaddr_storage converted;
  int err;
 
  assert(nbufs > 0);
 
  if (addr != NULL) {
    err = uv__convert_to_localhost_if_unspecified(addr, &converted);
    if (err)
      return err;
  }
 
  /* Already sending a message.*/
  if (handle->send_queue_count != 0)
    return UV_EAGAIN;
 
  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
      return UV_EINVAL;
    err = uv_udp_maybe_bind(handle, bind_addr, addrlen, 0);
    if (err)
      return uv_translate_sys_error(err);
  }
 
  err = WSASendTo(handle->socket,
                  (WSABUF*)bufs,
                  nbufs,
                  &bytes,
                  0,
                  (const struct sockaddr*) &converted,
                  addrlen,
                  NULL,
                  NULL);
 
  if (err)
    return uv_translate_sys_error(WSAGetLastError());
 
  return bytes;
}

References addr, addrlen, assert(), bufs, bytes, DWORD, err, handle, NULL, uv__convert_to_localhost_if_unspecified(), uv_addr_ip4_any_, uv_addr_ip6_any_, UV_HANDLE_BOUND, uv_translate_sys_error(), and uv_udp_maybe_bind().

uv_process_udp_recv_req()

void uv_process_udp_recv_req	(	uv_loop_t *	loop,
		uv_udp_t *	handle,
		uv_req_t *	req
	)

Definition at line 453 of file udp.c.

                   {
  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) {
      /* Not a real error, it just indicates that the received packet was
       * bigger than the receive buffer. */
    } else if (err == WSAECONNRESET || err == WSAENETRESET) {
      /* A previous sendto operation failed; ignore this error. If zero-reading
       * we need to call WSARecv/WSARecvFrom _without_ the. MSG_PEEK flag to
       * clear out the error queue. For nonzero reads, immediately queue a new
       * receive. */
      if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
        goto done;
      }
    } else {
      /* A real error occurred. Report the error to the user only if we're
       * currently reading. */
      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)) {
    /* Successful 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;
 
    /* Do a nonblocking receive.
     * TODO: try to read multiple datagrams at once. FIONREAD maybe? */
    buf = uv_buf_init(NULL, 0);
    handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);
    if (buf.base == NULL || 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) {
 
      /* Message received */
      handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0);
    } else {
      err = WSAGetLastError();
      if (err == WSAEMSGSIZE) {
        /* Message truncated */
        handle->recv_cb(handle,
                        bytes,
                        &buf,
                        (const struct sockaddr*) &from,
                        UV_UDP_PARTIAL);
      } else if (err == WSAEWOULDBLOCK) {
        /* Kernel buffer empty */
        handle->recv_cb(handle, 0, &buf, NULL, 0);
      } else if (err == WSAECONNRESET || err == WSAENETRESET) {
        /* WSAECONNRESET/WSANETRESET is ignored because this just indicates
         * that a previous sendto operation failed.
         */
        handle->recv_cb(handle, 0, &buf, NULL, 0);
      } else {
        /* Any other error that we want to report back to the user. */
        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);
}

References assert(), bytes, DECREASE_PENDING_REQ_COUNT, done, DWORD, err, flags, from, GET_REQ_SOCK_ERROR, handle, loop, memset(), NULL, req, REQ_SUCCESS, uv_buf_init(), UV_HANDLE_READ_PENDING, UV_HANDLE_READING, UV_HANDLE_ZERO_READ, uv_translate_sys_error(), UV_UDP_PARTIAL, uv_udp_queue_recv(), and uv_udp_recv_stop().

Referenced by uv_process_reqs().

uv_process_udp_send_req()

void uv_process_udp_send_req	(	uv_loop_t *	loop,
		uv_udp_t *	handle,
		uv_udp_send_t *	req
	)

Definition at line 564 of file udp.c.

                        {
  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);
}

References assert(), DECREASE_PENDING_REQ_COUNT, err, GET_REQ_SOCK_ERROR, handle, loop, req, REQ_SUCCESS, UNREGISTER_HANDLE_REQ, and uv_translate_sys_error().

Referenced by uv_process_reqs().

uv_udp_close()

void uv_udp_close	(	uv_loop_t *	loop,
		uv_udp_t *	handle
	)

Definition at line 170 of file udp.c.

                                                     {
  uv_udp_recv_stop(handle);
  closesocket(handle->socket);
  handle->socket = INVALID_SOCKET;
 
  uv__handle_closing(handle);
 
  if (handle->reqs_pending == 0) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
}

References handle, loop, uv__handle_closing, uv_udp_recv_stop(), and uv_want_endgame().

Referenced by uv_close().

uv_udp_endgame()

void uv_udp_endgame	(	uv_loop_t *	loop,
		uv_udp_t *	handle
	)

Definition at line 183 of file udp.c.

                                                       {
  if (handle->flags & UV_HANDLE_CLOSING &&
      handle->reqs_pending == 0) {
    assert(!(handle->flags & UV_HANDLE_CLOSED));
    uv__handle_close(handle);
  }
}

References assert(), handle, uv__handle_close, UV_HANDLE_CLOSED, and UV_HANDLE_CLOSING.

Referenced by uv_process_endgames().

uv_udp_getpeername()

int uv_udp_getpeername	(	const uv_udp_t *	handle,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 39 of file udp.c.

                                     {
 
  return uv__getsockpeername((const uv_handle_t*) handle,
                             getpeername,
                             name,
                             namelen,
                             0);
}

References handle, and uv__getsockpeername().

Referenced by uv__udp_is_connected().

uv_udp_getsockname()

int uv_udp_getsockname	(	const uv_udp_t *	handle,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 51 of file udp.c.

                                     {
 
  return uv__getsockpeername((const uv_handle_t*) handle,
                             getsockname,
                             name,
                             namelen,
                             0);
}

References handle, and uv__getsockpeername().

uv_udp_maybe_bind()

static int uv_udp_maybe_bind ( uv_udp_t *  handle, const struct sockaddr *  addr, unsigned int  addrlen, unsigned int  flags  )

static

Definition at line 197 of file udp.c.

                                                 {
  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) {
    /* UV_UDP_IPV6ONLY is supported only for IPV6 sockets */
    return ERROR_INVALID_PARAMETER;
  }
 
  if (handle->socket == INVALID_SOCKET) {
    SOCKET sock = socket(addr->sa_family, SOCK_DGRAM, 0);
    if (sock == INVALID_SOCKET) {
      return WSAGetLastError();
    }
 
    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)) {
    /* On windows IPV6ONLY is on by default. If the user doesn't specify it
     * libuv turns it off. */
 
    /* TODO: how to handle errors? This may fail if there is no ipv4 stack
     * available, or when run on XP/2003 which have no support for dualstack
     * sockets. For now we're silently ignoring the error. */
    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;
}

References addr, addrlen, AF_INET6, bind, DWORD, err, flags, handle, IPV6_V6ONLY, r, SO_REUSEADDR, SOCK_DGRAM, socket, SOL_SOCKET, UV_HANDLE_BOUND, UV_HANDLE_IPV6, UV_UDP_IPV6ONLY, UV_UDP_REUSEADDR, and uv_udp_set_socket().

Referenced by SOCKOPT_SETTER(), uv__udp_connect(), uv__udp_recv_start(), uv__udp_send(), uv__udp_set_membership4(), uv__udp_set_membership6(), uv__udp_set_source_membership4(), uv__udp_set_source_membership6(), and uv__udp_try_send().

uv_udp_open()

int uv_udp_open	(	uv_udp_t *	handle,
		uv_os_sock_t	sock
	)

Definition at line 950 of file udp.c.

                                                     {
  WSAPROTOCOL_INFOW protocol_info;
  int opt_len;
  int err;
 
  /* Detect the address family of the 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());
  }
 
  err = uv_udp_set_socket(handle->loop,
                          handle,
                          sock,
                          protocol_info.iAddressFamily);
  if (err)
    return uv_translate_sys_error(err);
 
  if (uv__udp_is_bound(handle))
    handle->flags |= UV_HANDLE_BOUND;
 
  if (uv__udp_is_connected(handle))
    handle->flags |= UV_HANDLE_UDP_CONNECTED;
 
  return 0;
}

References err, handle, int, SOL_SOCKET, uv__fd_exists(), uv__nonblock, uv__set_reuse(), uv__udp_is_bound(), uv__udp_is_connected(), UV_HANDLE_BOUND, UV_HANDLE_UDP_CONNECTED, uv_translate_sys_error(), and uv_udp_set_socket().

Referenced by uv_accept().

uv_udp_queue_recv()

static void uv_udp_queue_recv ( uv_loop_t *  loop, uv_udp_t *  handle  )

static

Definition at line 267 of file udp.c.

                                                                 {
  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));
 
  /*
   * Preallocate a read buffer if the number of active streams is below
   * the threshold.
  */
  if (loop->active_udp_streams < uv_active_udp_streams_threshold) {
    handle->flags &= ~UV_HANDLE_ZERO_READ;
 
    handle->recv_buffer = uv_buf_init(NULL, 0);
    handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->recv_buffer);
    if (handle->recv_buffer.base == NULL || handle->recv_buffer.len == 0) {
      handle->recv_cb(handle, UV_ENOBUFS, &handle->recv_buffer, NULL, 0);
      return;
    }
    assert(handle->recv_buffer.base != NULL);
 
    buf = handle->recv_buffer;
    memset(&handle->recv_from, 0, sizeof handle->recv_from);
    handle->recv_from_len = sizeof handle->recv_from;
    flags = 0;
 
    result = handle->func_wsarecvfrom(handle->socket,
                                      (WSABUF*) &buf,
                                      1,
                                      &bytes,
                                      &flags,
                                      (struct sockaddr*) &handle->recv_from,
                                      &handle->recv_from_len,
                                      &req->u.io.overlapped,
                                      NULL);
 
    if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
      /* Process the req without 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)) {
      /* The req will be processed with IOCP. */
      handle->flags |= UV_HANDLE_READ_PENDING;
      handle->reqs_pending++;
    } else {
      /* Make this req pending reporting an error. */
      SET_REQ_ERROR(req, WSAGetLastError());
      uv_insert_pending_req(loop, req);
      handle->reqs_pending++;
    }
 
  } 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)) {
      /* Process the req without 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)) {
      /* The req will be processed with IOCP. */
      handle->flags |= UV_HANDLE_READ_PENDING;
      handle->reqs_pending++;
    } else {
      /* Make this req pending reporting an error. */
      SET_REQ_ERROR(req, WSAGetLastError());
      uv_insert_pending_req(loop, req);
      handle->reqs_pending++;
    }
  }
}

References assert(), bytes, DWORD, flags, handle, loop, memset(), NULL, req, SET_REQ_ERROR, uv_active_udp_streams_threshold, uv_buf_init(), UV_HANDLE_READ_PENDING, UV_HANDLE_READING, UV_HANDLE_ZERO_READ, uv_insert_pending_req(), UV_SUCCEEDED_WITH_IOCP, UV_SUCCEEDED_WITHOUT_IOCP, and uv_zero_.

Referenced by uv__udp_recv_start(), and uv_process_udp_recv_req().

uv_udp_set_broadcast()

int uv_udp_set_broadcast	(	uv_udp_t *	handle,
		int	value
	)

Definition at line 920 of file udp.c.

                                                      {
  BOOL optval = (BOOL) value;
 
  if (handle->socket == INVALID_SOCKET)
    return UV_EBADF;
 
  if (setsockopt(handle->socket,
                 SOL_SOCKET,
                 SO_BROADCAST,
                 (char*) &optval,
                 sizeof optval)) {
    return uv_translate_sys_error(WSAGetLastError());
  }
 
  return 0;
}

References handle, SO_BROADCAST, SOL_SOCKET, UV__ERR, uv_translate_sys_error(), and value.

Referenced by main().

uv_udp_set_membership()

int uv_udp_set_membership	(	uv_udp_t *	handle,
		const char *	multicast_addr,
		const char *	interface_addr,
		uv_membership	membership
	)

Definition at line 807 of file udp.c.

                                                    {
  struct sockaddr_in addr4;
  struct sockaddr_in6 addr6;
 
  if (uv_ip4_addr(multicast_addr, 0, &addr4) == 0)
    return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
  else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0)
    return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
  else
    return UV_EINVAL;
}

References AF_INET, AF_INET6, err, handle, uv__udp_maybe_deferred_bind(), uv__udp_set_membership4(), uv__udp_set_membership6(), uv_ip4_addr(), uv_ip6_addr(), and UV_UDP_REUSEADDR.

uv_udp_set_multicast_interface()

int uv_udp_set_multicast_interface	(	uv_udp_t *	handle,
		const char *	interface_addr
	)

Definition at line 867 of file udp.c.

                                                                                 {
  struct sockaddr_storage addr_st;
  struct sockaddr_in* addr4;
  struct sockaddr_in6* addr6;
 
  addr4 = (struct sockaddr_in*) &addr_st;
  addr6 = (struct sockaddr_in6*) &addr_st;
 
  if (!interface_addr) {
    memset(&addr_st, 0, sizeof addr_st);
    if (handle->flags & UV_HANDLE_IPV6) {
      addr_st.ss_family = AF_INET6;
      addr6->sin6_scope_id = 0;
    } else {
      addr_st.ss_family = AF_INET;
      addr4->sin_addr.s_addr = htonl(INADDR_ANY);
    }
  } else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {
    /* nothing, address was parsed */
  } else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {
    /* nothing, address was parsed */
  } else {
    return UV_EINVAL;
  }
 
  if (handle->socket == INVALID_SOCKET)
    return UV_EBADF;
 
  if (addr_st.ss_family == AF_INET) {
    if (setsockopt(handle->socket,
                   IPPROTO_IP,
                   IP_MULTICAST_IF,
                   (char*) &addr4->sin_addr,
                   sizeof(addr4->sin_addr)) == SOCKET_ERROR) {
      return uv_translate_sys_error(WSAGetLastError());
    }
  } else if (addr_st.ss_family == AF_INET6) {
    if (setsockopt(handle->socket,
                   IPPROTO_IPV6,
                   IPV6_MULTICAST_IF,
                   (char*) &addr6->sin6_scope_id,
                   sizeof(addr6->sin6_scope_id)) == SOCKET_ERROR) {
      return uv_translate_sys_error(WSAGetLastError());
    }
  } else {
    assert(0 && "unexpected address family");
    abort();
  }
 
  return 0;
}

References AF_INET, AF_INET6, assert(), handle, memset(), in_addr::s_addr, sockaddr_in6::sin6_scope_id, sockaddr_in::sin_addr, UV__ERR, UV_HANDLE_IPV6, uv_ip4_addr(), uv_ip6_addr(), and uv_translate_sys_error().

uv_udp_set_socket()

static int uv_udp_set_socket ( uv_loop_t *  loop, uv_udp_t *  handle, SOCKET  socket, int  family  )

static

Definition at line 63 of file udp.c.

                {
  DWORD yes = 1;
  WSAPROTOCOL_INFOW info;
  int opt_len;
 
  if (handle->socket != INVALID_SOCKET)
    return UV_EBUSY;
 
  /* Set the socket to nonblocking mode */
  if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {
    return WSAGetLastError();
  }
 
  /* Make the socket non-inheritable */
  if (!SetHandleInformation((HANDLE)socket, HANDLE_FLAG_INHERIT, 0)) {
    return GetLastError();
  }
 
  /* Associate it with the I/O completion port. Use uv_handle_t pointer as
   * completion key. */
  if (CreateIoCompletionPort((HANDLE)socket,
                             loop->iocp,
                             (ULONG_PTR)socket,
                             0) == NULL) {
    return GetLastError();
  }
 
  /* All known Windows that support SetFileCompletionNotificationModes have a
   * bug that makes it impossible to use this function in conjunction with
   * datagram sockets. We can work around that but only if the user is using
   * the default UDP driver (AFD) and has no other. LSPs stacked on top. Here
   * we check whether that is the case. */
  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) {
    if (SetFileCompletionNotificationModes(
            (HANDLE) socket,
            FILE_SKIP_SET_EVENT_ON_HANDLE |
                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;
 
  if (family == AF_INET6) {
    handle->flags |= UV_HANDLE_IPV6;
  } else {
    assert(!(handle->flags & UV_HANDLE_IPV6));
  }
 
  return 0;
}

References AF_INET6, assert(), DWORD, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS, FILE_SKIP_SET_EVENT_ON_HANDLE, FIONBIO, handle, HANDLE, info(), int, loop, NULL, socket, SOL_SOCKET, UV_HANDLE_IPV6, UV_HANDLE_SYNC_BYPASS_IOCP, uv_wsarecv_workaround(), and uv_wsarecvfrom_workaround().

Referenced by uv__udp_init_ex(), uv_udp_maybe_bind(), and uv_udp_open().

uv_udp_set_source_membership()

int uv_udp_set_source_membership	(	uv_udp_t *	handle,
		const char *	multicast_addr,
		const char *	interface_addr,
		const char *	source_addr,
		uv_membership	membership
	)

Definition at line 823 of file udp.c.

                                                           {
  int err;
  struct sockaddr_storage mcast_addr;
  struct sockaddr_in* mcast_addr4;
  struct sockaddr_in6* mcast_addr6;
  struct sockaddr_storage src_addr;
  struct sockaddr_in* src_addr4;
  struct sockaddr_in6* src_addr6;
 
  mcast_addr4 = (struct sockaddr_in*)&mcast_addr;
  mcast_addr6 = (struct sockaddr_in6*)&mcast_addr;
  src_addr4 = (struct sockaddr_in*)&src_addr;
  src_addr6 = (struct sockaddr_in6*)&src_addr;
 
  err = uv_ip4_addr(multicast_addr, 0, mcast_addr4);
  if (err) {
    err = uv_ip6_addr(multicast_addr, 0, mcast_addr6);
    if (err)
      return err;
    err = uv_ip6_addr(source_addr, 0, src_addr6);
    if (err)
      return err;
    return uv__udp_set_source_membership6(handle,
                                          mcast_addr6,
                                          interface_addr,
                                          src_addr6,
                                          membership);
  }
  
  err = uv_ip4_addr(source_addr, 0, src_addr4);
  if (err)
    return err;
  return uv__udp_set_source_membership4(handle,
                                        mcast_addr4,
                                        interface_addr,
                                        src_addr4,
                                        membership);
}

References err, handle, uv__sockaddr::in, uv__sockaddr::in6, uv__udp_set_source_membership4(), uv__udp_set_source_membership6(), uv_ip4_addr(), and uv_ip6_addr().

uv_udp_using_recvmmsg()

int uv_udp_using_recvmmsg

(

const uv_udp_t *

handle

)

Definition at line 192 of file udp.c.

                                                  {
  return 0;
}

References handle, once, UV_HANDLE_UDP_RECVMMSG, and uv_once().

Variable Documentation

uv_active_udp_streams_threshold

const unsigned int uv_active_udp_streams_threshold = 0

Definition at line 35 of file udp.c.

Referenced by uv_udp_queue_recv().

uv_zero_

char uv_zero_[] = ""

static

Definition at line 38 of file udp.c.

Referenced by uv_udp_queue_recv().