internal.h File Reference

#include "uv-common.h"
#include <assert.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <sys/socket.h>
#include <poll.h>

Go to the source code of this file.

Classes
struct	uv__stream_queued_fds_s

Macros
#define	UV__PATH_MAX   8192
#define	ACCESS_ONCE(type, var)    (*(volatile type*) &(var))
#define	ROUND_UP(a, b)    ((a) % (b) ? ((a) + (b)) - ((a) % (b)) : (a))
#define	UNREACHABLE()
#define	SAVE_ERRNO(block)
#define	UV_UNUSED(declaration)   declaration
#define	UV__POLLRDHUP   0x2000
#define	UV__POLLPRI   0
#define	uv__cloexec   uv__cloexec_fcntl
#define	uv__nonblock   uv__nonblock_fcntl
#define	uv__stream_fd(handle)   ((handle)->io_watcher.fd)
#define	UV__F_NONBLOCK   1
#define	HAVE_MMSG   0

Typedefs
typedef struct uv__stream_queued_fds_s	uv__stream_queued_fds_t
typedef int(*	uv__peersockfunc) (int, struct sockaddr *, socklen_t *)

Enumerations
enum	{ UV_LOOP_BLOCK_SIGPROF = 1 }
enum	{ UV__EXCLUDE_IFPHYS , UV__EXCLUDE_IFADDR }
enum	uv_clocktype_t { UV_CLOCK_PRECISE = 0 , UV_CLOCK_FAST = 1 }

Functions
int	uv__cloexec_ioctl (int fd, int set)
int	uv__cloexec_fcntl (int fd, int set)
int	uv__nonblock_ioctl (int fd, int set)
int	uv__nonblock_fcntl (int fd, int set)
int	uv__close (int fd)
int	uv__close_nocheckstdio (int fd)
int	uv__close_nocancel (int fd)
int	uv__socket (int domain, int type, int protocol)
ssize_t	uv__recvmsg (int fd, struct msghdr *msg, int flags)
void	uv__make_close_pending (uv_handle_t *handle)
int	uv__getiovmax (void)
void	uv__io_init (uv__io_t *w, uv__io_cb cb, int fd)
void	uv__io_start (uv_loop_t *loop, uv__io_t *w, unsigned int events)
void	uv__io_stop (uv_loop_t *loop, uv__io_t *w, unsigned int events)
void	uv__io_close (uv_loop_t *loop, uv__io_t *w)
void	uv__io_feed (uv_loop_t *loop, uv__io_t *w)
int	uv__io_active (const uv__io_t *w, unsigned int events)
int	uv__io_check_fd (uv_loop_t *loop, int fd)
void	uv__io_poll (uv_loop_t *loop, int timeout)
int	uv__io_fork (uv_loop_t *loop)
int	uv__fd_exists (uv_loop_t *loop, int fd)
void	uv__async_stop (uv_loop_t *loop)
int	uv__async_fork (uv_loop_t *loop)
void	uv__run_idle (uv_loop_t *loop)
void	uv__run_check (uv_loop_t *loop)
void	uv__run_prepare (uv_loop_t *loop)
void	uv__stream_init (uv_loop_t *loop, uv_stream_t *stream, uv_handle_type type)
int	uv__stream_open (uv_stream_t *, int fd, int flags)
void	uv__stream_destroy (uv_stream_t *stream)
void	uv__server_io (uv_loop_t *loop, uv__io_t *w, unsigned int events)
int	uv__accept (int sockfd)
int	uv__dup2_cloexec (int oldfd, int newfd)
int	uv__open_cloexec (const char *path, int flags)
int	uv_tcp_listen (uv_tcp_t *tcp, int backlog, uv_connection_cb cb)
int	uv__tcp_nodelay (int fd, int on)
int	uv__tcp_keepalive (int fd, int on, unsigned int delay)
int	uv_pipe_listen (uv_pipe_t *handle, int backlog, uv_connection_cb cb)
void	uv__signal_close (uv_signal_t *handle)
void	uv__signal_global_once_init (void)
void	uv__signal_loop_cleanup (uv_loop_t *loop)
int	uv__signal_loop_fork (uv_loop_t *loop)
uint64_t	uv__hrtime (uv_clocktype_t type)
int	uv__kqueue_init (uv_loop_t *loop)
int	uv__platform_loop_init (uv_loop_t *loop)
void	uv__platform_loop_delete (uv_loop_t *loop)
void	uv__platform_invalidate_fd (uv_loop_t *loop, int fd)
void	uv__async_close (uv_async_t *handle)
void	uv__check_close (uv_check_t *handle)
void	uv__fs_event_close (uv_fs_event_t *handle)
void	uv__idle_close (uv_idle_t *handle)
void	uv__pipe_close (uv_pipe_t *handle)
void	uv__poll_close (uv_poll_t *handle)
void	uv__prepare_close (uv_prepare_t *handle)
void	uv__process_close (uv_process_t *handle)
void	uv__stream_close (uv_stream_t *handle)
void	uv__tcp_close (uv_tcp_t *handle)
void	uv__udp_close (uv_udp_t *handle)
void	uv__udp_finish_close (uv_udp_t *handle)
uv_handle_type	uv__handle_type (int fd)
FILE *	uv__open_file (const char *path)
int	uv__getpwuid_r (uv_passwd_t *pwd)
int	uv__search_path (const char *prog, char *buf, size_t *buflen)
int	uv__random_devurandom (void *buf, size_t buflen)
int	uv__random_getrandom (void *buf, size_t buflen)
int	uv__random_getentropy (void *buf, size_t buflen)
int	uv__random_readpath (const char *path, void *buf, size_t buflen)
int	uv__random_sysctl (void *buf, size_t buflen)
int	uv__make_pipe (int fds[2], int flags)
	UV_UNUSED (static void uv__update_time(uv_loop_t *loop))
	UV_UNUSED (static char *uv__basename_r(const char *path))
int	uv__getsockpeername (const uv_handle_t *handle, uv__peersockfunc func, struct sockaddr *name, int *namelen)

Macro Definition Documentation

ACCESS_ONCE

#define ACCESS_ONCE	(		type,
			var
	)		(*(volatile type*) &(var))

Definition at line 79 of file internal.h.

HAVE_MMSG

#define HAVE_MMSG   0

Definition at line 340 of file internal.h.

ROUND_UP

#define ROUND_UP	(		a,
			b
	)		((a) % (b) ? ((a) + (b)) - ((a) % (b)) : (a))

Definition at line 82 of file internal.h.

SAVE_ERRNO

#define SAVE_ERRNO

(

block

)

Value:

  do {                                                                        \
    int _saved_errno = errno;                                                 \
    do { block; } while (0);                                                  \
    errno = _saved_errno;                                                     \
  }                                                                           \
  while (0)

Definition at line 92 of file internal.h.

UNREACHABLE

#define UNREACHABLE

(

)

Value:

  do {                                                                        \
    assert(0 && "unreachable code");                                          \
    abort();                                                                  \
  }                                                                           \
  while (0)

Definition at line 85 of file internal.h.

uv__cloexec

#define uv__cloexec   uv__cloexec_fcntl

Definition at line 169 of file internal.h.

UV__F_NONBLOCK

#define UV__F_NONBLOCK   1

Definition at line 288 of file internal.h.

uv__nonblock

#define uv__nonblock   uv__nonblock_fcntl

Definition at line 170 of file internal.h.

UV__PATH_MAX

#define UV__PATH_MAX   8192

Definition at line 68 of file internal.h.

UV__POLLPRI

#define UV__POLLPRI   0

Definition at line 122 of file internal.h.

UV__POLLRDHUP

#define UV__POLLRDHUP   0x2000

Definition at line 116 of file internal.h.

uv__stream_fd

#define uv__stream_fd

(

handle

)

((handle)->io_watcher.fd)

Definition at line 282 of file internal.h.

UV_UNUSED

#define UV_UNUSED

(

declaration

)

declaration

Definition at line 109 of file internal.h.

Typedef Documentation

uv__peersockfunc

typedef int(* uv__peersockfunc) (int, struct sockaddr *, socklen_t *)

Definition at line 321 of file internal.h.

uv__stream_queued_fds_t

typedef struct uv__stream_queued_fds_s uv__stream_queued_fds_t

Definition at line 1 of file internal.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
UV_LOOP_BLOCK_SIGPROF

Definition at line 136 of file internal.h.

     {
  UV_LOOP_BLOCK_SIGPROF = 1
};

anonymous enum

anonymous enum

Enumerator
UV__EXCLUDE_IFPHYS
UV__EXCLUDE_IFADDR

Definition at line 141 of file internal.h.

     {
  UV__EXCLUDE_IFPHYS,
  UV__EXCLUDE_IFADDR
};

uv_clocktype_t

enum uv_clocktype_t

Enumerator
UV_CLOCK_PRECISE
UV_CLOCK_FAST

Definition at line 146 of file internal.h.

             {
  UV_CLOCK_PRECISE = 0,  /* Use the highest resolution clock available. */
  UV_CLOCK_FAST = 1      /* Use the fastest clock with <= 1ms granularity. */
} uv_clocktype_t;

Function Documentation

uv__accept()

int uv__accept

(

int

sockfd

)

