../deps/uv/src/unix/udp.c

Bug Summary

File:	out/../deps/uv/src/unix/udp.c
Warning:	line 229, column 19 1st function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name udp.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D _LARGEFILE_SOURCE -D _FILE_OFFSET_BITS=64 -D _GNU_SOURCE -I ../deps/uv/include -I ../deps/uv/src -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused-parameter -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fvisibility hidden -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c ../deps/uv/src/unix/udp.c
1/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/

22#include "uv.h"
23#include "internal.h"

25#include <assert.h>
26#include <string.h>
27#include <errno(*__errno_location ()).h>
28#include <stdlib.h>
29#include <unistd.h>
30#if defined(__MVS__)
31#include <xti.h>
32#endif
33#include <sys/un.h>

35#if defined(IPV6_JOIN_GROUP20) && !defined(IPV6_ADD_MEMBERSHIP20)
36# define IPV6_ADD_MEMBERSHIP20 IPV6_JOIN_GROUP20
37#endif

39#if defined(IPV6_LEAVE_GROUP21) && !defined(IPV6_DROP_MEMBERSHIP21)
40# define IPV6_DROP_MEMBERSHIP21 IPV6_LEAVE_GROUP21
41#endif

43union uv__sockaddr {
struct sockaddr_in6 in6;
struct sockaddr_in in;
struct sockaddr addr;
47};

49static void uv__udp_run_completed(uv_udp_t* handle);
50static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents);
51static void uv__udp_recvmsg(uv_udp_t* handle);
52static void uv__udp_sendmsg(uv_udp_t* handle);
53static int uv__udp_maybe_deferred_bind(uv_udp_t* handle,
                                     int domain,
                                     unsigned int flags);

57#if HAVE_MMSG1

59#define UV__MMSG_MAXWIDTH20 20

61static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf);
62static void uv__udp_sendmmsg(uv_udp_t* handle);

64static int uv__recvmmsg_avail;
65static int uv__sendmmsg_avail;
66static uv_once_t once = UV_ONCE_INIT0;

68static void uv__udp_mmsg_init(void) {
int ret;
int s;
s = uv__socket(AF_INET2, SOCK_DGRAMSOCK_DGRAM, 0);
if (s < 0)
  return;
ret = uv__sendmmsg(s, NULL((void*)0), 0);
if (ret == 0 || errno(*__errno_location ()) != ENOSYS38) {
  uv__sendmmsg_avail = 1;
  uv__recvmmsg_avail = 1;
} else {
  ret = uv__recvmmsg(s, NULL((void*)0), 0);
  if (ret == 0 || errno(*__errno_location ()) != ENOSYS38)
    uv__recvmmsg_avail = 1;
}
uv__close(s);
84}

86#endif

88void uv__udp_close(uv_udp_t* handle) {
uv__io_close(handle->loop, &handle->io_watcher);
uv__handle_stop(handle)do { if (((handle)->flags & UV_HANDLE_ACTIVE) == 0) break
; (handle)->flags &= ~UV_HANDLE_ACTIVE; if (((handle)->
flags & UV_HANDLE_REF) != 0) do { (handle)->loop->active_handles
--; } while (0); } while (0);

if (handle->io_watcher.fd != -1) {
  uv__close(handle->io_watcher.fd);
  handle->io_watcher.fd = -1;
}
96}


99void uv__udp_finish_close(uv_udp_t* handle) {
uv_udp_send_t* req;
QUEUE* q;

assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT))((void) sizeof ((!uv__io_active(&handle->io_watcher, 0x001
 | 0x004)) ? 1 : 0), __extension__ ({ if (!uv__io_active(&
handle->io_watcher, 0x001 | 0x004)) ; else __assert_fail (
"!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT)"
, "../deps/uv/src/unix/udp.c", 103, __extension__ __PRETTY_FUNCTION__
); }));
assert(handle->io_watcher.fd == -1)((void) sizeof ((handle->io_watcher.fd == -1) ? 1 : 0), __extension__
 ({ if (handle->io_watcher.fd == -1) ; else __assert_fail (
"handle->io_watcher.fd == -1", "../deps/uv/src/unix/udp.c"
, 104, __extension__ __PRETTY_FUNCTION__); }));

while (!QUEUE_EMPTY(&handle->write_queue)((const QUEUE *) (&handle->write_queue) == (const QUEUE
 *) (*(QUEUE **) &((*(&handle->write_queue))[0])))) {
  q = QUEUE_HEAD(&handle->write_queue)((*(QUEUE **) &((*(&handle->write_queue))[0])));
  QUEUE_REMOVE(q)do { ((*(QUEUE **) &((*((*(QUEUE **) &((*(q))[1]))))[
0]))) = (*(QUEUE **) &((*(q))[0])); ((*(QUEUE **) &((
*((*(QUEUE **) &((*(q))[0]))))[1]))) = (*(QUEUE **) &
((*(q))[1])); } while (0);

  req = QUEUE_DATA(q, uv_udp_send_t, queue)((uv_udp_send_t *) ((char *) (q) - __builtin_offsetof(uv_udp_send_t
, queue)));
  req->status = UV_ECANCELED;
  QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue)do { (*(QUEUE **) &((*(&req->queue))[0])) = (&
handle->write_completed_queue); (*(QUEUE **) &((*(&
req->queue))[1])) = (*(QUEUE **) &((*(&handle->
write_completed_queue))[1])); ((*(QUEUE **) &((*((*(QUEUE
 **) &((*(&req->queue))[1]))))[0]))) = (&req->
queue); (*(QUEUE **) &((*(&handle->write_completed_queue
))[1])) = (&req->queue); } while (0);
}

uv__udp_run_completed(handle);

assert(handle->send_queue_size == 0)((void) sizeof ((handle->send_queue_size == 0) ? 1 : 0), __extension__
 ({ if (handle->send_queue_size == 0) ; else __assert_fail
 ("handle->send_queue_size == 0", "../deps/uv/src/unix/udp.c"
, 117, __extension__ __PRETTY_FUNCTION__); }));
assert(handle->send_queue_count == 0)((void) sizeof ((handle->send_queue_count == 0) ? 1 : 0), __extension__
 ({ if (handle->send_queue_count == 0) ; else __assert_fail
 ("handle->send_queue_count == 0", "../deps/uv/src/unix/udp.c"
, 118, __extension__ __PRETTY_FUNCTION__); }));

/* Now tear down the handle. */
handle->recv_cb = NULL((void*)0);
handle->alloc_cb = NULL((void*)0);
/* but _do not_ touch close_cb */
124}


127static void uv__udp_run_completed(uv_udp_t* handle) {
uv_udp_send_t* req;
QUEUE* q;

assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING))((void) sizeof ((!(handle->flags & UV_HANDLE_UDP_PROCESSING
)) ? 1 : 0), __extension__ ({ if (!(handle->flags & UV_HANDLE_UDP_PROCESSING
)) ; else __assert_fail ("!(handle->flags & UV_HANDLE_UDP_PROCESSING)"
, "../deps/uv/src/unix/udp.c", 131, __extension__ __PRETTY_FUNCTION__
); }));
handle->flags |= UV_HANDLE_UDP_PROCESSING;