Definition at line 489 of file core.c.

                           {
  int peerfd;
  int err;
 
  (void) &err;
  assert(sockfd >= 0);
 
  do
#ifdef uv__accept4
    peerfd = uv__accept4(sockfd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
#else
    peerfd = accept(sockfd, NULL, NULL);
#endif
  while (peerfd == -1 && errno == EINTR);
 
  if (peerfd == -1)
    return UV__ERR(errno);
 
#ifndef uv__accept4
  err = uv__cloexec(peerfd, 1);
  if (err == 0)
    err = uv__nonblock(peerfd, 1);
 
  if (err != 0) {
    uv__close(peerfd);
    return err;
  }
#endif
 
  return peerfd;
}

References accept, assert(), EINTR, err, NULL, sockfd, uv__cloexec, uv__close(), UV__ERR, and uv__nonblock.

Referenced by uv__emfile_trick(), and uv__server_io().

uv__async_close()

void uv__async_close

(

uv_async_t *

handle

)

Definition at line 115 of file async.c.

                                         {
  uv__async_spin(handle);
  QUEUE_REMOVE(&handle->queue);
  uv__handle_stop(handle);
}

References handle, QUEUE_REMOVE, uv__async_spin(), and uv__handle_stop.

Referenced by uv_close().

uv__async_fork()

int uv__async_fork

(

uv_loop_t *

loop

)

Definition at line 230 of file async.c.

                                    {
  if (loop->async_io_watcher.fd == -1) /* never started */
    return 0;
 
  uv__async_stop(loop);
 
  return uv__async_start(loop);
}

References loop, uv__async_start(), and uv__async_stop().

Referenced by uv_loop_fork().

uv__async_stop()

void uv__async_stop

(

uv_loop_t *

loop

)

Definition at line 240 of file async.c.

                                     {
  if (loop->async_io_watcher.fd == -1)
    return;
 
  if (loop->async_wfd != -1) {
    if (loop->async_wfd != loop->async_io_watcher.fd)
      uv__close(loop->async_wfd);
    loop->async_wfd = -1;
  }
 
  uv__io_stop(loop, &loop->async_io_watcher, POLLIN);
  uv__close(loop->async_io_watcher.fd);
  loop->async_io_watcher.fd = -1;
}

References loop, uv__close(), and uv__io_stop().

Referenced by uv__async_fork(), and uv__loop_close().

uv__check_close()

void uv__check_close

(

uv_check_t *

handle

)

Referenced by uv_close().

uv__cloexec_fcntl()

int uv__cloexec_fcntl	(	int	fd,
		int	set
	)

Definition at line 639 of file core.c.

                                       {
  int flags;
  int r;
 
  do
    r = fcntl(fd, F_GETFD);
  while (r == -1 && errno == EINTR);
 
  if (r == -1)
    return UV__ERR(errno);
 
  /* Bail out now if already set/clear. */
  if (!!(r & FD_CLOEXEC) == !!set)
    return 0;
 
  if (set)
    flags = r | FD_CLOEXEC;
  else
    flags = r & ~FD_CLOEXEC;
 
  do
    r = fcntl(fd, F_SETFD, flags);
  while (r == -1 && errno == EINTR);
 
  if (r)
    return UV__ERR(errno);
 
  return 0;
}

References EINTR, F_GETFD, F_SETFD, fcntl, fd, FD_CLOEXEC, flags, r, and UV__ERR.

Referenced by uv__process_child_init().

uv__cloexec_ioctl()

int uv__cloexec_ioctl	(	int	fd,
		int	set
	)

Definition at line 593 of file core.c.

                                       {
  int r;
 
  do
    r = ioctl(fd, set ? FIOCLEX : FIONCLEX);
  while (r == -1 && errno == EINTR);
 
  if (r)
    return UV__ERR(errno);
 
  return 0;
}

References EINTR, fd, FIOCLEX, FIONCLEX, ioctl, r, and UV__ERR.

uv__close()

int uv__close

(

int

fd

)

Definition at line 569 of file core.c.

                      {
  assert(fd > STDERR_FILENO);  /* Catch stdio close bugs. */
#if defined(__MVS__)
  SAVE_ERRNO(epoll_file_close(fd));
#endif
  return uv__close_nocheckstdio(fd);
}

References assert(), epoll_file_close(), fd, SAVE_ERRNO, STDERR_FILENO, and uv__close_nocheckstdio().

Referenced by mkdtemp(), new_socket(), uv__accept(), uv__async_stop(), uv__dup2_cloexec(), uv__emfile_trick(), uv__fs_mkstemp(), uv__fs_open(), uv__interface_addresses_v6(), uv__io_fork(), uv__loop_close(), uv__make_pipe(), uv__make_socketpair(), uv__open_cloexec(), uv__open_file(), uv__platform_loop_delete(), uv__platform_loop_init(), uv__process_child_init(), uv__process_open_stream(), uv__random_readpath(), uv__set_phys_addr(), uv__signal_cleanup(), uv__signal_loop_cleanup(), uv__signal_loop_fork(), uv__socket(), uv__stream_close(), uv__stream_recv_cmsg(), uv__udp_close(), uv_accept(), uv_fs_event_stop(), uv_interface_addresses(), uv_pipe_bind(), uv_resident_set_memory(), uv_spawn(), and uv_tty_init().

uv__close_nocancel()

int uv__close_nocancel

(

int

fd

)

Definition at line 530 of file core.c.

                               {
#if defined(__APPLE__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdollar-in-identifier-extension"
#if defined(__LP64__) || TARGET_OS_IPHONE
  extern int close$NOCANCEL(int);
  return close$NOCANCEL(fd);
#else
  extern int close$NOCANCEL$UNIX2003(int);
  return close$NOCANCEL$UNIX2003(fd);
#endif
#pragma GCC diagnostic pop
#elif defined(__linux__)
  return syscall(SYS_close, fd);
#else
  return close(fd);
#endif
}

References close, fd, and syscall.

Referenced by uv__close_nocheckstdio(), and uv__fs_close().

uv__close_nocheckstdio()

int uv__close_nocheckstdio

(

int

fd

)

Definition at line 550 of file core.c.

                                   {
  int saved_errno;
  int rc;
 
  assert(fd > -1);  /* Catch uninitialized io_watcher.fd bugs. */
 
  saved_errno = errno;
  rc = uv__close_nocancel(fd);
  if (rc == -1) {
    rc = UV__ERR(errno);
    if (rc == UV_EINTR || rc == UV__ERR(EINPROGRESS))
      rc = 0;    /* The close is in progress, not an error. */
    errno = saved_errno;
  }
 
  return rc;
}

References assert(), EINPROGRESS, fd, uv__close_nocancel(), and UV__ERR.

Referenced by uv__close(), uv__fs_copyfile(), uv__slurp(), uv_fs_event_start(), and uv_spawn().

uv__dup2_cloexec()

int uv__dup2_cloexec	(	int	oldfd,
		int	newfd
	)

Definition at line 1031 of file core.c.

                                           {
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__linux__)
  int r;
 
  r = dup3(oldfd, newfd, O_CLOEXEC);
  if (r == -1)
    return UV__ERR(errno);
 
  return r;
#else
  int err;
  int r;
 
  r = dup2(oldfd, newfd);  /* Never retry. */
  if (r == -1)
    return UV__ERR(errno);
 
  err = uv__cloexec(newfd, 1);
  if (err != 0) {
    uv__close(newfd);
    return err;
  }
 
  return r;
#endif
}

References dup2, err, O_CLOEXEC, oldfd, r, uv__cloexec, uv__close(), and UV__ERR.

Referenced by uv_tty_init().

uv__fd_exists()

int uv__fd_exists	(	uv_loop_t *	loop,
		int	fd
	)

Definition at line 965 of file core.c.

                                           {
  return (unsigned) fd < loop->nwatchers && loop->watchers[fd] != NULL;
}

References fd, loop, and NULL.

Referenced by uv_pipe_open(), uv_poll_init(), uv_tcp_open(), and uv_udp_open().

uv__fs_event_close()

void uv__fs_event_close

(

uv_fs_event_t *

handle

)

Definition at line 863 of file aix.c.

                                               {
#ifdef HAVE_SYS_AHAFS_EVPRODS_H
  uv_fs_event_stop(handle);
#else
  UNREACHABLE();
#endif
}

References handle, UNREACHABLE, and uv_fs_event_stop().

Referenced by uv_close().

uv__getiovmax()

int uv__getiovmax

(

void

)

Definition at line 215 of file core.c.

                        {
#if defined(IOV_MAX)
  return IOV_MAX;
#elif defined(_SC_IOV_MAX)
  static int iovmax_cached = -1;
  int iovmax;
 
  iovmax = uv__load_relaxed(&iovmax_cached);
  if (iovmax != -1)
    return iovmax;
 
  /* On some embedded devices (arm-linux-uclibc based ip camera),
   * sysconf(_SC_IOV_MAX) can not get the correct value. The return
   * value is -1 and the errno is EINPROGRESS. Degrade the value to 1.
   */
  iovmax = sysconf(_SC_IOV_MAX);
  if (iovmax == -1)
    iovmax = 1;
 
  uv__store_relaxed(&iovmax_cached, iovmax);
 
  return iovmax;
#else
  return 1024;
#endif
}

References uv__load_relaxed, and uv__store_relaxed.

Referenced by uv__fs_read(), uv__fs_write_all(), and uv__write().

uv__getpwuid_r()

int uv__getpwuid_r

(

uv_passwd_t *

pwd

)

Definition at line 1146 of file core.c.

                                     {
  struct passwd pw;
  struct passwd* result;
  char* buf;
  uid_t uid;
  size_t bufsize;
  size_t name_size;
  size_t homedir_size;
  size_t shell_size;
  long initsize;
  int r;
 
  if (pwd == NULL)
    return UV_EINVAL;
 
  initsize = sysconf(_SC_GETPW_R_SIZE_MAX);
 
  if (initsize <= 0)
    bufsize = 4096;
  else
    bufsize = (size_t) initsize;
 
  uid = geteuid();
  buf = NULL;
 
  for (;;) {
    uv__free(buf);
    buf = uv__malloc(bufsize);
 
    if (buf == NULL)
      return UV_ENOMEM;
 
    r = getpwuid_r(uid, &pw, buf, bufsize, &result);
 
    if (r != ERANGE)
      break;
 
    bufsize *= 2;
  }
 
  if (r != 0) {
    uv__free(buf);
    return -r;
  }
 
  if (result == NULL) {
    uv__free(buf);
    return UV_ENOENT;
  }
 
  /* Allocate memory for the username, shell, and home directory */
  name_size = strlen(pw.pw_name) + 1;
  homedir_size = strlen(pw.pw_dir) + 1;
  shell_size = strlen(pw.pw_shell) + 1;
  pwd->username = uv__malloc(name_size + homedir_size + shell_size);
 
  if (pwd->username == NULL) {
    uv__free(buf);
    return UV_ENOMEM;
  }
 
  /* Copy the username */
  memcpy(pwd->username, pw.pw_name, name_size);
 
  /* Copy the home directory */
  pwd->homedir = pwd->username + name_size;
  memcpy(pwd->homedir, pw.pw_dir, homedir_size);
 
  /* Copy the shell */
  pwd->shell = pwd->homedir + homedir_size;
  memcpy(pwd->shell, pw.pw_shell, shell_size);
 
  /* Copy the uid and gid */
  pwd->uid = pw.pw_uid;
  pwd->gid = pw.pw_gid;
 
  uv__free(buf);
 
  return 0;
}

uv__getsockpeername()

int uv__getsockpeername	(	const uv_handle_t *	handle,
		uv__peersockfunc	func,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 1490 of file core.c.

                                      {
  socklen_t socklen;
  uv_os_fd_t fd;
  int r;
 
  r = uv_fileno(handle, &fd);
  if (r < 0)
    return r;
 
  /* sizeof(socklen_t) != sizeof(int) on some systems. */
  socklen = (socklen_t) *namelen;
 
  if (func(fd, name, &socklen))
    return UV__ERR(errno);
 
  *namelen = (int) socklen;
  return 0;
}

References fd, handle, int, r, UV__ERR, and uv_fileno().

Referenced by uv__pipe_getsockpeername(), uv_tcp_getpeername(), uv_tcp_getsockname(), uv_udp_getpeername(), and uv_udp_getsockname().

uv__handle_type()

uv_handle_type uv__handle_type

(

int

fd

)

Definition at line 958 of file stream.c.

                                       {
  struct sockaddr_storage ss;
  socklen_t sslen;
  socklen_t len;
  int type;
 
  memset(&ss, 0, sizeof(ss));
  sslen = sizeof(ss);
 
  if (getsockname(fd, (struct sockaddr*)&ss, &sslen))
    return UV_UNKNOWN_HANDLE;
 
  len = sizeof type;
 
  if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &len))
    return UV_UNKNOWN_HANDLE;
 
  if (type == SOCK_STREAM) {
#if defined(_AIX) || defined(__DragonFly__)
    /* on AIX/DragonFly the getsockname call returns an empty sa structure
     * for sockets of type AF_UNIX.  For all other types it will
     * return a properly filled in structure.
     */
    if (sslen == 0)
      return UV_NAMED_PIPE;
#endif
    switch (ss.ss_family) {
      case AF_UNIX:
        return UV_NAMED_PIPE;
      case AF_INET:
      case AF_INET6:
        return UV_TCP;
      }
  }
 
  if (type == SOCK_DGRAM &&
      (ss.ss_family == AF_INET || ss.ss_family == AF_INET6))
    return UV_UDP;
 
  return UV_UNKNOWN_HANDLE;
}

References AF_INET, AF_INET6, AF_UNIX, fd, len, memset(), SO_TYPE, SOCK_DGRAM, SOCK_STREAM, SOL_SOCKET, type, and UV_UNKNOWN_HANDLE.

Referenced by uv_pipe_pending_type().

uv__hrtime()

uint64_t uv__hrtime

(

uv_clocktype_t

type

)

Definition at line 43 of file aix-common.c.

                                         {
  uint64_t G = 1000000000;
  timebasestruct_t t;
  read_wall_time(&t, TIMEBASE_SZ);
  time_base_to_time(&t, TIMEBASE_SZ);
  return (uint64_t) t.tb_high * G + t.tb_low;
}

References CLOCK_MONOTONIC_COARSE, done, G, NANOSEC, once, time_func, timebase, TOD_RES, timespec::tv_nsec, timespec::tv_sec, type, uv__hrtime_init_once(), uv__load_relaxed, uv__store_relaxed, UV_CLOCK_FAST, and uv_once().

Referenced by uv_cond_timedwait(), uv_hrtime(), UV_UNUSED(), and uv_update_time().

uv__idle_close()

void uv__idle_close

(

uv_idle_t *

handle

)

Referenced by uv_close().

uv__io_active()

int uv__io_active	(	const uv__io_t *	w,
		unsigned int	events
	)

Definition at line 958 of file core.c.

                                                          {
  assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
  assert(0 != events);
  return 0 != (w->pevents & events);
}

References assert(), UV__POLLPRI, UV__POLLRDHUP, and w.

Referenced by uv__read(), uv__stream_close(), uv__stream_destroy(), uv__stream_eof(), uv__udp_finish_close(), uv__udp_recv_start(), uv__udp_run_completed(), uv__write(), uv_read_stop(), and uv_try_write().

uv__io_check_fd()

int uv__io_check_fd	(	uv_loop_t *	loop,
		int	fd
	)

Definition at line 115 of file aix.c.

                                             {
  struct poll_ctl pc;
 
  pc.events = POLLIN;
  pc.cmd = PS_MOD;  /* Equivalent to PS_ADD if the fd is not in the pollset. */
  pc.fd = fd;
 
  if (pollset_ctl(loop->backend_fd, &pc, 1))
    return UV__ERR(errno);
 
  pc.cmd = PS_DELETE;
  if (pollset_ctl(loop->backend_fd, &pc, 1))
    abort();
 
  return 0;
}

References e, EAGAIN, EEXIST, EINTR, epoll_ctl(), EPOLL_CTL_ADD, EPOLL_CTL_DEL, fd, loop, memset(), NULL, p, pc, poll, and UV__ERR.

Referenced by uv_poll_init().

uv__io_close()

void uv__io_close	(	uv_loop_t *	loop,
		uv__io_t *	w
	)