while (!QUEUE_EMPTY(&handle->write_completed_queue)((const QUEUE *) (&handle->write_completed_queue) == (
const QUEUE *) (*(QUEUE **) &((*(&handle->write_completed_queue
))[0])))) {
  q = QUEUE_HEAD(&handle->write_completed_queue)((*(QUEUE **) &((*(&handle->write_completed_queue)
)[0])));
  QUEUE_REMOVE(q)do { ((*(QUEUE **) &((*((*(QUEUE **) &((*(q))[1]))))[
0]))) = (*(QUEUE **) &((*(q))[0])); ((*(QUEUE **) &((
*((*(QUEUE **) &((*(q))[0]))))[1]))) = (*(QUEUE **) &
((*(q))[1])); } while (0);

  req = QUEUE_DATA(q, uv_udp_send_t, queue)((uv_udp_send_t *) ((char *) (q) - __builtin_offsetof(uv_udp_send_t
, queue)));
  uv__req_unregister(handle->loop, req)do { ((void) sizeof ((((handle->loop)->active_reqs.count
 > 0)) ? 1 : 0), __extension__ ({ if (((handle->loop)->
active_reqs.count > 0)) ; else __assert_fail ("uv__has_active_reqs(handle->loop)"
, "../deps/uv/src/unix/udp.c", 139, __extension__ __PRETTY_FUNCTION__
); })); (handle->loop)->active_reqs.count--; } while (0
);

  handle->send_queue_size -= uv__count_bufs(req->bufs, req->nbufs);
  handle->send_queue_count--;

  if (req->bufs != req->bufsml)
    uv__free(req->bufs);
  req->bufs = NULL((void*)0);

  if (req->send_cb == NULL((void*)0))
    continue;

  /* req->status >= 0 == bytes written
   * req->status <  0 == errno
   */
  if (req->status >= 0)
    req->send_cb(req, 0);
  else
    req->send_cb(req, req->status);
}

if (QUEUE_EMPTY(&handle->write_queue)((const QUEUE *) (&handle->write_queue) == (const QUEUE
 *) (*(QUEUE **) &((*(&handle->write_queue))[0])))) {
  /* Pending queue and completion queue empty, stop watcher. */
  uv__io_stop(handle->loop, &handle->io_watcher, POLLOUT0x004);
  if (!uv__io_active(&handle->io_watcher, POLLIN0x001))
    uv__handle_stop(handle)do { if (((handle)->flags & UV_HANDLE_ACTIVE) == 0) break
; (handle)->flags &= ~UV_HANDLE_ACTIVE; if (((handle)->
flags & UV_HANDLE_REF) != 0) do { (handle)->loop->active_handles
--; } while (0); } while (0);
}

handle->flags &= ~UV_HANDLE_UDP_PROCESSING;
168}


171static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents) {
uv_udp_t* handle;

handle = container_of(w, uv_udp_t, io_watcher)((uv_udp_t *) ((char *) (w) - __builtin_offsetof(uv_udp_t, io_watcher
)));
assert(handle->type == UV_UDP)((void) sizeof ((handle->type == UV_UDP) ? 1 : 0), __extension__
 ({ if (handle->type == UV_UDP) ; else __assert_fail ("handle->type == UV_UDP"
, "../deps/uv/src/unix/udp.c", 175, __extension__ __PRETTY_FUNCTION__
); }));
1
Assuming field 'type' is equal to UV_UDP→
2
←
Taking true branch→

if (revents & POLLIN0x001)
3
←
Assuming the condition is true→
4
←
Taking true branch→
  uv__udp_recvmsg(handle);
5
←
Calling 'uv__udp_recvmsg'→

if (revents & POLLOUT0x004) {
  uv__udp_sendmsg(handle);
  uv__udp_run_completed(handle);
}
184}

186#if HAVE_MMSG1
187static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf) {
struct sockaddr_in6 peers[UV__MMSG_MAXWIDTH20];
struct iovec iov[UV__MMSG_MAXWIDTH20];
struct uv__mmsghdr msgs[UV__MMSG_MAXWIDTH20];
ssize_t nread;
uv_buf_t chunk_buf;
size_t chunks;
int flags;
size_t k;

/* prepare structures for recvmmsg */
chunks = buf->len / UV__UDP_DGRAM_MAXSIZE(64 * 1024);
if (chunks > ARRAY_SIZE(iov)(sizeof(iov) / sizeof((iov)[0])))
17
←
Assuming the condition is false→
18
←
Taking false branch→
  chunks = ARRAY_SIZE(iov)(sizeof(iov) / sizeof((iov)[0]));
for (k = 0; k < chunks; ++k) {
19
←
Assuming 'k' is >= 'chunks'→
20
←
Loop condition is false. Execution continues on line 214→
  iov[k].iov_base = buf->base + k * UV__UDP_DGRAM_MAXSIZE(64 * 1024);
  iov[k].iov_len = UV__UDP_DGRAM_MAXSIZE(64 * 1024);
  msgs[k].msg_hdr.msg_iov = iov + k;
  msgs[k].msg_hdr.msg_iovlen = 1;
  msgs[k].msg_hdr.msg_name = peers + k;
  msgs[k].msg_hdr.msg_namelen = sizeof(peers[0]);
  msgs[k].msg_hdr.msg_control = NULL((void*)0);
  msgs[k].msg_hdr.msg_controllen = 0;
  msgs[k].msg_hdr.msg_flags = 0;
}

do
22
←
Loop condition is false.  Exiting loop→
  nread = uv__recvmmsg(handle->io_watcher.fd, msgs, chunks);
while (nread == -1 && errno(*__errno_location ()) == EINTR4);
21
←
Assuming the condition is false→

if (nread < 1) {
23
←
Assuming 'nread' is >= 1→
24
←
Taking false branch→
  if (nread == 0 || errno(*__errno_location ()) == EAGAIN11 || errno(*__errno_location ()) == EWOULDBLOCK11)
    handle->recv_cb(handle, 0, buf, NULL((void*)0), 0);
  else
    handle->recv_cb(handle, UV__ERR(errno)(-((*__errno_location ()))), buf, NULL((void*)0), 0);
} else {
  /* pass each chunk to the application */
  for (k = 0; k24.1
'k' is < 'nread'
 < (size_t) nread && handle->recv_cb != NULL((void*)0); k++) {
25
←
Assuming field 'recv_cb' is not equal to NULL→
26
←
Loop condition is true.  Entering loop body→
    flags = UV_UDP_MMSG_CHUNK;
    if (msgs[k].msg_hdr.msg_flags & MSG_TRUNCMSG_TRUNC)
27
←
Assuming the condition is false→
28
←
Taking false branch→
      flags |= UV_UDP_PARTIAL;

    chunk_buf = uv_buf_init(iov[k].iov_base, iov[k].iov_len);
29
←
1st function call argument is an uninitialized value
    handle->recv_cb(handle,
                    msgs[k].msg_len,
                    &chunk_buf,
                    msgs[k].msg_hdr.msg_name,
                    flags);
  }

  /* one last callback so the original buffer is freed */
  if (handle->recv_cb != NULL((void*)0))
    handle->recv_cb(handle, 0, buf, NULL((void*)0), UV_UDP_MMSG_FREE);
}
return nread;
242}
243#endif

245static void uv__udp_recvmsg(uv_udp_t* handle) {
struct sockaddr_storage peer;
struct msghdr h;
ssize_t nread;
uv_buf_t buf;
int flags;
int count;

assert(handle->recv_cb != NULL)((void) sizeof ((handle->recv_cb != ((void*)0)) ? 1 : 0), __extension__
 ({ if (handle->recv_cb != ((void*)0)) ; else __assert_fail
 ("handle->recv_cb != NULL", "../deps/uv/src/unix/udp.c", 253
, __extension__ __PRETTY_FUNCTION__); }));
6
←
Assuming field 'recv_cb' is not equal to null→
7
←
Taking true branch→
assert(handle->alloc_cb != NULL)((void) sizeof ((handle->alloc_cb != ((void*)0)) ? 1 : 0),
 __extension__ ({ if (handle->alloc_cb != ((void*)0)) ; else
 __assert_fail ("handle->alloc_cb != NULL", "../deps/uv/src/unix/udp.c"
, 254, __extension__ __PRETTY_FUNCTION__); }));
8
←
Assuming field 'alloc_cb' is not equal to null→
9
←
Taking true branch→

/* Prevent loop starvation when the data comes in as fast as (or faster than)
 * we can read it. XXX Need to rearm fd if we switch to edge-triggered I/O.
 */
count = 32;

do {
  buf = uv_buf_init(NULL((void*)0), 0);
  handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE(64 * 1024), &buf);
  if (buf.base == NULL((void*)0) || buf.len == 0) {
10
←
Assuming field 'base' is not equal to NULL→
11
←
Assuming field 'len' is not equal to 0→
12
←
Taking false branch→
    handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL((void*)0), 0);
    return;
  }
  assert(buf.base != NULL)((void) sizeof ((buf.base != ((void*)0)) ? 1 : 0), __extension__
 ({ if (buf.base != ((void*)0)) ; else __assert_fail ("buf.base != NULL"
, "../deps/uv/src/unix/udp.c", 268, __extension__ __PRETTY_FUNCTION__
); }));
13
←
Taking true branch→

270#if HAVE_MMSG1
  if (uv_udp_using_recvmmsg(handle)) {
14
←
Assuming the condition is true→
15
←
Taking true branch→
    nread = uv__udp_recvmmsg(handle, &buf);
16
←
Calling 'uv__udp_recvmmsg'→
    if (nread > 0)
      count -= nread;
    continue;
  }
277#endif

  memset(&h, 0, sizeof(h));
  memset(&peer, 0, sizeof(peer));
  h.msg_name = &peer;
  h.msg_namelen = sizeof(peer);
  h.msg_iov = (void*) &buf;
  h.msg_iovlen = 1;

  do {
    nread = recvmsg(handle->io_watcher.fd, &h, 0);
  }
  while (nread == -1 && errno(*__errno_location ()) == EINTR4);

  if (nread == -1) {
    if (errno(*__errno_location ()) == EAGAIN11 || errno(*__errno_location ()) == EWOULDBLOCK11)
      handle->recv_cb(handle, 0, &buf, NULL((void*)0), 0);
    else
      handle->recv_cb(handle, UV__ERR(errno)(-((*__errno_location ()))), &buf, NULL((void*)0), 0);
  }
  else {
    flags = 0;
    if (h.msg_flags & MSG_TRUNCMSG_TRUNC)
      flags |= UV_UDP_PARTIAL;

    handle->recv_cb(handle, nread, &buf, (const struct sockaddr*) &peer, flags);
  }
  count--;
}
/* recv_cb callback may decide to pause or close the handle */
while (nread != -1
    && count > 0
    && handle->io_watcher.fd != -1
    && handle->recv_cb != NULL((void*)0));
311}

313#if HAVE_MMSG1
314static void uv__udp_sendmmsg(uv_udp_t* handle) {
uv_udp_send_t* req;
struct uv__mmsghdr h[UV__MMSG_MAXWIDTH20];
struct uv__mmsghdr *p;
QUEUE* q;
ssize_t npkts;
size_t pkts;
size_t i;

if (QUEUE_EMPTY(&handle->write_queue)((const QUEUE *) (&handle->write_queue) == (const QUEUE
 *) (*(QUEUE **) &((*(&handle->write_queue))[0]))))
  return;

326write_queue_drain:
for (pkts = 0, q = QUEUE_HEAD(&handle->write_queue)((*(QUEUE **) &((*(&handle->write_queue))[0])));
     pkts < UV__MMSG_MAXWIDTH20 && q != &handle->write_queue;
     ++pkts, q = QUEUE_HEAD(q)((*(QUEUE **) &((*(q))[0])))) {
  assert(q != NULL)((void) sizeof ((q != ((void*)0)) ? 1 : 0), __extension__ ({ if
 (q != ((void*)0)) ; else __assert_fail ("q != NULL", "../deps/uv/src/unix/udp.c"
, 330, __extension__ __PRETTY_FUNCTION__); }));
  req = QUEUE_DATA(q, uv_udp_send_t, queue)((uv_udp_send_t *) ((char *) (q) - __builtin_offsetof(uv_udp_send_t
, queue)));
  assert(req != NULL)((void) sizeof ((req != ((void*)0)) ? 1 : 0), __extension__ (
{ if (req != ((void*)0)) ; else __assert_fail ("req != NULL",
 "../deps/uv/src/unix/udp.c", 332, __extension__ __PRETTY_FUNCTION__
); }));

  p = &h[pkts];
  memset(p, 0, sizeof(*p));
  if (req->addr.ss_family == AF_UNSPEC0) {
    p->msg_hdr.msg_name = NULL((void*)0);
    p->msg_hdr.msg_namelen = 0;
  } else {
    p->msg_hdr.msg_name = &req->addr;
    if (req->addr.ss_family == AF_INET610)
      p->msg_hdr.msg_namelen = sizeof(struct sockaddr_in6);
    else if (req->addr.ss_family == AF_INET2)
      p->msg_hdr.msg_namelen = sizeof(struct sockaddr_in);
    else if (req->addr.ss_family == AF_UNIX1)
      p->msg_hdr.msg_namelen = sizeof(struct sockaddr_un);
    else {
      assert(0 && "unsupported address family")((void) sizeof ((0 && "unsupported address family") ?
: 0), __extension__ ({ if (0 && "unsupported address family"
) ; else __assert_fail ("0 && \"unsupported address family\""
, "../deps/uv/src/unix/udp.c", 348, __extension__ __PRETTY_FUNCTION__
); }));
      abort();
    }
  }
  h[pkts].msg_hdr.msg_iov = (struct iovec*) req->bufs;
  h[pkts].msg_hdr.msg_iovlen = req->nbufs;
}

do
  npkts = uv__sendmmsg(handle->io_watcher.fd, h, pkts);
while (npkts == -1 && errno(*__errno_location ()) == EINTR4);

if (npkts < 1) {
  if (errno(*__errno_location ()) == EAGAIN11 || errno(*__errno_location ()) == EWOULDBLOCK11 || errno(*__errno_location ()) == ENOBUFS105)
    return;
  for (i = 0, q = QUEUE_HEAD(&handle->write_queue)((*(QUEUE **) &((*(&handle->write_queue))[0])));
       i < pkts && q != &handle->write_queue;
       ++i, q = QUEUE_HEAD(&handle->write_queue)((*(QUEUE **) &((*(&handle->write_queue))[0])))) {
    assert(q != NULL)((void) sizeof ((q != ((void*)0)) ? 1 : 0), __extension__ ({ if
 (q != ((void*)0)) ; else __assert_fail ("q != NULL", "../deps/uv/src/unix/udp.c"
, 366, __extension__ __PRETTY_FUNCTION__); }));
    req = QUEUE_DATA(q, uv_udp_send_t, queue)((uv_udp_send_t *) ((char *) (q) - __builtin_offsetof(uv_udp_send_t
, queue)));
    assert(req != NULL)((void) sizeof ((req != ((void*)0)) ? 1 : 0), __extension__ (
{ if (req != ((void*)0)) ; else __assert_fail ("req != NULL",
 "../deps/uv/src/unix/udp.c", 368, __extension__ __PRETTY_FUNCTION__
); }));

    req->status = UV__ERR(errno)(-((*__errno_location ())));
    QUEUE_REMOVE(&req->queue)do { ((*(QUEUE **) &((*((*(QUEUE **) &((*(&req->
queue))[1]))))[0]))) = (*(QUEUE **) &((*(&req->queue
))[0])); ((*(QUEUE **) &((*((*(QUEUE **) &((*(&req
->queue))[0]))))[1]))) = (*(QUEUE **) &((*(&req->
queue))[1])); } while (0);
    QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue)do { (*(QUEUE **) &((*(&req->queue))[0])) = (&
handle->write_completed_queue); (*(QUEUE **) &((*(&
req->queue))[1])) = (*(QUEUE **) &((*(&handle->
write_completed_queue))[1])); ((*(QUEUE **) &((*((*(QUEUE
 **) &((*(&req->queue))[1]))))[0]))) = (&req->
queue); (*(QUEUE **) &((*(&handle->write_completed_queue
))[1])) = (&req->queue); } while (0);
  }
  uv__io_feed(handle->loop, &handle->io_watcher);
  return;
}

/* Safety: npkts known to be >0 below. Hence cast from ssize_t
 * to size_t safe.
 */