Definition at line 942 of file core.c.

                                                {
  uv__io_stop(loop, w, POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
  QUEUE_REMOVE(&w->pending_queue);
 
  /* Remove stale events for this file descriptor */
  if (w->fd != -1)
    uv__platform_invalidate_fd(loop, w->fd);
}

References loop, QUEUE_REMOVE, uv__io_stop(), uv__platform_invalidate_fd(), UV__POLLPRI, UV__POLLRDHUP, and w.

Referenced by uv__stream_close(), uv__udp_close(), and uv_fs_event_stop().

uv__io_feed()

void uv__io_feed	(	uv_loop_t *	loop,
		uv__io_t *	w
	)

Definition at line 952 of file core.c.

                                               {
  if (QUEUE_EMPTY(&w->pending_queue))
    QUEUE_INSERT_TAIL(&loop->pending_queue, &w->pending_queue);
}

References loop, QUEUE_EMPTY, QUEUE_INSERT_TAIL, and w.

Referenced by uv__tcp_connect(), uv__udp_sendmsg(), uv__write_req_finish(), and uv_pipe_connect().

uv__io_fork()

int uv__io_fork

(

uv_loop_t *

loop

)

Definition at line 108 of file aix.c.

                                 {
  uv__platform_loop_delete(loop);
 
  return uv__platform_loop_init(loop);
}

References err, loop, NULL, uv__close(), uv__free(), uv__inotify_fork(), uv__io_stop(), uv__kqueue_init(), uv__platform_loop_delete(), uv__platform_loop_init(), and uv__store_relaxed.

Referenced by uv_loop_fork().

uv__io_init()

void uv__io_init	(	uv__io_t *	w,
		uv__io_cb	cb,
		int	fd
	)

Definition at line 865 of file core.c.

                                                    {
  assert(cb != NULL);
  assert(fd >= -1);
  QUEUE_INIT(&w->pending_queue);
  QUEUE_INIT(&w->watcher_queue);
  w->cb = cb;
  w->fd = fd;
  w->events = 0;
  w->pevents = 0;
 
#if defined(UV_HAVE_KQUEUE)
  w->rcount = 0;
  w->wcount = 0;
#endif /* defined(UV_HAVE_KQUEUE) */
}

References assert(), cb, fd, NULL, QUEUE_INIT, and w.

Referenced by init_inotify(), uv__async_start(), uv__signal_loop_once_init(), uv__stream_init(), uv__udp_init_ex(), uv_fs_event_start(), and uv_poll_init().

uv__io_poll()

void uv__io_poll	(	uv_loop_t *	loop,
		int	timeout
	)

Definition at line 133 of file aix.c.

                                               {
  struct pollfd events[1024];
  struct pollfd pqry;
  struct pollfd* pe;
  struct poll_ctl pc;
  QUEUE* q;
  uv__io_t* w;
  uint64_t base;
  uint64_t diff;
  int have_signals;
  int nevents;
  int count;
  int nfds;
  int i;
  int rc;
  int add_failed;
  int user_timeout;
  int reset_timeout;
 
  if (loop->nfds == 0) {
    assert(QUEUE_EMPTY(&loop->watcher_queue));
    return;
  }
 
  while (!QUEUE_EMPTY(&loop->watcher_queue)) {
    q = QUEUE_HEAD(&loop->watcher_queue);
    QUEUE_REMOVE(q);
    QUEUE_INIT(q);
 
    w = QUEUE_DATA(q, uv__io_t, watcher_queue);
    assert(w->pevents != 0);
    assert(w->fd >= 0);
    assert(w->fd < (int) loop->nwatchers);
 
    pc.events = w->pevents;
    pc.fd = w->fd;
 
    add_failed = 0;
    if (w->events == 0) {
      pc.cmd = PS_ADD;
      if (pollset_ctl(loop->backend_fd, &pc, 1)) {
        if (errno != EINVAL) {
          assert(0 && "Failed to add file descriptor (pc.fd) to pollset");
          abort();
        }
        /* Check if the fd is already in the pollset */
        pqry.fd = pc.fd;
        rc = pollset_query(loop->backend_fd, &pqry);
        switch (rc) {
        case -1:
          assert(0 && "Failed to query pollset for file descriptor");
          abort();
        case 0:
          assert(0 && "Pollset does not contain file descriptor");
          abort();
        }
        /* If we got here then the pollset already contained the file descriptor even though
         * we didn't think it should. This probably shouldn't happen, but we can continue. */
        add_failed = 1;
      }
    }
    if (w->events != 0 || add_failed) {
      /* Modify, potentially removing events -- need to delete then add.
       * Could maybe mod if we knew for sure no events are removed, but
       * content of w->events is handled above as not reliable (falls back)
       * so may require a pollset_query() which would have to be pretty cheap
       * compared to a PS_DELETE to be worth optimizing. Alternatively, could
       * lazily remove events, squelching them in the mean time. */
      pc.cmd = PS_DELETE;
      if (pollset_ctl(loop->backend_fd, &pc, 1)) {
        assert(0 && "Failed to delete file descriptor (pc.fd) from pollset");
        abort();
      }
      pc.cmd = PS_ADD;
      if (pollset_ctl(loop->backend_fd, &pc, 1)) {
        assert(0 && "Failed to add file descriptor (pc.fd) to pollset");
        abort();
      }
    }
 
    w->events = w->pevents;
  }
 
  assert(timeout >= -1);
  base = loop->time;
  count = 48; /* Benchmarks suggest this gives the best throughput. */
 
  if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) {
    reset_timeout = 1;
    user_timeout = timeout;
    timeout = 0;
  } else {
    reset_timeout = 0;
  }
 
  for (;;) {
    /* Only need to set the provider_entry_time if timeout != 0. The function
     * will return early if the loop isn't configured with UV_METRICS_IDLE_TIME.
     */
    if (timeout != 0)
      uv__metrics_set_provider_entry_time(loop);
 
    nfds = pollset_poll(loop->backend_fd,
                        events,
                        ARRAY_SIZE(events),
                        timeout);
 
    /* Update loop->time unconditionally. It's tempting to skip the update when
     * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the
     * operating system didn't reschedule our process while in the syscall.
     */
    SAVE_ERRNO(uv__update_time(loop));
 
    if (nfds == 0) {
      if (reset_timeout != 0) {
        timeout = user_timeout;
        reset_timeout = 0;
        if (timeout == -1)
          continue;
        if (timeout > 0)
          goto update_timeout;
      }
 
      assert(timeout != -1);
      return;
    }
 
    if (nfds == -1) {
      if (errno != EINTR) {
        abort();
      }
 
      if (reset_timeout != 0) {
        timeout = user_timeout;
        reset_timeout = 0;
      }
 
      if (timeout == -1)
        continue;
 
      if (timeout == 0)
        return;
 
      /* Interrupted by a signal. Update timeout and poll again. */
      goto update_timeout;
    }
 
    have_signals = 0;
    nevents = 0;
 
    assert(loop->watchers != NULL);
    loop->watchers[loop->nwatchers] = (void*) events;
    loop->watchers[loop->nwatchers + 1] = (void*) (uintptr_t) nfds;
 
    for (i = 0; i < nfds; i++) {
      pe = events + i;
      pc.cmd = PS_DELETE;
      pc.fd = pe->fd;
 
      /* Skip invalidated events, see uv__platform_invalidate_fd */
      if (pc.fd == -1)
        continue;
 
      assert(pc.fd >= 0);
      assert((unsigned) pc.fd < loop->nwatchers);
 
      w = loop->watchers[pc.fd];
 
      if (w == NULL) {
        /* File descriptor that we've stopped watching, disarm it.
         *
         * Ignore all errors because we may be racing with another thread
         * when the file descriptor is closed.
         */
        pollset_ctl(loop->backend_fd, &pc, 1);
        continue;
      }
 
      /* Run signal watchers last.  This also affects child process watchers
       * because those are implemented in terms of signal watchers.
       */
      if (w == &loop->signal_io_watcher) {
        have_signals = 1;
      } else {
        uv__metrics_update_idle_time(loop);
        w->cb(loop, w, pe->revents);
      }
 
      nevents++;
    }
 
    if (reset_timeout != 0) {
      timeout = user_timeout;
      reset_timeout = 0;
    }
 
    if (have_signals != 0) {
      uv__metrics_update_idle_time(loop);
      loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN);
    }
 
    loop->watchers[loop->nwatchers] = NULL;
    loop->watchers[loop->nwatchers + 1] = NULL;
 
    if (have_signals != 0)
      return;  /* Event loop should cycle now so don't poll again. */
 
    if (nevents != 0) {
      if (nfds == ARRAY_SIZE(events) && --count != 0) {
        /* Poll for more events but don't block this time. */
        timeout = 0;
        continue;
      }
      return;
    }
 
    if (timeout == 0)
      return;
 
    if (timeout == -1)
      continue;
 
update_timeout:
    assert(timeout > 0);
 
    diff = loop->time - base;
    if (diff >= (uint64_t) timeout)
      return;
 
    timeout -= diff;
  }
}

References ARRAY_SIZE, assert(), container_of, count, e, EBADF, EEXIST, EINTR, EINVAL, ENOENT, epoll_ctl(), EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD, epoll_wait(), err, EV_OOBAND, epoll_event::events, fd, epoll_event::fd, filter(), flags, i, epoll_event::is_msg, loop, memset(), nfds, NULL, op, os390_message_queue_handler(), pc, poll, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_INIT, QUEUE_INSERT_TAIL, QUEUE_REMOVE, SAVE_ERRNO, timeout, timespec::tv_nsec, timespec::tv_sec, uv__fs_event(), uv__get_internal_fields, uv__load_relaxed, uv__metrics_set_provider_entry_time(), uv__metrics_update_idle_time(), uv__platform_invalidate_fd(), uv__pollfds_add(), uv__pollfds_del(), UV__POLLPRI, UV__POLLRDHUP, uv__store_relaxed, UV_LOOP_BLOCK_SIGPROF, UV_METRICS_IDLE_TIME, w, and x.

Referenced by uv_run().

uv__io_start()

void uv__io_start	(	uv_loop_t *	loop,
		uv__io_t *	w,
		unsigned int	events
	)

Definition at line 882 of file core.c.

                                                                     {
  assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
  assert(0 != events);
  assert(w->fd >= 0);
  assert(w->fd < INT_MAX);
 
  w->pevents |= events;
  maybe_resize(loop, w->fd + 1);
 
#if !defined(__sun)
  /* The event ports backend needs to rearm all file descriptors on each and
   * every tick of the event loop but the other backends allow us to
   * short-circuit here if the event mask is unchanged.
   */
  if (w->events == w->pevents)
    return;
#endif
 
  if (QUEUE_EMPTY(&w->watcher_queue))
    QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
 
  if (loop->watchers[w->fd] == NULL) {
    loop->watchers[w->fd] = w;
    loop->nfds++;
  }
}

References assert(), INT_MAX, loop, maybe_resize(), NULL, QUEUE_EMPTY, QUEUE_INSERT_TAIL, UV__POLLPRI, UV__POLLRDHUP, and w.

Referenced by init_inotify(), uv__async_start(), uv__read(), uv__server_io(), uv__signal_loop_once_init(), uv__tcp_connect(), uv__udp_recv_start(), uv__udp_send(), uv__write(), uv_accept(), uv_fs_event_start(), uv_pipe_connect(), uv_pipe_listen(), uv_poll_start(), uv_read_start(), uv_shutdown(), uv_tcp_listen(), and uv_write2().

uv__io_stop()

void uv__io_stop	(	uv_loop_t *	loop,
		uv__io_t *	w,
		unsigned int	events
	)

Definition at line 910 of file core.c.

                                                                    {
  assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
  assert(0 != events);
 
  if (w->fd == -1)
    return;
 
  assert(w->fd >= 0);
 
  /* Happens when uv__io_stop() is called on a handle that was never started. */
  if ((unsigned) w->fd >= loop->nwatchers)
    return;
 
  w->pevents &= ~events;
 
  if (w->pevents == 0) {
    QUEUE_REMOVE(&w->watcher_queue);
    QUEUE_INIT(&w->watcher_queue);
 
    if (loop->watchers[w->fd] != NULL) {
      assert(loop->watchers[w->fd] == w);
      assert(loop->nfds > 0);
      loop->watchers[w->fd] = NULL;
      loop->nfds--;
      w->events = 0;
    }
  }
  else if (QUEUE_EMPTY(&w->watcher_queue))
    QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
}

References assert(), loop, NULL, QUEUE_EMPTY, QUEUE_INIT, QUEUE_INSERT_TAIL, QUEUE_REMOVE, UV__POLLPRI, UV__POLLRDHUP, and w.