for (i = 0, q = QUEUE_HEAD(&handle->write_queue)((*(QUEUE **) &((*(&handle->write_queue))[0])));
     i < (size_t)npkts && q != &handle->write_queue;
     ++i, q = QUEUE_HEAD(&handle->write_queue)((*(QUEUE **) &((*(&handle->write_queue))[0])))) {
  assert(q != NULL)((void) sizeof ((q != ((void*)0)) ? 1 : 0), __extension__ ({ if
 (q != ((void*)0)) ; else __assert_fail ("q != NULL", "../deps/uv/src/unix/udp.c"
, 384, __extension__ __PRETTY_FUNCTION__); }));
  req = QUEUE_DATA(q, uv_udp_send_t, queue)((uv_udp_send_t *) ((char *) (q) - __builtin_offsetof(uv_udp_send_t
, queue)));
  assert(req != NULL)((void) sizeof ((req != ((void*)0)) ? 1 : 0), __extension__ (
{ if (req != ((void*)0)) ; else __assert_fail ("req != NULL",
 "../deps/uv/src/unix/udp.c", 386, __extension__ __PRETTY_FUNCTION__
); }));

  req->status = req->bufs[0].len;

  /* Sending a datagram is an atomic operation: either all data
   * is written or nothing is (and EMSGSIZE is raised). That is
   * why we don't handle partial writes. Just pop the request
   * off the write queue and onto the completed queue, done.
   */
  QUEUE_REMOVE(&req->queue)do { ((*(QUEUE **) &((*((*(QUEUE **) &((*(&req->
queue))[1]))))[0]))) = (*(QUEUE **) &((*(&req->queue
))[0])); ((*(QUEUE **) &((*((*(QUEUE **) &((*(&req
->queue))[0]))))[1]))) = (*(QUEUE **) &((*(&req->
queue))[1])); } while (0);
  QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue)do { (*(QUEUE **) &((*(&req->queue))[0])) = (&
handle->write_completed_queue); (*(QUEUE **) &((*(&
req->queue))[1])) = (*(QUEUE **) &((*(&handle->
write_completed_queue))[1])); ((*(QUEUE **) &((*((*(QUEUE
 **) &((*(&req->queue))[1]))))[0]))) = (&req->
queue); (*(QUEUE **) &((*(&handle->write_completed_queue
))[1])) = (&req->queue); } while (0);
}

/* couldn't batch everything, continue sending (jump to avoid stack growth) */
if (!QUEUE_EMPTY(&handle->write_queue)((const QUEUE *) (&handle->write_queue) == (const QUEUE
 *) (*(QUEUE **) &((*(&handle->write_queue))[0]))))
  goto write_queue_drain;
uv__io_feed(handle->loop, &handle->io_watcher);
return;
404}
405#endif

407static void uv__udp_sendmsg(uv_udp_t* handle) {
uv_udp_send_t* req;
struct msghdr h;
QUEUE* q;
ssize_t size;

413#if HAVE_MMSG1
uv_once(&once, uv__udp_mmsg_init);
if (uv__sendmmsg_avail) {
  uv__udp_sendmmsg(handle);
  return;
}
419#endif

while (!QUEUE_EMPTY(&handle->write_queue)((const QUEUE *) (&handle->write_queue) == (const QUEUE
 *) (*(QUEUE **) &((*(&handle->write_queue))[0])))) {
  q = QUEUE_HEAD(&handle->write_queue)((*(QUEUE **) &((*(&handle->write_queue))[0])));
  assert(q != NULL)((void) sizeof ((q != ((void*)0)) ? 1 : 0), __extension__ ({ if
 (q != ((void*)0)) ; else __assert_fail ("q != NULL", "../deps/uv/src/unix/udp.c"
, 423, __extension__ __PRETTY_FUNCTION__); }));

  req = QUEUE_DATA(q, uv_udp_send_t, queue)((uv_udp_send_t *) ((char *) (q) - __builtin_offsetof(uv_udp_send_t
, queue)));
  assert(req != NULL)((void) sizeof ((req != ((void*)0)) ? 1 : 0), __extension__ (
{ if (req != ((void*)0)) ; else __assert_fail ("req != NULL",
 "../deps/uv/src/unix/udp.c", 426, __extension__ __PRETTY_FUNCTION__
); }));

  memset(&h, 0, sizeof h);
  if (req->addr.ss_family == AF_UNSPEC0) {
    h.msg_name = NULL((void*)0);
    h.msg_namelen = 0;
  } else {
    h.msg_name = &req->addr;
    if (req->addr.ss_family == AF_INET610)
      h.msg_namelen = sizeof(struct sockaddr_in6);
    else if (req->addr.ss_family == AF_INET2)
      h.msg_namelen = sizeof(struct sockaddr_in);
    else if (req->addr.ss_family == AF_UNIX1)
      h.msg_namelen = sizeof(struct sockaddr_un);
    else {
      assert(0 && "unsupported address family")((void) sizeof ((0 && "unsupported address family") ?
: 0), __extension__ ({ if (0 && "unsupported address family"
) ; else __assert_fail ("0 && \"unsupported address family\""
, "../deps/uv/src/unix/udp.c", 441, __extension__ __PRETTY_FUNCTION__
); }));
      abort();
    }
  }
  h.msg_iov = (struct iovec*) req->bufs;
  h.msg_iovlen = req->nbufs;

  do {
    size = sendmsg(handle->io_watcher.fd, &h, 0);
  } while (size == -1 && errno(*__errno_location ()) == EINTR4);

  if (size == -1) {
    if (errno(*__errno_location ()) == EAGAIN11 || errno(*__errno_location ()) == EWOULDBLOCK11 || errno(*__errno_location ()) == ENOBUFS105)
      break;
  }

  req->status = (size == -1 ? UV__ERR(errno)(-((*__errno_location ()))) : size);

  /* Sending a datagram is an atomic operation: either all data
   * is written or nothing is (and EMSGSIZE is raised). That is
   * why we don't handle partial writes. Just pop the request
   * off the write queue and onto the completed queue, done.
   */
  QUEUE_REMOVE(&req->queue)do { ((*(QUEUE **) &((*((*(QUEUE **) &((*(&req->
queue))[1]))))[0]))) = (*(QUEUE **) &((*(&req->queue
))[0])); ((*(QUEUE **) &((*((*(QUEUE **) &((*(&req
->queue))[0]))))[1]))) = (*(QUEUE **) &((*(&req->
queue))[1])); } while (0);
  QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue)do { (*(QUEUE **) &((*(&req->queue))[0])) = (&
handle->write_completed_queue); (*(QUEUE **) &((*(&
req->queue))[1])) = (*(QUEUE **) &((*(&handle->
write_completed_queue))[1])); ((*(QUEUE **) &((*((*(QUEUE
 **) &((*(&req->queue))[1]))))[0]))) = (&req->
queue); (*(QUEUE **) &((*(&handle->write_completed_queue
))[1])) = (&req->queue); } while (0);
  uv__io_feed(handle->loop, &handle->io_watcher);
}
468}

470/* On the BSDs, SO_REUSEPORT implies SO_REUSEADDR but with some additional
* refinements for programs that use multicast.
*
* Linux as of 3.9 has a SO_REUSEPORT socket option but with semantics that
* are different from the BSDs: it _shares_ the port rather than steal it
* from the current listener.  While useful, it's not something we can emulate
* on other platforms so we don't enable it.
*
* zOS does not support getsockname with SO_REUSEPORT option when using
* AF_UNIX.
*/
481static int uv__set_reuse(int fd) {
int yes;
yes = 1;

485#if defined(SO_REUSEPORT15) && defined(__MVS__)
struct sockaddr_in sockfd;
unsigned int sockfd_len = sizeof(sockfd);
if (getsockname(fd, (struct sockaddr*) &sockfd, &sockfd_len) == -1)
    return UV__ERR(errno)(-((*__errno_location ())));
if (sockfd.sin_family == AF_UNIX1) {
  if (setsockopt(fd, SOL_SOCKET1, SO_REUSEADDR2, &yes, sizeof(yes)))
    return UV__ERR(errno)(-((*__errno_location ())));
} else {
  if (setsockopt(fd, SOL_SOCKET1, SO_REUSEPORT15, &yes, sizeof(yes)))
     return UV__ERR(errno)(-((*__errno_location ())));
}
497#elif defined(SO_REUSEPORT15) && !defined(__linux__1)
if (setsockopt(fd, SOL_SOCKET1, SO_REUSEPORT15, &yes, sizeof(yes)))
  return UV__ERR(errno)(-((*__errno_location ())));
500#else
if (setsockopt(fd, SOL_SOCKET1, SO_REUSEADDR2, &yes, sizeof(yes)))
  return UV__ERR(errno)(-((*__errno_location ())));
503#endif

return 0;
506}

508/*
* The Linux kernel suppresses some ICMP error messages by default for UDP
* sockets. Setting IP_RECVERR/IPV6_RECVERR on the socket enables full ICMP
* error reporting, hopefully resulting in faster failover to working name
* servers.
*/
514static int uv__set_recverr(int fd, sa_family_t ss_family) {
515#if defined(__linux__1)
int yes;

yes = 1;
if (ss_family == AF_INET2) {
  if (setsockopt(fd, IPPROTO_IPIPPROTO_IP, IP_RECVERR11, &yes, sizeof(yes)))
    return UV__ERR(errno)(-((*__errno_location ())));
} else if (ss_family == AF_INET610) {
  if (setsockopt(fd, IPPROTO_IPV6IPPROTO_IPV6, IPV6_RECVERR25, &yes, sizeof(yes)))
     return UV__ERR(errno)(-((*__errno_location ())));
}
526#endif
return 0;
528}


531int uv__udp_bind(uv_udp_t* handle,
               const struct sockaddr* addr,
               unsigned int addrlen,
               unsigned int flags) {
int err;
int yes;
int fd;

/* Check for bad flags. */
if (flags & ~(UV_UDP_IPV6ONLY | UV_UDP_REUSEADDR | UV_UDP_LINUX_RECVERR))
  return UV_EINVAL;

/* Cannot set IPv6-only mode on non-IPv6 socket. */
if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET610)
  return UV_EINVAL;

fd = handle->io_watcher.fd;
if (fd == -1) {
  err = uv__socket(addr->sa_family, SOCK_DGRAMSOCK_DGRAM, 0);
  if (err < 0)
    return err;
  fd = err;
  handle->io_watcher.fd = fd;
}

if (flags & UV_UDP_LINUX_RECVERR) {
  err = uv__set_recverr(fd, addr->sa_family);
  if (err)
    return err;
}

if (flags & UV_UDP_REUSEADDR) {
  err = uv__set_reuse(fd);
  if (err)
    return err;
}

if (flags & UV_UDP_IPV6ONLY) {
569#ifdef IPV6_V6ONLY26
  yes = 1;
  if (setsockopt(fd, IPPROTO_IPV6IPPROTO_IPV6, IPV6_V6ONLY26, &yes, sizeof yes) == -1) {
    err = UV__ERR(errno)(-((*__errno_location ())));
    return err;
  }
575#else
  err = UV_ENOTSUP;
  return err;
578#endif
}

if (bind(fd, addr, addrlen)) {
  err = UV__ERR(errno)(-((*__errno_location ())));
  if (errno(*__errno_location ()) == EAFNOSUPPORT97)
    /* OSX, other BSDs and SunoS fail with EAFNOSUPPORT when binding a
     * socket created with AF_INET to an AF_INET6 address or vice versa. */
    err = UV_EINVAL;
  return err;
}

if (addr->sa_family == AF_INET610)
  handle->flags |= UV_HANDLE_IPV6;

handle->flags |= UV_HANDLE_BOUND;
return 0;
595}


598static int uv__udp_maybe_deferred_bind(uv_udp_t* handle,
                                     int domain,
                                     unsigned int flags) {
union uv__sockaddr taddr;
socklen_t addrlen;

if (handle->io_watcher.fd != -1)
  return 0;

switch (domain) {
case AF_INET2:
{
  struct sockaddr_in* addr = &taddr.in;
  memset(addr, 0, sizeof *addr);
  addr->sin_family = AF_INET2;
  addr->sin_addr.s_addr = INADDR_ANY((in_addr_t) 0x00000000);
  addrlen = sizeof *addr;
  break;
}
case AF_INET610:
{
  struct sockaddr_in6* addr = &taddr.in6;
  memset(addr, 0, sizeof *addr);
  addr->sin6_family = AF_INET610;
  addr->sin6_addr = in6addr_any;
  addrlen = sizeof *addr;
  break;
}
default:
  assert(0 && "unsupported address family")((void) sizeof ((0 && "unsupported address family") ?
: 0), __extension__ ({ if (0 && "unsupported address family"
) ; else __assert_fail ("0 && \"unsupported address family\""
, "../deps/uv/src/unix/udp.c", 627, __extension__ __PRETTY_FUNCTION__
); }));
  abort();
}

return uv__udp_bind(handle, &taddr.addr, addrlen, flags);
632}


635int uv__udp_connect(uv_udp_t* handle,
                  const struct sockaddr* addr,
                  unsigned int addrlen) {
int err;

err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
if (err)
  return err;

do {
  errno(*__errno_location ()) = 0;
  err = connect(handle->io_watcher.fd, addr, addrlen);
} while (err == -1 && errno(*__errno_location ()) == EINTR4);

if (err)
  return UV__ERR(errno)(-((*__errno_location ())));

handle->flags |= UV_HANDLE_UDP_CONNECTED;

return 0;
655}

657/* From https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html
* Any of uv supported UNIXs kernel should be standardized, but the kernel 
* implementation logic not same, let's use pseudocode to explain the udp
* disconnect behaviors:
* 
* Predefined stubs for pseudocode:
*   1. sodisconnect: The function to perform the real udp disconnect
*   2. pru_connect: The function to perform the real udp connect
*   3. so: The kernel object match with socket fd
*   4. addr: The sockaddr parameter from user space
* 
* BSDs:
*   if(sodisconnect(so) == 0) { // udp disconnect succeed
*     if (addr->sa_len != so->addr->sa_len) return EINVAL;
*     if (addr->sa_family != so->addr->sa_family) return EAFNOSUPPORT;
*     pru_connect(so);
*   }
*   else return EISCONN;
*
* z/OS (same with Windows):
*   if(addr->sa_len < so->addr->sa_len) return EINVAL;
*   if (addr->sa_family == AF_UNSPEC) sodisconnect(so);
*
* AIX:
*   if(addr->sa_len != sizeof(struct sockaddr)) return EINVAL; // ignore ip proto version
*   if (addr->sa_family == AF_UNSPEC) sodisconnect(so);
*
* Linux,Others:
*   if(addr->sa_len < sizeof(struct sockaddr)) return EINVAL;
*   if (addr->sa_family == AF_UNSPEC) sodisconnect(so);
*/
688int uv__udp_disconnect(uv_udp_t* handle) {
  int r;
690#if defined(__MVS__)
  struct sockaddr_storage addr;
692#else
  struct sockaddr addr;
694#endif

  memset(&addr, 0, sizeof(addr));
  
698#if defined(__MVS__)
  addr.ss_family = AF_UNSPEC0;
700#else
  addr.sa_family = AF_UNSPEC0;
702#endif
  
  do {
    errno(*__errno_location ()) = 0;
    r = connect(handle->io_watcher.fd, (struct sockaddr*) &addr, sizeof(addr));
  } while (r == -1 && errno(*__errno_location ()) == EINTR4);

  if (r == -1) {
710#if defined(BSD)  /* The macro BSD is from sys/param.h */
    if (errno(*__errno_location ()) != EAFNOSUPPORT97 && errno(*__errno_location ()) != EINVAL22)
      return UV__ERR(errno)(-((*__errno_location ())));
713#else
    return UV__ERR(errno)(-((*__errno_location ())));
715#endif
  }

  handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
  return 0;
720}