Referenced by uv__async_stop(), uv__drain(), uv__io_close(), uv__io_fork(), uv__platform_loop_delete(), uv__poll_io(), uv__poll_stop(), uv__read(), uv__server_io(), uv__signal_loop_fork(), uv__stream_connect(), uv__stream_eof(), uv__udp_run_completed(), uv__write(), uv_read_stop(), and uv_try_write().

uv__kqueue_init()

int uv__kqueue_init

(

uv_loop_t *

loop

)

Definition at line 51 of file kqueue.c.

                                     {
  loop->backend_fd = kqueue();
  if (loop->backend_fd == -1)
    return UV__ERR(errno);
 
  uv__cloexec(loop->backend_fd, 1);
 
  return 0;
}

References loop, uv__cloexec, and UV__ERR.

Referenced by uv__io_fork(), and uv__platform_loop_init().

uv__make_close_pending()

void uv__make_close_pending

(

uv_handle_t *

handle

)

Definition at line 208 of file core.c.

                                                 {
  assert(handle->flags & UV_HANDLE_CLOSING);
  assert(!(handle->flags & UV_HANDLE_CLOSED));
  handle->next_closing = handle->loop->closing_handles;
  handle->loop->closing_handles = handle;
}

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

Referenced by timer_close_cb(), uv__finish_close(), uv__fs_poll_close(), and uv_close().

uv__make_pipe()

int uv__make_pipe	(	int	fds[2],
		int	flags
	)

Definition at line 142 of file process.c.

                                         {
#if defined(__FreeBSD__) || defined(__linux__)
  if (pipe2(fds, flags | O_CLOEXEC))
    return UV__ERR(errno);
 
  return 0;
#else
  if (pipe(fds))
    return UV__ERR(errno);
 
  if (uv__cloexec(fds[0], 1))
    goto fail;
 
  if (uv__cloexec(fds[1], 1))
    goto fail;
 
  if (flags & UV__F_NONBLOCK) {
    if (uv__nonblock(fds[0], 1))
      goto fail;
 
    if (uv__nonblock(fds[1], 1))
      goto fail;
  }
 
  return 0;
 
fail:
  uv__close(fds[0]);
  uv__close(fds[1]);
  return UV__ERR(errno);
#endif
}

References fail, flags, O_CLOEXEC, pipe, uv__cloexec, uv__close(), UV__ERR, UV__F_NONBLOCK, and uv__nonblock.

Referenced by uv__async_start(), uv__signal_global_reinit(), uv__signal_loop_once_init(), and uv_spawn().

uv__nonblock_fcntl()

int uv__nonblock_fcntl	(	int	fd,
		int	set
	)

Definition at line 608 of file core.c.

                                        {
  int flags;
  int r;
 
  do
    r = fcntl(fd, F_GETFL);
  while (r == -1 && errno == EINTR);
 
  if (r == -1)
    return UV__ERR(errno);
 
  /* Bail out now if already set/clear. */
  if (!!(r & O_NONBLOCK) == !!set)
    return 0;
 
  if (set)
    flags = r | O_NONBLOCK;
  else
    flags = r & ~O_NONBLOCK;
 
  do
    r = fcntl(fd, F_SETFL, flags);
  while (r == -1 && errno == EINTR);
 
  if (r)
    return UV__ERR(errno);
 
  return 0;
}

References EINTR, F_GETFL, F_SETFL, fcntl, fd, flags, O_NONBLOCK, r, and UV__ERR.

Referenced by uv__process_child_init(), and uv_poll_init().

uv__nonblock_ioctl()

int uv__nonblock_ioctl	(	int	fd,
		int	set
	)

Definition at line 578 of file core.c.

                                        {
  int r;
 
  do
    r = ioctl(fd, FIONBIO, &set);
  while (r == -1 && errno == EINTR);
 
  if (r)
    return UV__ERR(errno);
 
  return 0;
}

References EINTR, fd, FIONBIO, ioctl, r, and UV__ERR.

Referenced by uv_poll_init().

uv__open_cloexec()

int uv__open_cloexec	(	const char *	path,
		int	flags
	)

Definition at line 1003 of file core.c.

                                                  {
#if defined(O_CLOEXEC)
  int fd;
 
  fd = open(path, flags | O_CLOEXEC);
  if (fd == -1)
    return UV__ERR(errno);
 
  return fd;
#else  /* O_CLOEXEC */
  int err;
  int fd;
 
  fd = open(path, flags);
  if (fd == -1)
    return UV__ERR(errno);
 
  err = uv__cloexec(fd, 1);
  if (err) {
    uv__close(fd);
    return err;
  }
 
  return fd;
#endif  /* O_CLOEXEC */
}

References err, fd, flags, O_CLOEXEC, path, uv__cloexec, uv__close(), and UV__ERR.

Referenced by uv__emfile_trick(), uv__open_file(), uv__random_readpath(), uv__slurp(), uv__stream_init(), uv_resident_set_memory(), and uv_tty_init().

uv__open_file()

FILE* uv__open_file

(

const char *

path

)

Definition at line 473 of file core.c.

                                      {
  int fd;
  FILE* fp;
 
  fd = uv__open_cloexec(path, O_RDONLY);
  if (fd < 0)
    return NULL;
 
   fp = fdopen(fd, "r");
   if (fp == NULL)
     uv__close(fd);
 
   return fp;
}

References fd, benchmark::FILE, NULL, O_RDONLY, path, uv__close(), and uv__open_cloexec().

Referenced by read_cpufreq(), read_models(), and uv_cpu_info().

uv__pipe_close()

void uv__pipe_close

(

uv_pipe_t *

handle

)

Definition at line 120 of file pipe.c.

                                       {
  if (handle->pipe_fname) {
    /*
     * Unlink the file system entity before closing the file descriptor.
     * Doing it the other way around introduces a race where our process
     * unlinks a socket with the same name that's just been created by
     * another thread or process.
     */
    unlink(handle->pipe_fname);
    uv__free((void*)handle->pipe_fname);
    handle->pipe_fname = NULL;
  }
 
  uv__stream_close((uv_stream_t*)handle);
}

References handle, NULL, unlink, uv__free(), and uv__stream_close().

Referenced by uv_close().

uv__platform_invalidate_fd()

void uv__platform_invalidate_fd	(	uv_loop_t *	loop,
		int	fd
	)

Definition at line 1280 of file aix.c.

                                                         {
  struct pollfd* events;
  uintptr_t i;
  uintptr_t nfds;
  struct poll_ctl pc;
 
  assert(loop->watchers != NULL);
  assert(fd >= 0);
 
  events = (struct pollfd*) loop->watchers[loop->nwatchers];
  nfds = (uintptr_t) loop->watchers[loop->nwatchers + 1];
 
  if (events != NULL)
    /* Invalidate events with same file descriptor */
    for (i = 0; i < nfds; i++)
      if ((int) events[i].fd == fd)
        events[i].fd = -1;
 
  /* Remove the file descriptor from the poll set */
  pc.events = 0;
  pc.cmd = PS_DELETE;
  pc.fd = fd;
  if(loop->backend_fd >= 0)
    pollset_ctl(loop->backend_fd, &pc, 1);
}

References assert(), epoll_ctl(), EPOLL_CTL_DEL, epoll_event::events, fd, i, loop, memset(), nfds, NULL, pc, and uv__pollfds_del().

Referenced by uv__io_close(), uv__io_poll(), and uv__poll_stop().

uv__platform_loop_delete()

void uv__platform_loop_delete

(

uv_loop_t *

loop

)

Definition at line 95 of file aix.c.

                                               {
  if (loop->fs_fd != -1) {
    uv__close(loop->fs_fd);
    loop->fs_fd = -1;
  }
 
  if (loop->backend_fd != -1) {
    pollset_destroy(loop->backend_fd);
    loop->backend_fd = -1;
  }
}

References epoll_queue_close(), loop, NULL, uv__close(), uv__free(), uv__fsevents_loop_delete(), and uv__io_stop().

Referenced by uv__io_fork(), uv__loop_close(), and uv_loop_init().

uv__platform_loop_init()

int uv__platform_loop_init

(

uv_loop_t *

loop

)

Definition at line 81 of file aix.c.

                                            {
  loop->fs_fd = -1;
 
  /* Passing maxfd of -1 should mean the limit is determined
   * by the user's ulimit or the global limit as per the doc */
  loop->backend_fd = pollset_create(-1);
 
  if (loop->backend_fd == -1)
    return -1;
 
  return 0;
}

References EINVAL, epoll_create1(), err, fd, loop, NULL, O_CLOEXEC, uv__cloexec, uv__close(), UV__ERR, and uv__kqueue_init().

Referenced by uv__io_fork(), and uv_loop_init().

uv__poll_close()

void uv__poll_close

(

uv_poll_t *

handle

)

Definition at line 148 of file poll.c.

                                       {
  uv__poll_stop(handle);
}

References handle, and uv__poll_stop().

Referenced by uv_close().

uv__prepare_close()

void uv__prepare_close

(

uv_prepare_t *

handle

)

Referenced by uv_close().

uv__process_close()

void uv__process_close

(

uv_process_t *

handle

)

Definition at line 590 of file process.c.

                                             {
  QUEUE_REMOVE(&handle->queue);
  uv__handle_stop(handle);
  if (QUEUE_EMPTY(&handle->loop->process_handles))
    uv_signal_stop(&handle->loop->child_watcher);
}

References handle, QUEUE_EMPTY, QUEUE_REMOVE, uv__handle_stop, and uv_signal_stop().

Referenced by uv_close().

uv__random_devurandom()

int uv__random_devurandom	(	void *	buf,
		size_t	buflen
	)

Definition at line 86 of file random-devurandom.c.

                                                    {
  uv_once(&once, uv__random_devurandom_init);
 
  if (status != 0)
    return status;
 
  return uv__random_readpath("/dev/urandom", buf, buflen);
}