722int 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 err;
int empty_queue;

assert(nbufs > 0)((void) sizeof ((nbufs > 0) ? 1 : 0), __extension__ ({ if (
nbufs > 0) ; else __assert_fail ("nbufs > 0", "../deps/uv/src/unix/udp.c"
, 732, __extension__ __PRETTY_FUNCTION__); }));

if (addr) {
  err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
  if (err)
    return err;
}

/* It's legal for send_queue_count > 0 even when the write_queue is empty;
 * it means there are error-state requests in the write_completed_queue that
 * will touch up send_queue_size/count later.
 */
empty_queue = (handle->send_queue_count == 0);

uv__req_init(handle->loop, req, UV_UDP_SEND)do { do { (req)->type = (UV_UDP_SEND); } while (0); do { (
handle->loop)->active_reqs.count++; } while (0); } while
 (0);
assert(addrlen <= sizeof(req->addr))((void) sizeof ((addrlen <= sizeof(req->addr)) ? 1 : 0)
, __extension__ ({ if (addrlen <= sizeof(req->addr)) ; else
 __assert_fail ("addrlen <= sizeof(req->addr)", "../deps/uv/src/unix/udp.c"
, 747, __extension__ __PRETTY_FUNCTION__); }));
if (addr == NULL((void*)0))
  req->addr.ss_family = AF_UNSPEC0;
else
  memcpy(&req->addr, addr, addrlen);
req->send_cb = send_cb;
req->handle = handle;
req->nbufs = nbufs;

req->bufs = req->bufsml;
if (nbufs > ARRAY_SIZE(req->bufsml)(sizeof(req->bufsml) / sizeof((req->bufsml)[0])))
  req->bufs = uv__malloc(nbufs * sizeof(bufs[0]));

if (req->bufs == NULL((void*)0)) {
  uv__req_unregister(handle->loop, req)do { ((void) sizeof ((((handle->loop)->active_reqs.count
 > 0)) ? 1 : 0), __extension__ ({ if (((handle->loop)->
active_reqs.count > 0)) ; else __assert_fail ("uv__has_active_reqs(handle->loop)"
, "../deps/uv/src/unix/udp.c", 761, __extension__ __PRETTY_FUNCTION__
); })); (handle->loop)->active_reqs.count--; } while (0
);
  return UV_ENOMEM;
}

memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
handle->send_queue_size += uv__count_bufs(req->bufs, req->nbufs);
handle->send_queue_count++;
QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue)do { (*(QUEUE **) &((*(&req->queue))[0])) = (&
handle->write_queue); (*(QUEUE **) &((*(&req->queue
))[1])) = (*(QUEUE **) &((*(&handle->write_queue))
[1])); ((*(QUEUE **) &((*((*(QUEUE **) &((*(&req->
queue))[1]))))[0]))) = (&req->queue); (*(QUEUE **) &
((*(&handle->write_queue))[1])) = (&req->queue)
; } while (0);
uv__handle_start(handle)do { if (((handle)->flags & UV_HANDLE_ACTIVE) != 0) break
; (handle)->flags |= UV_HANDLE_ACTIVE; if (((handle)->flags
 & UV_HANDLE_REF) != 0) do { (handle)->loop->active_handles
++; } while (0); } while (0);

if (empty_queue && !(handle->flags & UV_HANDLE_UDP_PROCESSING)) {
  uv__udp_sendmsg(handle);

  /* `uv__udp_sendmsg` may not be able to do non-blocking write straight
   * away. In such cases the `io_watcher` has to be queued for asynchronous
   * write.
   */
  if (!QUEUE_EMPTY(&handle->write_queue)((const QUEUE *) (&handle->write_queue) == (const QUEUE
 *) (*(QUEUE **) &((*(&handle->write_queue))[0]))))
    uv__io_start(handle->loop, &handle->io_watcher, POLLOUT0x004);
} else {
  uv__io_start(handle->loop, &handle->io_watcher, POLLOUT0x004);
}

return 0;
785}


788int uv__udp_try_send(uv_udp_t* handle,
                   const uv_buf_t bufs[],
                   unsigned int nbufs,
                   const struct sockaddr* addr,
                   unsigned int addrlen) {
int err;
struct msghdr h;
ssize_t size;

assert(nbufs > 0)((void) sizeof ((nbufs > 0) ? 1 : 0), __extension__ ({ if (
nbufs > 0) ; else __assert_fail ("nbufs > 0", "../deps/uv/src/unix/udp.c"
, 797, __extension__ __PRETTY_FUNCTION__); }));

/* already sending a message */
if (handle->send_queue_count != 0)
  return UV_EAGAIN;

if (addr) {
  err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
  if (err)
    return err;
} else {
  assert(handle->flags & UV_HANDLE_UDP_CONNECTED)((void) sizeof ((handle->flags & UV_HANDLE_UDP_CONNECTED
) ? 1 : 0), __extension__ ({ if (handle->flags & UV_HANDLE_UDP_CONNECTED
) ; else __assert_fail ("handle->flags & UV_HANDLE_UDP_CONNECTED"
, "../deps/uv/src/unix/udp.c", 808, __extension__ __PRETTY_FUNCTION__
); }));
}

memset(&h, 0, sizeof h);
h.msg_name = (struct sockaddr*) addr;
h.msg_namelen = addrlen;
h.msg_iov = (struct iovec*) bufs;
h.msg_iovlen = nbufs;

do {
  size = sendmsg(handle->io_watcher.fd, &h, 0);
} while (size == -1 && errno(*__errno_location ()) == EINTR4);

if (size == -1) {
  if (errno(*__errno_location ()) == EAGAIN11 || errno(*__errno_location ()) == EWOULDBLOCK11 || errno(*__errno_location ()) == ENOBUFS105)
    return UV_EAGAIN;
  else
    return UV__ERR(errno)(-((*__errno_location ())));
}

return size;
829}


832static int uv__udp_set_membership4(uv_udp_t* handle,
                                 const struct sockaddr_in* multicast_addr,
                                 const char* interface_addr,
                                 uv_membership membership) {
struct ip_mreq mreq;
int optname;
int err;

memset(&mreq, 0, sizeof mreq);

if (interface_addr) {
  err = uv_inet_pton(AF_INET2, interface_addr, &mreq.imr_interface.s_addr);
  if (err)
    return err;
} else {
  mreq.imr_interface.s_addr = htonl(INADDR_ANY)__bswap_32 (((in_addr_t) 0x00000000));
}

mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;

switch (membership) {
case UV_JOIN_GROUP:
  optname = IP_ADD_MEMBERSHIP35;
  break;
case UV_LEAVE_GROUP:
  optname = IP_DROP_MEMBERSHIP36;
  break;
default:
  return UV_EINVAL;
}

if (setsockopt(handle->io_watcher.fd,
               IPPROTO_IPIPPROTO_IP,
               optname,
               &mreq,
               sizeof(mreq))) {
868#if defined(__MVS__)
if (errno(*__errno_location ()) == ENXIO6)
  return UV_ENODEV;
871#endif
  return UV__ERR(errno)(-((*__errno_location ())));
}

return 0;
876}


879static int uv__udp_set_membership6(uv_udp_t* handle,
                                 const struct sockaddr_in6* multicast_addr,
                                 const char* interface_addr,
                                 uv_membership membership) {
int optname;
struct ipv6_mreq mreq;
struct sockaddr_in6 addr6;

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_MEMBERSHIP20;
  break;
case UV_LEAVE_GROUP:
  optname = IPV6_DROP_MEMBERSHIP21;
  break;
default:
  return UV_EINVAL;
}

if (setsockopt(handle->io_watcher.fd,
               IPPROTO_IPV6IPPROTO_IPV6,
               optname,
               &mreq,
               sizeof(mreq))) {
915#if defined(__MVS__)
if (errno(*__errno_location ()) == ENXIO6)
  return UV_ENODEV;
918#endif
  return UV__ERR(errno)(-((*__errno_location ())));
}