References buflen, once, status, uv__random_devurandom_init(), uv__random_readpath(), and uv_once().

Referenced by uv__random().

uv__random_getentropy()

int uv__random_getentropy	(	void *	buf,
		size_t	buflen
	)

Definition at line 39 of file random-getentropy.c.

                                                    {
  size_t pos;
  size_t stride;
 
  uv_once(&once, uv__random_getentropy_init);
 
  if (uv__getentropy == NULL)
    return UV_ENOSYS;
 
  /* getentropy() returns an error for requests > 256 bytes. */
  for (pos = 0, stride = 256; pos + stride < buflen; pos += stride)
    if (uv__getentropy((char *) buf + pos, stride))
      return UV__ERR(errno);
 
  if (uv__getentropy((char *) buf + pos, buflen - pos))
    return UV__ERR(errno);
 
  return 0;
}

References buflen, NULL, once, pos, UV__ERR, uv__getentropy, uv__random_getentropy_init(), and uv_once().

Referenced by uv__random().

uv__random_getrandom()

int uv__random_getrandom	(	void *	buf,
		size_t	buflen
	)

Definition at line 56 of file random-getrandom.c.

                                                   {
  ssize_t n;
  size_t pos;
  int rc;
 
  rc = uv__random_getrandom_init();
  if (rc != 0)
    return rc;
 
  for (pos = 0; pos != buflen; pos += n) {
    do {
      n = buflen - pos;
 
      /* Most getrandom() implementations promise that reads <= 256 bytes
       * will always succeed and won't be interrupted by signals.
       * It's therefore useful to split it up in smaller reads because
       * one big read may, in theory, continuously fail with EINTR.
       */
      if (n > 256)
        n = 256;
 
      n = uv__getrandom((char *) buf + pos, n, 0);
    } while (n == -1 && errno == EINTR);
 
    if (n == -1)
      return UV__ERR(errno);
 
    if (n == 0)
      return UV_EIO;
  }
 
  return 0;
}

References buflen, EINTR, n, pos, UV__ERR, uv__getrandom, and uv__random_getrandom_init().

Referenced by uv__random().

uv__random_readpath()

int uv__random_readpath	(	const char *	path,
		void *	buf,
		size_t	buflen
	)

Definition at line 32 of file random-devurandom.c.

                                                                    {
  struct stat s;
  size_t pos;
  ssize_t n;
  int fd;
 
  fd = uv__open_cloexec(path, O_RDONLY);
 
  if (fd < 0)
    return fd;
 
  if (fstat(fd, &s)) {
    uv__close(fd);
    return UV__ERR(errno);
  }
 
  if (!S_ISCHR(s.st_mode)) {
    uv__close(fd);
    return UV_EIO;
  }
 
  for (pos = 0; pos != buflen; pos += n) {
    do
      n = read(fd, (char*) buf + pos, buflen - pos);
    while (n == -1 && errno == EINTR);
 
    if (n == -1) {
      uv__close(fd);
      return UV__ERR(errno);
    }
 
    if (n == 0) {
      uv__close(fd);
      return UV_EIO;
    }
  }
 
  uv__close(fd);
  return 0;
}

References buflen, EINTR, fd, fstat, n, O_RDONLY, path, pos, read(), s, uv__close(), UV__ERR, and uv__open_cloexec().

Referenced by uv__random(), uv__random_devurandom(), and uv__random_devurandom_init().

uv__random_sysctl()

int uv__random_sysctl	(	void *	buf,
		size_t	buflen
	)

Definition at line 238 of file netbsd.c.

                                             {
  static int name[] = {CTL_KERN, KERN_ARND};
  size_t count, req;
  unsigned char* p;
 
  p = buf;
  while (len) {
    req = len < 32 ? len : 32;
    count = req;
 
    if (sysctl(name, ARRAY_SIZE(name), p, &count, NULL, 0) == -1)
      return UV__ERR(errno);
 
    if (count != req)
      return UV_EIO;  /* Can't happen. */
 
    p += count;
    len -= count;
  }
 
  return 0;
}

References args, ARRAY_SIZE, buflen, count, len, memcpy(), memset(), n, name, NULL, p, req, syscall, and UV__ERR.

Referenced by uv__random().

uv__recvmsg()

ssize_t uv__recvmsg	(	int	fd,
		struct msghdr *	msg,
		int	flags
	)

Definition at line 670 of file core.c.

                                                           {
  struct cmsghdr* cmsg;
  ssize_t rc;
  int* pfd;
  int* end;
#if defined(__linux__)
  static int no_msg_cmsg_cloexec;
  if (0 == uv__load_relaxed(&no_msg_cmsg_cloexec)) {
    rc = recvmsg(fd, msg, flags | 0x40000000);  /* MSG_CMSG_CLOEXEC */
    if (rc != -1)
      return rc;
    if (errno != EINVAL)
      return UV__ERR(errno);
    rc = recvmsg(fd, msg, flags);
    if (rc == -1)
      return UV__ERR(errno);
    uv__store_relaxed(&no_msg_cmsg_cloexec, 1);
  } else {
    rc = recvmsg(fd, msg, flags);
  }
#else
  rc = recvmsg(fd, msg, flags);
#endif
  if (rc == -1)
    return UV__ERR(errno);
  if (msg->msg_controllen == 0)
    return rc;
  for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg))
    if (cmsg->cmsg_type == SCM_RIGHTS)
      for (pfd = (int*) CMSG_DATA(cmsg),
           end = (int*) ((char*) cmsg + cmsg->cmsg_len);
           pfd < end;
           pfd += 1)
        uv__cloexec(*pfd, 1);
  return rc;
}

References CMSG_DATA, CMSG_FIRSTHDR, cmsghdr::cmsg_len, CMSG_NXTHDR, cmsghdr::cmsg_type, EINVAL, test_evm::end, fd, flags, msg, NULL, SCM_RIGHTS, uv__cloexec, UV__ERR, uv__load_relaxed, and uv__store_relaxed.

Referenced by uv__read().

uv__run_check()

void uv__run_check

(

uv_loop_t *

loop

)

Referenced by uv_run().

uv__run_idle()

void uv__run_idle

(

uv_loop_t *

loop

)

Referenced by uv_run().

uv__run_prepare()

void uv__run_prepare

(

uv_loop_t *

loop

)

Referenced by uv_run().

uv__search_path()

int uv__search_path	(	const char *	prog,
		char *	buf,
		size_t *	buflen
	)

Definition at line 1540 of file core.c.

                                                                 {
  char abspath[UV__PATH_MAX];
  size_t abspath_size;
  char trypath[UV__PATH_MAX];
  char* cloned_path;
  char* path_env;
  char* token;
 
  if (buf == NULL || buflen == NULL || *buflen == 0)
    return UV_EINVAL;
 
  /*
   * Possibilities for prog:
   * i) an absolute path such as: /home/user/myprojects/nodejs/node
   * ii) a relative path such as: ./node or ../myprojects/nodejs/node
   * iii) a bare filename such as "node", after exporting PATH variable
   *     to its location.
   */
 
  /* Case i) and ii) absolute or relative paths */
  if (strchr(prog, '/') != NULL) {
    if (realpath(prog, abspath) != abspath)
      return UV__ERR(errno);
 
    abspath_size = strlen(abspath);
 
    *buflen -= 1;
    if (*buflen > abspath_size)
      *buflen = abspath_size;
 
    memcpy(buf, abspath, *buflen);
    buf[*buflen] = '\0';
 
    return 0;
  } 
 
  /* Case iii). Search PATH environment variable */
  cloned_path = NULL;
  token = NULL;
  path_env = getenv("PATH");
 
  if (path_env == NULL)
    return UV_EINVAL;
 
  cloned_path = uv__strdup(path_env);
  if (cloned_path == NULL)
    return UV_ENOMEM;
 
  token = strtok(cloned_path, ":");
  while (token != NULL) {
    snprintf(trypath, sizeof(trypath) - 1, "%s/%s", token, prog);
    if (realpath(trypath, abspath) == abspath) {
      /* Check the match is executable */
      if (access(abspath, X_OK) == 0) {
        abspath_size = strlen(abspath);
 
        *buflen -= 1;
        if (*buflen > abspath_size)
          *buflen = abspath_size;
 
        memcpy(buf, abspath, *buflen);
        buf[*buflen] = '\0';
 
        uv__free(cloned_path);
        return 0;
      }
    }
    token = strtok(NULL, ":");
  }
  uv__free(cloned_path);
 
  /* Out of tokens (path entries), and no match found */
  return UV_EINVAL;
}

References access, buflen, getenv(), memcpy(), NULL, prog, snprintf, UV__ERR, uv__free(), UV__PATH_MAX, uv__strdup(), and X_OK.

Referenced by uv_exepath(), and uv_setup_args().

uv__server_io()

void uv__server_io	(	uv_loop_t *	loop,
		uv__io_t *	w,
		unsigned int	events
	)

Definition at line 528 of file stream.c.

                                                                      {
  uv_stream_t* stream;
  int err;
 
  stream = container_of(w, uv_stream_t, io_watcher);
  assert(events & POLLIN);
  assert(stream->accepted_fd == -1);
  assert(!(stream->flags & UV_HANDLE_CLOSING));
 
  uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
 
  /* connection_cb can close the server socket while we're
   * in the loop so check it on each iteration.
   */
  while (uv__stream_fd(stream) != -1) {
    assert(stream->accepted_fd == -1);
 
#if defined(UV_HAVE_KQUEUE)
    if (w->rcount <= 0)
      return;
#endif /* defined(UV_HAVE_KQUEUE) */
 
    err = uv__accept(uv__stream_fd(stream));
    if (err < 0) {
      if (err == UV_EAGAIN || err == UV__ERR(EWOULDBLOCK))
        return;  /* Not an error. */
 
      if (err == UV_ECONNABORTED)
        continue;  /* Ignore. Nothing we can do about that. */
 
      if (err == UV_EMFILE || err == UV_ENFILE) {
        err = uv__emfile_trick(loop, uv__stream_fd(stream));
        if (err == UV_EAGAIN || err == UV__ERR(EWOULDBLOCK))
          break;
      }
 
      stream->connection_cb(stream, err);
      continue;
    }
 
    UV_DEC_BACKLOG(w)
    stream->accepted_fd = err;
    stream->connection_cb(stream, 0);
 
    if (stream->accepted_fd != -1) {
      /* The user hasn't yet accepted called uv_accept() */
      uv__io_stop(loop, &stream->io_watcher, POLLIN);
      return;
    }
 
    if (stream->type == UV_TCP &&
        (stream->flags & UV_HANDLE_TCP_SINGLE_ACCEPT)) {
      /* Give other processes a chance to accept connections. */
      struct timespec timeout = { 0, 1 };
      nanosleep(&timeout, NULL);
    }
  }
}

References assert(), container_of, err, loop, nanosleep, NULL, timeout, uv__accept(), uv__emfile_trick(), UV__ERR, uv__io_start(), uv__io_stop(), uv__stream_fd, UV_DEC_BACKLOG, UV_HANDLE_CLOSING, UV_HANDLE_TCP_SINGLE_ACCEPT, and w.

Referenced by uv_pipe_listen(), and uv_tcp_listen().

uv__signal_close()

void uv__signal_close

(

uv_signal_t *

handle

)

Definition at line 335 of file signal.c.

                                           {
  uv__signal_stop(handle);
}

References handle, and uv__signal_stop().

Referenced by uv_close().

uv__signal_global_once_init()

void uv__signal_global_once_init

(

void

)

Definition at line 111 of file signal.c.

                                       {
  uv_once(&uv__signal_global_init_guard, uv__signal_global_init);
}

References uv__signal_global_init_guard, and uv_once().

Referenced by uv_loop_init().

uv__signal_loop_cleanup()

void uv__signal_loop_cleanup

(

uv_loop_t *

loop

)

Definition at line 291 of file signal.c.

                                              {
  QUEUE* q;
 
  /* Stop all the signal watchers that are still attached to this loop. This
   * ensures that the (shared) signal tree doesn't contain any invalid entries
   * entries, and that signal handlers are removed when appropriate.
   * It's safe to use QUEUE_FOREACH here because the handles and the handle
   * queue are not modified by uv__signal_stop().
   */
  QUEUE_FOREACH(q, &loop->handle_queue) {
    uv_handle_t* handle = QUEUE_DATA(q, uv_handle_t, handle_queue);
 
    if (handle->type == UV_SIGNAL)
      uv__signal_stop((uv_signal_t*) handle);
  }
 
  if (loop->signal_pipefd[0] != -1) {
    uv__close(loop->signal_pipefd[0]);
    loop->signal_pipefd[0] = -1;
  }
 
  if (loop->signal_pipefd[1] != -1) {
    uv__close(loop->signal_pipefd[1]);
    loop->signal_pipefd[1] = -1;
  }
}

References handle, uv_loop_s::handle_queue, loop, QUEUE_DATA, QUEUE_FOREACH, uv__close(), and uv__signal_stop().

Referenced by uv__loop_close(), and uv_loop_init().

uv__signal_loop_fork()

int uv__signal_loop_fork

(

uv_loop_t *

loop

)

Definition at line 281 of file signal.c.

                                          {
  uv__io_stop(loop, &loop->signal_io_watcher, POLLIN);
  uv__close(loop->signal_pipefd[0]);
  uv__close(loop->signal_pipefd[1]);
  loop->signal_pipefd[0] = -1;
  loop->signal_pipefd[1] = -1;
  return uv__signal_loop_once_init(loop);
}

References loop, uv__close(), uv__io_stop(), and uv__signal_loop_once_init().

Referenced by uv_loop_fork().

uv__socket()

int uv__socket	(	int	domain,
		int	type,
		int	protocol
	)

Definition at line 436 of file core.c.

                                                   {
  int sockfd;
  int err;
 
#if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
  sockfd = socket(domain, type | SOCK_NONBLOCK | SOCK_CLOEXEC, protocol);
  if (sockfd != -1)
    return sockfd;
 
  if (errno != EINVAL)
    return UV__ERR(errno);
#endif
 
  sockfd = socket(domain, type, protocol);
  if (sockfd == -1)
    return UV__ERR(errno);
 
  err = uv__nonblock(sockfd, 1);
  if (err == 0)
    err = uv__cloexec(sockfd, 1);
 
  if (err) {
    uv__close(sockfd);
    return err;
  }
 
#if defined(SO_NOSIGPIPE)
  {
    int on = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof(on));
  }
#endif
 
  return sockfd;
}

References domain, EINVAL, err, socket, sockfd, SOL_SOCKET, type, uv__cloexec, uv__close(), UV__ERR, and uv__nonblock.

Referenced by new_socket(), uv__udp_bind(), uv__udp_init_ex(), uv_pipe_bind(), and uv_pipe_connect().

uv__stream_close()

void uv__stream_close

(

uv_stream_t *

handle

)

Definition at line 1633 of file stream.c.

                                           {
  unsigned int i;
  uv__stream_queued_fds_t* queued_fds;
 
#if defined(__APPLE__)
  /* Terminate select loop first */
  if (handle->select != NULL) {
    uv__stream_select_t* s;
 
    s = handle->select;
 
    uv_sem_post(&s->close_sem);
    uv_sem_post(&s->async_sem);
    uv__stream_osx_interrupt_select(handle);
    uv_thread_join(&s->thread);
    uv_sem_destroy(&s->close_sem);
    uv_sem_destroy(&s->async_sem);
    uv__close(s->fake_fd);
    uv__close(s->int_fd);
    uv_close((uv_handle_t*) &s->async, uv__stream_osx_cb_close);
 
    handle->select = NULL;
  }
#endif /* defined(__APPLE__) */
 
  uv__io_close(handle->loop, &handle->io_watcher);
  uv_read_stop(handle);
  uv__handle_stop(handle);
  handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
 
  if (handle->io_watcher.fd != -1) {
    /* Don't close stdio file descriptors.  Nothing good comes from it. */
    if (handle->io_watcher.fd > STDERR_FILENO)
      uv__close(handle->io_watcher.fd);
    handle->io_watcher.fd = -1;
  }
 
  if (handle->accepted_fd != -1) {
    uv__close(handle->accepted_fd);
    handle->accepted_fd = -1;
  }
 
  /* Close all queued fds */
  if (handle->queued_fds != NULL) {
    queued_fds = handle->queued_fds;
    for (i = 0; i < queued_fds->offset; i++)
      uv__close(queued_fds->fds[i]);
    uv__free(handle->queued_fds);
    handle->queued_fds = NULL;
  }
 
  assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
}

References assert(), uv__stream_queued_fds_s::fds, handle, i, NULL, uv__stream_queued_fds_s::offset, s, STDERR_FILENO, uv__close(), uv__free(), uv__handle_stop, uv__io_active(), uv__io_close(), uv__stream_osx_interrupt_select(), uv_close(), UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, uv_read_stop(), uv_sem_destroy(), uv_sem_post(), and uv_thread_join().

Referenced by uv__pipe_close(), uv__process_close_stream(), uv__tcp_close(), and uv_close().

uv__stream_destroy()

void uv__stream_destroy

(

uv_stream_t *

stream

)

Definition at line 458 of file stream.c.

                                             {
  assert(!uv__io_active(&stream->io_watcher, POLLIN | POLLOUT));
  assert(stream->flags & UV_HANDLE_CLOSED);
 
  if (stream->connect_req) {
    uv__req_unregister(stream->loop, stream->connect_req);
    stream->connect_req->cb(stream->connect_req, UV_ECANCELED);
    stream->connect_req = NULL;
  }
 
  uv__stream_flush_write_queue(stream, UV_ECANCELED);
  uv__write_callbacks(stream);
 
  if (stream->shutdown_req) {
    /* The ECANCELED error code is a lie, the shutdown(2) syscall is a
     * fait accompli at this point. Maybe we should revisit this in v0.11.
     * A possible reason for leaving it unchanged is that it informs the
     * callee that the handle has been destroyed.
     */
    uv__req_unregister(stream->loop, stream->shutdown_req);
    stream->shutdown_req->cb(stream->shutdown_req, UV_ECANCELED);
    stream->shutdown_req = NULL;
  }
 
  assert(stream->write_queue_size == 0);
}

References assert(), NULL, uv__io_active(), uv__req_unregister, uv__stream_flush_write_queue(), uv__write_callbacks(), and UV_HANDLE_CLOSED.

Referenced by uv__finish_close().

uv__stream_init()

void uv__stream_init	(	uv_loop_t *	loop,
		uv_stream_t *	stream,
		uv_handle_type	type
	)