return 0;
923}


926#if !defined(__OpenBSD__) &&                                        \
  !defined(__NetBSD__) &&                                         \
  !defined(__ANDROID__) &&                                        \
  !defined(__DragonFly__) &&                                      \
  !defined(__QNX__)
931static 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) {
struct ip_mreq_source mreq;
int optname;
int err;

err = uv__udp_maybe_deferred_bind(handle, AF_INET2, UV_UDP_REUSEADDR);
if (err)
  return err;

memset(&mreq, 0, sizeof(mreq));

if (interface_addr != NULL((void*)0)) {
  err = uv_inet_pton(AF_INET2, interface_addr, &mreq.imr_interface.s_addr);
  if (err)
    return err;
} else {
  mreq.imr_interface.s_addr = htonl(INADDR_ANY)__bswap_32 (((in_addr_t) 0x00000000));
}

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_MEMBERSHIP39;
else if (membership == UV_LEAVE_GROUP)
  optname = IP_DROP_SOURCE_MEMBERSHIP40;
else
  return UV_EINVAL;

if (setsockopt(handle->io_watcher.fd,
               IPPROTO_IPIPPROTO_IP,
               optname,
               &mreq,
               sizeof(mreq))) {
  return UV__ERR(errno)(-((*__errno_location ())));
}

return 0;
973}


976static 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) {
struct group_source_req mreq;
struct sockaddr_in6 addr6;
int optname;
int err;

err = uv__udp_maybe_deferred_bind(handle, AF_INET610, UV_UDP_REUSEADDR);
if (err)
  return err;

memset(&mreq, 0, sizeof(mreq));

if (interface_addr != NULL((void*)0)) {
  err = uv_ip6_addr(interface_addr, 0, &addr6);
  if (err)
    return err;
  mreq.gsr_interface = addr6.sin6_scope_id;
} else {
  mreq.gsr_interface = 0;
}

STATIC_ASSERT(sizeof(mreq.gsr_group) >= sizeof(*multicast_addr))void uv__static_assert(int static_assert_failed[1 - 2 * !(sizeof
(mreq.gsr_group) >= sizeof(*multicast_addr))]);
STATIC_ASSERT(sizeof(mreq.gsr_source) >= sizeof(*source_addr))void uv__static_assert(int static_assert_failed[1 - 2 * !(sizeof
(mreq.gsr_source) >= sizeof(*source_addr))]);
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_GROUP46;
else if (membership == UV_LEAVE_GROUP)
  optname = MCAST_LEAVE_SOURCE_GROUP47;
else
  return UV_EINVAL;

if (setsockopt(handle->io_watcher.fd,
               IPPROTO_IPV6IPPROTO_IPV6,
               optname,
               &mreq,
               sizeof(mreq))) {
  return UV__ERR(errno)(-((*__errno_location ())));
}

return 0;
1022}
1023#endif


1026int uv__udp_init_ex(uv_loop_t* loop,
                  uv_udp_t* handle,
                  unsigned flags,
                  int domain) {
int fd;

fd = -1;
if (domain != AF_UNSPEC0) {
  fd = uv__socket(domain, SOCK_DGRAMSOCK_DGRAM, 0);
  if (fd < 0)
    return fd;
}

uv__handle_init(loop, (uv_handle_t*)handle, UV_UDP)do { ((uv_handle_t*)handle)->loop = (loop); ((uv_handle_t*
)handle)->type = (UV_UDP); ((uv_handle_t*)handle)->flags
 = UV_HANDLE_REF; do { (*(QUEUE **) &((*(&((uv_handle_t
*)handle)->handle_queue))[0])) = (&(loop)->handle_queue
); (*(QUEUE **) &((*(&((uv_handle_t*)handle)->handle_queue
))[1])) = (*(QUEUE **) &((*(&(loop)->handle_queue)
)[1])); ((*(QUEUE **) &((*((*(QUEUE **) &((*(&((uv_handle_t
*)handle)->handle_queue))[1]))))[0]))) = (&((uv_handle_t
*)handle)->handle_queue); (*(QUEUE **) &((*(&(loop
)->handle_queue))[1])) = (&((uv_handle_t*)handle)->
handle_queue); } while (0); (((uv_handle_t*)handle)->next_closing
 = ((void*)0)); } while (0);
handle->alloc_cb = NULL((void*)0);
handle->recv_cb = NULL((void*)0);
handle->send_queue_size = 0;
handle->send_queue_count = 0;
uv__io_init(&handle->io_watcher, uv__udp_io, fd);
QUEUE_INIT(&handle->write_queue)do { (*(QUEUE **) &((*(&handle->write_queue))[0]))
 = (&handle->write_queue); (*(QUEUE **) &((*(&
handle->write_queue))[1])) = (&handle->write_queue)
; } while (0);
QUEUE_INIT(&handle->write_completed_queue)do { (*(QUEUE **) &((*(&handle->write_completed_queue
))[0])) = (&handle->write_completed_queue); (*(QUEUE *
*) &((*(&handle->write_completed_queue))[1])) = (&
handle->write_completed_queue); } while (0);

return 0;
1049}


1052int uv_udp_using_recvmmsg(const uv_udp_t* handle) {
1053#if HAVE_MMSG1
if (handle->flags & UV_HANDLE_UDP_RECVMMSG) {
  uv_once(&once, uv__udp_mmsg_init);
  return uv__recvmmsg_avail;
}
1058#endif
return 0;
1060}


1063int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
int err;

/* Check for already active socket. */
if (handle->io_watcher.fd != -1)
  return UV_EBUSY;

if (uv__fd_exists(handle->loop, sock))
  return UV_EEXIST;

err = uv__nonblockuv__nonblock_ioctl(sock, 1);
if (err)
  return err;

err = uv__set_reuse(sock);
if (err)
  return err;

handle->io_watcher.fd = sock;
if (uv__udp_is_connected(handle))
  handle->flags |= UV_HANDLE_UDP_CONNECTED;

return 0;
1086}


1089int uv_udp_set_membership(uv_udp_t* handle,
                        const char* multicast_addr,
                        const char* interface_addr,
                        uv_membership membership) {
int err;
struct sockaddr_in addr4;
struct sockaddr_in6 addr6;

if (uv_ip4_addr(multicast_addr, 0, &addr4) == 0) {
  err = uv__udp_maybe_deferred_bind(handle, AF_INET2, UV_UDP_REUSEADDR);
  if (err)
    return err;
  return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
} else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0) {
  err = uv__udp_maybe_deferred_bind(handle, AF_INET610, UV_UDP_REUSEADDR);
  if (err)
    return err;
  return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
} else {
  return UV_EINVAL;
}
1110}


1113int uv_udp_set_source_membership(uv_udp_t* handle,
                               const char* multicast_addr,
                               const char* interface_addr,
                               const char* source_addr,
                               uv_membership membership) {
1118#if !defined(__OpenBSD__) &&                                        \
  !defined(__NetBSD__) &&                                         \
  !defined(__ANDROID__) &&                                        \
  !defined(__DragonFly__) &&                                      \
  !defined(__QNX__)
int err;
union uv__sockaddr mcast_addr;
union uv__sockaddr src_addr;

err = uv_ip4_addr(multicast_addr, 0, &mcast_addr.in);
if (err) {
  err = uv_ip6_addr(multicast_addr, 0, &mcast_addr.in6);
  if (err)
    return err;
  err = uv_ip6_addr(source_addr, 0, &src_addr.in6);
  if (err)
    return err;
  return uv__udp_set_source_membership6(handle,
                                        &mcast_addr.in6,
                                        interface_addr,
                                        &src_addr.in6,
                                        membership);
}

err = uv_ip4_addr(source_addr, 0, &src_addr.in);
if (err)
  return err;
return uv__udp_set_source_membership4(handle,
                                      &mcast_addr.in,
                                      interface_addr,
                                      &src_addr.in,
                                      membership);
1150#else
return UV_ENOSYS;
1152#endif
1153}