Definition at line 85 of file stream.c.

                                          {
  int err;
 
  uv__handle_init(loop, (uv_handle_t*)stream, type);
  stream->read_cb = NULL;
  stream->alloc_cb = NULL;
  stream->close_cb = NULL;
  stream->connection_cb = NULL;
  stream->connect_req = NULL;
  stream->shutdown_req = NULL;
  stream->accepted_fd = -1;
  stream->queued_fds = NULL;
  stream->delayed_error = 0;
  QUEUE_INIT(&stream->write_queue);
  QUEUE_INIT(&stream->write_completed_queue);
  stream->write_queue_size = 0;
 
  if (loop->emfile_fd == -1) {
    err = uv__open_cloexec("/dev/null", O_RDONLY);
    if (err < 0)
        /* In the rare case that "/dev/null" isn't mounted open "/"
         * instead.
         */
        err = uv__open_cloexec("/", O_RDONLY);
    if (err >= 0)
      loop->emfile_fd = err;
  }
 
#if defined(__APPLE__)
  stream->select = NULL;
#endif /* defined(__APPLE_) */
 
  uv__io_init(&stream->io_watcher, uv__stream_io, -1);
}

References err, loop, NULL, O_RDONLY, QUEUE_INIT, type, uv__handle_init, uv__io_init(), uv__open_cloexec(), and uv__stream_io().

Referenced by uv_pipe_init(), uv_tcp_init_ex(), and uv_tty_init().

uv__stream_open()

int uv__stream_open	(	uv_stream_t *	stream,
		int	fd,
		int	flags
	)

Definition at line 406 of file stream.c.

                                                            {
#if defined(__APPLE__)
  int enable;
#endif
 
  if (!(stream->io_watcher.fd == -1 || stream->io_watcher.fd == fd))
    return UV_EBUSY;
 
  assert(fd >= 0);
  stream->flags |= flags;
 
  if (stream->type == UV_TCP) {
    if ((stream->flags & UV_HANDLE_TCP_NODELAY) && uv__tcp_nodelay(fd, 1))
      return UV__ERR(errno);
 
    /* TODO Use delay the user passed in. */
    if ((stream->flags & UV_HANDLE_TCP_KEEPALIVE) &&
        uv__tcp_keepalive(fd, 1, 60)) {
      return UV__ERR(errno);
    }
  }
 
#if defined(__APPLE__)
  enable = 1;
  if (setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &enable, sizeof(enable)) &&
      errno != ENOTSOCK &&
      errno != EINVAL) {
    return UV__ERR(errno);
  }
#endif
 
  stream->io_watcher.fd = fd;
 
  return 0;
}

References assert(), EINVAL, ENOTSOCK, fd, flags, SO_OOBINLINE, SOL_SOCKET, UV__ERR, uv__tcp_keepalive(), uv__tcp_nodelay(), UV_HANDLE_TCP_KEEPALIVE, and UV_HANDLE_TCP_NODELAY.

Referenced by new_socket(), uv__process_open_stream(), uv_accept(), uv_pipe_connect(), uv_pipe_open(), uv_tcp_open(), and uv_tty_init().

uv__tcp_close()

void uv__tcp_close

(

uv_tcp_t *

handle

)

Definition at line 459 of file tcp.c.

                                     {
  uv__stream_close((uv_stream_t*)handle);
}

References handle, and uv__stream_close().

Referenced by uv_close().

uv__tcp_keepalive()

int uv__tcp_keepalive	(	int	fd,
		int	on,
		unsigned int	delay
	)

Definition at line 380 of file tcp.c.

                                                          {
  if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)))
    return UV__ERR(errno);
 
#ifdef TCP_KEEPIDLE
  if (on) {
    int intvl = 1;  /*  1 second; same as default on Win32 */
    int cnt = 10;  /* 10 retries; same as hardcoded on Win32 */
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &delay, sizeof(delay)))
      return UV__ERR(errno);
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl)))
      return UV__ERR(errno);
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt)))
      return UV__ERR(errno);
  }
#endif
 
  /* Solaris/SmartOS, if you don't support keep-alive,
   * then don't advertise it in your system headers...
   */
  /* FIXME(bnoordhuis) That's possibly because sizeof(delay) should be 1. */
#if defined(TCP_KEEPALIVE) && !defined(__sun)
  if (on && setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &delay, sizeof(delay)))
    return UV__ERR(errno);
#endif
 
  return 0;
}

References fd, SO_KEEPALIVE, SOL_SOCKET, TCP_KEEPALIVE, and UV__ERR.

Referenced by uv__stream_open(), uv_tcp_keepalive(), and uv_tcp_set_socket().

uv__tcp_nodelay()

int uv__tcp_nodelay	(	int	fd,
		int	on
	)

Definition at line 373 of file tcp.c.

                                    {
  if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)))
    return UV__ERR(errno);
  return 0;
}

References fd, and UV__ERR.

Referenced by uv__stream_open(), uv_tcp_nodelay(), and uv_tcp_set_socket().

uv__udp_close()

void uv__udp_close

(

uv_udp_t *

handle

)

Definition at line 90 of file udp.c.

                                     {
  uv__io_close(handle->loop, &handle->io_watcher);
  uv__handle_stop(handle);
 
  if (handle->io_watcher.fd != -1) {
    uv__close(handle->io_watcher.fd);
    handle->io_watcher.fd = -1;
  }
}

References handle, uv__close(), uv__handle_stop, and uv__io_close().

Referenced by uv_close().

uv__udp_finish_close()

void uv__udp_finish_close

(

uv_udp_t *

handle

)

Definition at line 101 of file udp.c.

                                            {
  uv_udp_send_t* req;
  QUEUE* q;
 
  assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
  assert(handle->io_watcher.fd == -1);
 
  while (!QUEUE_EMPTY(&handle->write_queue)) {
    q = QUEUE_HEAD(&handle->write_queue);
    QUEUE_REMOVE(q);
 
    req = QUEUE_DATA(q, uv_udp_send_t, queue);
    req->status = UV_ECANCELED;
    QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
  }
 
  uv__udp_run_completed(handle);
 
  assert(handle->send_queue_size == 0);
  assert(handle->send_queue_count == 0);
 
  /* Now tear down the handle. */
  handle->recv_cb = NULL;
  handle->alloc_cb = NULL;
  /* but _do not_ touch close_cb */
}

References assert(), handle, NULL, queue, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_INSERT_TAIL, QUEUE_REMOVE, req, uv__io_active(), and uv__udp_run_completed().

Referenced by uv__finish_close().

uv_pipe_listen()

int uv_pipe_listen	(	uv_pipe_t *	handle,
		int	backlog,
		uv_connection_cb	cb
	)

Definition at line 94 of file pipe.c.

                                                                        {
  if (uv__stream_fd(handle) == -1)
    return UV_EINVAL;
 
  if (handle->ipc)
    return UV_EINVAL;
 
#if defined(__MVS__) || defined(__PASE__)
  /* On zOS, backlog=0 has undefined behaviour */
  /* On IBMi PASE, backlog=0 leads to "Connection refused" error */
  if (backlog == 0)
    backlog = 1;
  else if (backlog < 0)
    backlog = SOMAXCONN;
#endif
 
  if (listen(uv__stream_fd(handle), backlog))
    return UV__ERR(errno);
 
  handle->connection_cb = cb;
  handle->io_watcher.cb = uv__server_io;
  uv__io_start(handle->loop, &handle->io_watcher, POLLIN);
  return 0;
}

References cb, handle, listen, UV__ERR, uv__io_start(), uv__server_io(), and uv__stream_fd.

Referenced by uv_listen().

uv_tcp_listen()

int uv_tcp_listen	(	uv_tcp_t *	tcp,
		int	backlog,
		uv_connection_cb	cb
	)

Definition at line 328 of file tcp.c.

                                                                   {
  static int single_accept_cached = -1;
  unsigned long flags;
  int single_accept;
  int err;
 
  if (tcp->delayed_error)
    return tcp->delayed_error;
 
  single_accept = uv__load_relaxed(&single_accept_cached);
  if (single_accept == -1) {
    const char* val = getenv("UV_TCP_SINGLE_ACCEPT");
    single_accept = (val != NULL && atoi(val) != 0);  /* Off by default. */
    uv__store_relaxed(&single_accept_cached, single_accept);
  }
 
  if (single_accept)
    tcp->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
 
  flags = 0;
#if defined(__MVS__)
  /* on zOS the listen call does not bind automatically
     if the socket is unbound. Hence the manual binding to
     an arbitrary port is required to be done manually
  */
  flags |= UV_HANDLE_BOUND;
#endif
  err = maybe_new_socket(tcp, AF_INET, flags);
  if (err)
    return err;
 
  if (listen(tcp->io_watcher.fd, backlog))
    return UV__ERR(errno);
 
  tcp->connection_cb = cb;
  tcp->flags |= UV_HANDLE_BOUND;
 
  /* Start listening for connections. */
  tcp->io_watcher.cb = uv__server_io;
  uv__io_start(tcp->loop, &tcp->io_watcher, POLLIN);
 
  return 0;
}

References AF_INET, cb, err, flags, getenv(), listen, maybe_new_socket(), NULL, UV__ERR, uv__io_start(), uv__load_relaxed, uv__server_io(), uv__store_relaxed, UV_HANDLE_BOUND, UV_HANDLE_TCP_SINGLE_ACCEPT, and val.

Referenced by uv_listen().

UV_UNUSED() [1/2]

UV_UNUSED

(

static char *

uv__basename_rconst char *path

)

Definition at line 307 of file internal.h.

                                                         {
  char* s;
 
  s = strrchr(path, '/');
  if (s == NULL)
    return (char*) path;
 
  return s + 1;
}

References NULL, path, and s.

UV_UNUSED() [2/2]

UV_UNUSED

(

static void

uv__update_timeuv_loop_t *loop

)

Definition at line 301 of file internal.h.

                                                        {
  /* Use a fast time source if available.  We only need millisecond precision.
   */
  loop->time = uv__hrtime(UV_CLOCK_FAST) / 1000000;
}

References loop, uv__hrtime(), and UV_CLOCK_FAST.