1156static int uv__setsockopt(uv_udp_t* handle,
                       int option4,
                       int option6,
                       const void* val,
                       socklen_t size) {
int r;

if (handle->flags & UV_HANDLE_IPV6)
  r = setsockopt(handle->io_watcher.fd,
                 IPPROTO_IPV6IPPROTO_IPV6,
                 option6,
                 val,
                 size);
else
  r = setsockopt(handle->io_watcher.fd,
                 IPPROTO_IPIPPROTO_IP,
                 option4,
                 val,
                 size);
if (r)
  return UV__ERR(errno)(-((*__errno_location ())));

return 0;
1179}

1181static int uv__setsockopt_maybe_char(uv_udp_t* handle,
                                   int option4,
                                   int option6,
                                   int val) {
1185#if defined(__sun) || defined(_AIX) || defined(__MVS__)
char arg = val;
1187#elif defined(__OpenBSD__)
unsigned char arg = val;
1189#else
int arg = val;
1191#endif

if (val < 0 || val > 255)
  return UV_EINVAL;

return uv__setsockopt(handle, option4, option6, &arg, sizeof(arg));
1197}


1200int uv_udp_set_broadcast(uv_udp_t* handle, int on) {
if (setsockopt(handle->io_watcher.fd,
               SOL_SOCKET1,
               SO_BROADCAST6,
               &on,
               sizeof(on))) {
  return UV__ERR(errno)(-((*__errno_location ())));
}

return 0;
1210}


1213int uv_udp_set_ttl(uv_udp_t* handle, int ttl) {
if (ttl < 1 || ttl > 255)
  return UV_EINVAL;

1217#if defined(__MVS__)
if (!(handle->flags & UV_HANDLE_IPV6))
  return UV_ENOTSUP;  /* zOS does not support setting ttl for IPv4 */
1220#endif

1222/*
* On Solaris and derivatives such as SmartOS, the length of socket options
* is sizeof(int) for IP_TTL and IPV6_UNICAST_HOPS,
* so hardcode the size of these options on this platform,
* and use the general uv__setsockopt_maybe_char call on other platforms.
*/
1228#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
  defined(__MVS__) || defined(__QNX__)

return uv__setsockopt(handle,
                      IP_TTL2,
                      IPV6_UNICAST_HOPS16,
                      &ttl,
                      sizeof(ttl));

1237#else /* !(defined(__sun) || defined(_AIX) || defined (__OpenBSD__) ||
         defined(__MVS__) || defined(__QNX__)) */

return uv__setsockopt_maybe_char(handle,
                                 IP_TTL2,
                                 IPV6_UNICAST_HOPS16,
                                 ttl);

1245#endif /* defined(__sun) || defined(_AIX) || defined (__OpenBSD__) ||
        defined(__MVS__) || defined(__QNX__) */
1247}


1250int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl) {
1251/*
* On Solaris and derivatives such as SmartOS, the length of socket options
* is sizeof(int) for IPV6_MULTICAST_HOPS and sizeof(char) for
* IP_MULTICAST_TTL, so hardcode the size of the option in the IPv6 case,
* and use the general uv__setsockopt_maybe_char call otherwise.
*/
1257#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
  defined(__MVS__) || defined(__QNX__)
if (handle->flags & UV_HANDLE_IPV6)
  return uv__setsockopt(handle,
                        IP_MULTICAST_TTL33,
                        IPV6_MULTICAST_HOPS18,
                        &ttl,
                        sizeof(ttl));
1265#endif /* defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
  defined(__MVS__) || defined(__QNX__) */

return uv__setsockopt_maybe_char(handle,
                                 IP_MULTICAST_TTL33,
                                 IPV6_MULTICAST_HOPS18,
                                 ttl);
1272}


1275int uv_udp_set_multicast_loop(uv_udp_t* handle, int on) {
1276/*
* On Solaris and derivatives such as SmartOS, the length of socket options
* is sizeof(int) for IPV6_MULTICAST_LOOP and sizeof(char) for
* IP_MULTICAST_LOOP, so hardcode the size of the option in the IPv6 case,
* and use the general uv__setsockopt_maybe_char call otherwise.
*/
1282#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
  defined(__MVS__) || defined(__QNX__)
if (handle->flags & UV_HANDLE_IPV6)
  return uv__setsockopt(handle,
                        IP_MULTICAST_LOOP34,
                        IPV6_MULTICAST_LOOP19,
                        &on,
                        sizeof(on));
1290#endif /* defined(__sun) || defined(_AIX) ||defined(__OpenBSD__) ||
  defined(__MVS__) || defined(__QNX__) */

return uv__setsockopt_maybe_char(handle,
                                 IP_MULTICAST_LOOP34,
                                 IPV6_MULTICAST_LOOP19,
                                 on);
1297}

1299int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
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_INET610;
    addr6->sin6_scope_id = 0;
  } else {
    addr_st.ss_family = AF_INET2;
    addr4->sin_addr.s_addr = htonl(INADDR_ANY)__bswap_32 (((in_addr_t) 0x00000000));
  }
} 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 (addr_st.ss_family == AF_INET2) {
  if (setsockopt(handle->io_watcher.fd,
                 IPPROTO_IPIPPROTO_IP,
                 IP_MULTICAST_IF32,
                 (void*) &addr4->sin_addr,
                 sizeof(addr4->sin_addr)) == -1) {
    return UV__ERR(errno)(-((*__errno_location ())));
  }
} else if (addr_st.ss_family == AF_INET610) {
  if (setsockopt(handle->io_watcher.fd,
                 IPPROTO_IPV6IPPROTO_IPV6,
                 IPV6_MULTICAST_IF17,
                 &addr6->sin6_scope_id,
                 sizeof(addr6->sin6_scope_id)) == -1) {
    return UV__ERR(errno)(-((*__errno_location ())));
  }
} else {
  assert(0 && "unexpected address family")((void) sizeof ((0 && "unexpected address family") ? 1
 : 0), __extension__ ({ if (0 && "unexpected address family"
) ; else __assert_fail ("0 && \"unexpected address family\""
, "../deps/uv/src/unix/udp.c", 1341, __extension__ __PRETTY_FUNCTION__
); }));
  abort();
}

return 0;
1346}

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

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

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

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


1369int uv__udp_recv_start(uv_udp_t* handle,
                     uv_alloc_cb alloc_cb,
                     uv_udp_recv_cb recv_cb) {
int err;

if (alloc_cb == NULL((void*)0) || recv_cb == NULL((void*)0))
  return UV_EINVAL;

if (uv__io_active(&handle->io_watcher, POLLIN0x001))
  return UV_EALREADY;  /* FIXME(bnoordhuis) Should be UV_EBUSY. */

err = uv__udp_maybe_deferred_bind(handle, AF_INET2, 0);
if (err)
  return err;

handle->alloc_cb = alloc_cb;
handle->recv_cb = recv_cb;

uv__io_start(handle->loop, &handle->io_watcher, POLLIN0x001);
uv__handle_start(handle)do { if (((handle)->flags & UV_HANDLE_ACTIVE) != 0) break
; (handle)->flags |= UV_HANDLE_ACTIVE; if (((handle)->flags
 & UV_HANDLE_REF) != 0) do { (handle)->loop->active_handles
++; } while (0); } while (0);

return 0;
1391}


1394int uv__udp_recv_stop(uv_udp_t* handle) {
uv__io_stop(handle->loop, &handle->io_watcher, POLLIN0x001);

if (!uv__io_active(&handle->io_watcher, POLLOUT0x004))
  uv__handle_stop(handle)do { if (((handle)->flags & UV_HANDLE_ACTIVE) == 0) break
; (handle)->flags &= ~UV_HANDLE_ACTIVE; if (((handle)->
flags & UV_HANDLE_REF) != 0) do { (handle)->loop->active_handles
--; } while (0); } while (0);

handle->alloc_cb = NULL((void*)0);
handle->recv_cb = NULL((void*)0);

return 0;
1404}