core.c File Reference

#include "uv.h"
#include "internal.h"
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <limits.h>
#include <sys/uio.h>
#include <sys/resource.h>
#include <pwd.h>
#include <sys/utsname.h>
#include <sys/time.h>

Go to the source code of this file.

Macros
#define	CHECK_ENV_VAR(name)

Functions
static int	uv__run_pending (uv_loop_t *loop)
	STATIC_ASSERT (sizeof(uv_buf_t)==sizeof(struct iovec))
	STATIC_ASSERT (sizeof(&((uv_buf_t *) 0) ->base)==sizeof(((struct iovec *) 0) ->iov_base))
	STATIC_ASSERT (sizeof(&((uv_buf_t *) 0) ->len)==sizeof(((struct iovec *) 0) ->iov_len))
	STATIC_ASSERT (offsetof(uv_buf_t, base)==offsetof(struct iovec, iov_base))
	STATIC_ASSERT (offsetof(uv_buf_t, len)==offsetof(struct iovec, iov_len))
uint64_t	uv_hrtime (void)
void	uv_close (uv_handle_t *handle, uv_close_cb close_cb)
int	uv__socket_sockopt (uv_handle_t *handle, int optname, int *value)
void	uv__make_close_pending (uv_handle_t *handle)
int	uv__getiovmax (void)
static void	uv__finish_close (uv_handle_t *handle)
static void	uv__run_closing_handles (uv_loop_t *loop)
int	uv_is_closing (const uv_handle_t *handle)
int	uv_backend_fd (const uv_loop_t *loop)
int	uv_backend_timeout (const uv_loop_t *loop)
static int	uv__loop_alive (const uv_loop_t *loop)
int	uv_loop_alive (const uv_loop_t *loop)
int	uv_run (uv_loop_t *loop, uv_run_mode mode)
void	uv_update_time (uv_loop_t *loop)
int	uv_is_active (const uv_handle_t *handle)
int	uv__socket (int domain, int type, int protocol)
FILE *	uv__open_file (const char *path)
int	uv__accept (int sockfd)
int	uv__close_nocancel (int fd)
int	uv__close_nocheckstdio (int fd)
int	uv__close (int fd)
int	uv__nonblock_ioctl (int fd, int set)
int	uv__cloexec_ioctl (int fd, int set)
int	uv__nonblock_fcntl (int fd, int set)
int	uv__cloexec_fcntl (int fd, int set)
ssize_t	uv__recvmsg (int fd, struct msghdr *msg, int flags)
int	uv_cwd (char *buffer, size_t *size)
int	uv_chdir (const char *dir)
void	uv_disable_stdio_inheritance (void)
int	uv_fileno (const uv_handle_t *handle, uv_os_fd_t *fd)
static unsigned int	next_power_of_two (unsigned int val)
static void	maybe_resize (uv_loop_t *loop, unsigned int len)
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__fd_exists (uv_loop_t *loop, int fd)
int	uv_getrusage (uv_rusage_t *rusage)
int	uv__open_cloexec (const char *path, int flags)
int	uv__dup2_cloexec (int oldfd, int newfd)
int	uv_os_homedir (char *buffer, size_t *size)
int	uv_os_tmpdir (char *buffer, size_t *size)
int	uv__getpwuid_r (uv_passwd_t *pwd)
void	uv_os_free_passwd (uv_passwd_t *pwd)
int	uv_os_get_passwd (uv_passwd_t *pwd)
int	uv_translate_sys_error (int sys_errno)
int	uv_os_environ (uv_env_item_t **envitems, int *count)
int	uv_os_getenv (const char *name, char *buffer, size_t *size)
int	uv_os_setenv (const char *name, const char *value)
int	uv_os_unsetenv (const char *name)
int	uv_os_gethostname (char *buffer, size_t *size)
uv_os_fd_t	uv_get_osfhandle (int fd)
int	uv_open_osfhandle (uv_os_fd_t os_fd)
uv_pid_t	uv_os_getpid (void)
uv_pid_t	uv_os_getppid (void)
int	uv_os_getpriority (uv_pid_t pid, int *priority)
int	uv_os_setpriority (uv_pid_t pid, int priority)
int	uv_os_uname (uv_utsname_t *buffer)
int	uv__getsockpeername (const uv_handle_t *handle, uv__peersockfunc func, struct sockaddr *name, int *namelen)
int	uv_gettimeofday (uv_timeval64_t *tv)
void	uv_sleep (unsigned int msec)
int	uv__search_path (const char *prog, char *buf, size_t *buflen)

Variables
char **	environ

Macro Definition Documentation

CHECK_ENV_VAR

#define CHECK_ENV_VAR

(

name

)

Value:

  do {                                                                        \
    buf = getenv(name);                                                       \
    if (buf != NULL)                                                          \
      goto return_buffer;                                                     \
  }                                                                           \
  while (0)

Function Documentation

maybe_resize()

static void maybe_resize ( uv_loop_t *  loop, unsigned int  len  )

static

Definition at line 830 of file core.c.

                                                            {
  uv__io_t** watchers;
  void* fake_watcher_list;
  void* fake_watcher_count;
  unsigned int nwatchers;
  unsigned int i;
 
  if (len <= loop->nwatchers)
    return;
 
  /* Preserve fake watcher list and count at the end of the watchers */
  if (loop->watchers != NULL) {
    fake_watcher_list = loop->watchers[loop->nwatchers];
    fake_watcher_count = loop->watchers[loop->nwatchers + 1];
  } else {
    fake_watcher_list = NULL;
    fake_watcher_count = NULL;
  }
 
  nwatchers = next_power_of_two(len + 2) - 2;
  watchers = uv__reallocf(loop->watchers,
                          (nwatchers + 2) * sizeof(loop->watchers[0]));
 
  if (watchers == NULL)
    abort();
  for (i = loop->nwatchers; i < nwatchers; i++)
    watchers[i] = NULL;
  watchers[nwatchers] = fake_watcher_list;
  watchers[nwatchers + 1] = fake_watcher_count;
 
  loop->watchers = watchers;
  loop->nwatchers = nwatchers;
}

References i, len, loop, next_power_of_two(), NULL, and uv__reallocf().

Referenced by uv__io_start().

next_power_of_two()

static unsigned int next_power_of_two ( unsigned int  val )

static

Definition at line 819 of file core.c.

                                                        {
  val -= 1;
  val |= val >> 1;
  val |= val >> 2;
  val |= val >> 4;
  val |= val >> 8;
  val |= val >> 16;
  val += 1;
  return val;
}

References val.

Referenced by maybe_resize().

STATIC_ASSERT() [1/5]

STATIC_ASSERT

(

offsetof(uv_buf_t, base)

= =offsetof(struct iovec, iov_base)

)

STATIC_ASSERT() [2/5]

STATIC_ASSERT

(

offsetof(uv_buf_t, len)

= =offsetof(struct iovec, iov_len)

)

STATIC_ASSERT() [3/5]

STATIC_ASSERT

(

sizeof(&((uv_buf_t *) 0) ->base)

= =sizeof(((struct iovec *) 0) ->iov_base)

)

STATIC_ASSERT() [4/5]

STATIC_ASSERT

(

sizeof(&((uv_buf_t *) 0) ->len)

= =sizeof(((struct iovec *) 0) ->iov_len)

)

STATIC_ASSERT() [5/5]

STATIC_ASSERT

(

sizeof(uv_buf_t)

= =sizeof(struct iovec)

)

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__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__finish_close()

static void uv__finish_close ( uv_handle_t *  handle )

static

Definition at line 243 of file core.c.

                                                  {
  uv_signal_t* sh;
 
  /* Note: while the handle is in the UV_HANDLE_CLOSING state now, it's still
   * possible for it to be active in the sense that uv__is_active() returns
   * true.
   *
   * A good example is when the user calls uv_shutdown(), immediately followed
   * by uv_close(). The handle is considered active at this point because the
   * completion of the shutdown req is still pending.
   */
  assert(handle->flags & UV_HANDLE_CLOSING);
  assert(!(handle->flags & UV_HANDLE_CLOSED));
  handle->flags |= UV_HANDLE_CLOSED;
 
  switch (handle->type) {
    case UV_PREPARE:
    case UV_CHECK:
    case UV_IDLE:
    case UV_ASYNC:
    case UV_TIMER:
    case UV_PROCESS:
    case UV_FS_EVENT:
    case UV_FS_POLL:
    case UV_POLL:
      break;
 
    case UV_SIGNAL:
      /* If there are any caught signals "trapped" in the signal pipe,
       * we can't call the close callback yet. Reinserting the handle
       * into the closing queue makes the event loop spin but that's
       * okay because we only need to deliver the pending events.
       */
      sh = (uv_signal_t*) handle;
      if (sh->caught_signals > sh->dispatched_signals) {
        handle->flags ^= UV_HANDLE_CLOSED;
        uv__make_close_pending(handle);  /* Back into the queue. */
        return;
      }
      break;
 
    case UV_NAMED_PIPE:
    case UV_TCP:
    case UV_TTY:
      uv__stream_destroy((uv_stream_t*)handle);
      break;
 
    case UV_UDP:
      uv__udp_finish_close((uv_udp_t*)handle);
      break;
 
    default:
      assert(0);
      break;
  }
 
  uv__handle_unref(handle);
  QUEUE_REMOVE(&handle->handle_queue);
 
  if (handle->close_cb) {
    handle->close_cb(handle);
  }
}

References assert(), handle, QUEUE_REMOVE, uv__handle_unref, uv__make_close_pending(), uv__stream_destroy(), uv__udp_finish_close(), UV_HANDLE_CLOSED, and UV_HANDLE_CLOSING.

Referenced by uv__run_closing_handles().

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

References buf, ERANGE, uv_passwd_s::gid, uv_passwd_s::homedir, memcpy(), NULL, r, uv_passwd_s::shell, uv_passwd_s::uid, uv_passwd_s::username, uv__free(), and uv__malloc().

Referenced by uv_os_get_passwd(), and uv_os_homedir().

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__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_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_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_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__loop_alive()

static int uv__loop_alive ( const uv_loop_t *  loop )

static

Definition at line 353 of file core.c.

                                                 {
  return uv__has_active_handles(loop) ||
         uv__has_active_reqs(loop) ||
         loop->closing_handles != NULL;
}

References loop, NULL, uv__has_active_handles, and uv__has_active_reqs.

Referenced by uv_loop_alive(), and uv_run().

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__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__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_closing_handles()

static void uv__run_closing_handles ( uv_loop_t *  loop )

static

Definition at line 308 of file core.c.

                                                     {
  uv_handle_t* p;
  uv_handle_t* q;
 
  p = loop->closing_handles;
  loop->closing_handles = NULL;
 
  while (p) {
    q = p->next_closing;
    uv__finish_close(p);
    p = q;
  }
}

References loop, NULL, p, and uv__finish_close().

Referenced by uv_run().

uv__run_pending()

static int uv__run_pending ( uv_loop_t *  loop )

static

Definition at line 797 of file core.c.

                                            {
  QUEUE* q;
  QUEUE pq;
  uv__io_t* w;
 
  if (QUEUE_EMPTY(&loop->pending_queue))
    return 0;
 
  QUEUE_MOVE(&loop->pending_queue, &pq);
 
  while (!QUEUE_EMPTY(&pq)) {
    q = QUEUE_HEAD(&pq);
    QUEUE_REMOVE(q);
    QUEUE_INIT(q);
    w = QUEUE_DATA(q, uv__io_t, pending_queue);
    w->cb(loop, w, POLLOUT);
  }
 
  return 1;
}

References loop, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_INIT, QUEUE_MOVE, QUEUE_REMOVE, and w.

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__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__socket_sockopt()

int uv__socket_sockopt	(	uv_handle_t *	handle,
		int	optname,
		int *	value
	)

Definition at line 180 of file core.c.

                                                                     {
  int r;
  int fd;
  socklen_t len;
 
  if (handle == NULL || value == NULL)
    return UV_EINVAL;
 
  if (handle->type == UV_TCP || handle->type == UV_NAMED_PIPE)
    fd = uv__stream_fd((uv_stream_t*) handle);
  else if (handle->type == UV_UDP)
    fd = ((uv_udp_t *) handle)->io_watcher.fd;
  else
    return UV_ENOTSUP;
 
  len = sizeof(*value);
 
  if (*value == 0)
    r = getsockopt(fd, SOL_SOCKET, optname, value, &len);
  else
    r = setsockopt(fd, SOL_SOCKET, optname, (const void*) value, len);
 
  if (r < 0)
    return UV__ERR(errno);
 
  return 0;
}

References fd, handle, len, NULL, r, SOL_SOCKET, UV__ERR, uv__stream_fd, and value.

Referenced by uv_recv_buffer_size(), and uv_send_buffer_size().

uv_backend_fd()

int uv_backend_fd

(

const uv_loop_t *

loop

)

Definition at line 328 of file core.c.

                                         {
  return loop->backend_fd;
}

uv_backend_timeout()

int uv_backend_timeout

(

const uv_loop_t *

loop

)

Definition at line 333 of file core.c.

                                              {
  if (loop->stop_flag != 0)
    return 0;
 
  if (!uv__has_active_handles(loop) && !uv__has_active_reqs(loop))
    return 0;
 
  if (!QUEUE_EMPTY(&loop->idle_handles))
    return 0;
 
  if (!QUEUE_EMPTY(&loop->pending_queue))
    return 0;
 
  if (loop->closing_handles)
    return 0;
 
  return uv__next_timeout(loop);
}

Referenced by uv_run().

uv_chdir()

int uv_chdir

(

const char *

dir

)

Definition at line 747 of file core.c.

                              {
  if (chdir(dir))
    return UV__ERR(errno);
 
  return 0;
}

uv_close()

void uv_close	(	uv_handle_t *	handle,
		uv_close_cb	close_cb
	)

Definition at line 108 of file core.c.

                                                         {
  assert(!uv__is_closing(handle));
 
  handle->flags |= UV_HANDLE_CLOSING;
  handle->close_cb = close_cb;
 
  switch (handle->type) {
  case UV_NAMED_PIPE:
    uv__pipe_close((uv_pipe_t*)handle);
    break;
 
  case UV_TTY:
    uv__stream_close((uv_stream_t*)handle);
    break;
 
  case UV_TCP:
    uv__tcp_close((uv_tcp_t*)handle);
    break;
 
  case UV_UDP:
    uv__udp_close((uv_udp_t*)handle);
    break;
 
  case UV_PREPARE:
    uv__prepare_close((uv_prepare_t*)handle);
    break;
 
  case UV_CHECK:
    uv__check_close((uv_check_t*)handle);
    break;
 
  case UV_IDLE:
    uv__idle_close((uv_idle_t*)handle);
    break;
 
  case UV_ASYNC:
    uv__async_close((uv_async_t*)handle);
    break;
 
  case UV_TIMER:
    uv__timer_close((uv_timer_t*)handle);
    break;
 
  case UV_PROCESS:
    uv__process_close((uv_process_t*)handle);
    break;
 
  case UV_FS_EVENT:
    uv__fs_event_close((uv_fs_event_t*)handle);
    break;
 
  case UV_POLL:
    uv__poll_close((uv_poll_t*)handle);
    break;
 
  case UV_FS_POLL:
    uv__fs_poll_close((uv_fs_poll_t*)handle);
    /* Poll handles use file system requests, and one of them may still be
     * running. The poll code will call uv__make_close_pending() for us. */
    return;
 
  case UV_SIGNAL:
    uv__signal_close((uv_signal_t*) handle);
    break;
 
  default:
    assert(0);
  }
 
  uv__make_close_pending(handle);
}

uv_cwd()

int uv_cwd	(	char *	buffer,
		size_t *	size
	)

Definition at line 708 of file core.c.

                                       {
  char scratch[1 + UV__PATH_MAX];
 
  if (buffer == NULL || size == NULL)
    return UV_EINVAL;
 
  /* Try to read directly into the user's buffer first... */
  if (getcwd(buffer, *size) != NULL)
    goto fixup;
 
  if (errno != ERANGE)
    return UV__ERR(errno);
 
  /* ...or into scratch space if the user's buffer is too small
   * so we can report how much space to provide on the next try.
   */
  if (getcwd(scratch, sizeof(scratch)) == NULL)
    return UV__ERR(errno);
 
  buffer = scratch;
 
fixup:
 
  *size = strlen(buffer);
 
  if (*size > 1 && buffer[*size - 1] == '/') {
    *size -= 1;
    buffer[*size] = '\0';
  }
 
  if (buffer == scratch) {
    *size += 1;
    return UV_ENOBUFS;
  }
 
  return 0;
}

uv_disable_stdio_inheritance()

void uv_disable_stdio_inheritance

(

void

)

Definition at line 755 of file core.c.

                                        {
  int fd;
 
  /* Set the CLOEXEC flag on all open descriptors. Unconditionally try the
   * first 16 file descriptors. After that, bail out after the first error.
   */
  for (fd = 0; ; fd++)
    if (uv__cloexec(fd, 1) && fd > 15)
      break;
}

uv_fileno()

int uv_fileno	(	const uv_handle_t *	handle,
		uv_os_fd_t *	fd
	)

Definition at line 767 of file core.c.

                                                         {
  int fd_out;
 
  switch (handle->type) {
  case UV_TCP:
  case UV_NAMED_PIPE:
  case UV_TTY:
    fd_out = uv__stream_fd((uv_stream_t*) handle);
    break;
 
  case UV_UDP:
    fd_out = ((uv_udp_t *) handle)->io_watcher.fd;
    break;
 
  case UV_POLL:
    fd_out = ((uv_poll_t *) handle)->io_watcher.fd;
    break;
 
  default:
    return UV_EINVAL;
  }
 
  if (uv__is_closing(handle) || fd_out == -1)
    return UV_EBADF;
 
  *fd = fd_out;
  return 0;
}

Referenced by uv__getsockpeername().

uv_get_osfhandle()

uv_os_fd_t uv_get_osfhandle

(

int

fd

)

Definition at line 1389 of file core.c.

                                    {
  return fd;
}

uv_getrusage()

int uv_getrusage

(

uv_rusage_t *

rusage

)

Definition at line 970 of file core.c.

                                      {
  struct rusage usage;
 
  if (getrusage(RUSAGE_SELF, &usage))
    return UV__ERR(errno);
 
  rusage->ru_utime.tv_sec = usage.ru_utime.tv_sec;
  rusage->ru_utime.tv_usec = usage.ru_utime.tv_usec;
 
  rusage->ru_stime.tv_sec = usage.ru_stime.tv_sec;
  rusage->ru_stime.tv_usec = usage.ru_stime.tv_usec;
 
#if !defined(__MVS__) && !defined(__HAIKU__)
  rusage->ru_maxrss = usage.ru_maxrss;
  rusage->ru_ixrss = usage.ru_ixrss;
  rusage->ru_idrss = usage.ru_idrss;
  rusage->ru_isrss = usage.ru_isrss;
  rusage->ru_minflt = usage.ru_minflt;
  rusage->ru_majflt = usage.ru_majflt;
  rusage->ru_nswap = usage.ru_nswap;
  rusage->ru_inblock = usage.ru_inblock;
  rusage->ru_oublock = usage.ru_oublock;
  rusage->ru_msgsnd = usage.ru_msgsnd;
  rusage->ru_msgrcv = usage.ru_msgrcv;
  rusage->ru_nsignals = usage.ru_nsignals;
  rusage->ru_nvcsw = usage.ru_nvcsw;
  rusage->ru_nivcsw = usage.ru_nivcsw;
#endif
 
  return 0;
}

uv_gettimeofday()

int uv_gettimeofday

(

uv_timeval64_t *

tv

)

Definition at line 1512 of file core.c.

                                        {
  struct timeval time;
 
  if (tv == NULL)
    return UV_EINVAL;
 
  if (gettimeofday(&time, NULL) != 0)
    return UV__ERR(errno);
 
  tv->tv_sec = (int64_t) time.tv_sec;
  tv->tv_usec = (int32_t) time.tv_usec;
  return 0;
}

uv_hrtime()

uint64_t uv_hrtime

(

void

)

Definition at line 103 of file core.c.

                         {
  return uv__hrtime(UV_CLOCK_PRECISE);
}

uv_is_active()

int uv_is_active

(

const uv_handle_t *

handle

)

Definition at line 430 of file core.c.

                                            {
  return uv__is_active(handle);
}

uv_is_closing()

int uv_is_closing

(

const uv_handle_t *

handle

)

Definition at line 323 of file core.c.

                                             {
  return uv__is_closing(handle);
}

Referenced by uv_fileno().

uv_loop_alive()

int uv_loop_alive

(

const uv_loop_t *

loop

)

Definition at line 360 of file core.c.

                                         {
    return uv__loop_alive(loop);
}

uv_open_osfhandle()

int uv_open_osfhandle

(

uv_os_fd_t

os_fd

)

Definition at line 1393 of file core.c.

                                        {
  return os_fd;
}

uv_os_environ()

int uv_os_environ	(	uv_env_item_t **	envitems,
		int *	count
	)

Definition at line 1255 of file core.c.

                                                        {
  int i, j, cnt;
  uv_env_item_t* envitem;
 
  *envitems = NULL;
  *count = 0;
 
  for (i = 0; environ[i] != NULL; i++);
 
  *envitems = uv__calloc(i, sizeof(**envitems));
 
  if (*envitems == NULL)
    return UV_ENOMEM;
 
  for (j = 0, cnt = 0; j < i; j++) {
    char* buf;
    char* ptr;
 
    if (environ[j] == NULL)
      break;
 
    buf = uv__strdup(environ[j]);
    if (buf == NULL)
      goto fail;
 
    ptr = strchr(buf, '=');
    if (ptr == NULL) {
      uv__free(buf);
      continue;
    }
 
    *ptr = '\0';
 
    envitem = &(*envitems)[cnt];
    envitem->name = buf;
    envitem->value = ptr + 1;
 
    cnt++;
  }
 
  *count = cnt;
  return 0;
 
fail:
  for (i = 0; i < cnt; i++) {
    envitem = &(*envitems)[cnt];
    uv__free(envitem->name);
  }
  uv__free(*envitems);
 
  *envitems = NULL;
  *count = 0;
  return UV_ENOMEM;
}

uv_os_free_passwd()

void uv_os_free_passwd

(

uv_passwd_t *

pwd

)

Definition at line 1228 of file core.c.

                                         {
  if (pwd == NULL)
    return;
 
  /*
    The memory for name, shell, and homedir are allocated in a single
    uv__malloc() call. The base of the pointer is stored in pwd->username, so
    that is the field that needs to be freed.
  */
  uv__free(pwd->username);
  pwd->username = NULL;
  pwd->shell = NULL;
  pwd->homedir = NULL;
}

Referenced by uv_os_homedir().

uv_os_get_passwd()

int uv_os_get_passwd

(

uv_passwd_t *

pwd

)

Definition at line 1244 of file core.c.

                                       {
  return uv__getpwuid_r(pwd);
}

uv_os_getenv()

int uv_os_getenv	(	const char *	name,
		char *	buffer,
		size_t *	size
	)

Definition at line 1311 of file core.c.

                                                               {
  char* var;
  size_t len;
 
  if (name == NULL || buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
  var = getenv(name);
 
  if (var == NULL)
    return UV_ENOENT;
 
  len = strlen(var);
 
  if (len >= *size) {
    *size = len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, var, len + 1);
  *size = len;
 
  return 0;
}

Referenced by uv_os_homedir().

uv_os_gethostname()

int uv_os_gethostname	(	char *	buffer,
		size_t *	size
	)

Definition at line 1359 of file core.c.

                                                  {
  /*
    On some platforms, if the input buffer is not large enough, gethostname()
    succeeds, but truncates the result. libuv can detect this and return ENOBUFS
    instead by creating a large enough buffer and comparing the hostname length
    to the size input.
  */
  char buf[UV_MAXHOSTNAMESIZE];
  size_t len;
 
  if (buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
  if (gethostname(buf, sizeof(buf)) != 0)
    return UV__ERR(errno);
 
  buf[sizeof(buf) - 1] = '\0'; /* Null terminate, just to be safe. */
  len = strlen(buf);
 
  if (len >= *size) {
    *size = len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, buf, len + 1);
  *size = len;
  return 0;
}

uv_os_getpid()

uv_pid_t uv_os_getpid

(

void

)

Definition at line 1397 of file core.c.

                            {
  return getpid();
}

uv_os_getppid()

uv_pid_t uv_os_getppid

(

void

)

Definition at line 1402 of file core.c.

                             {
  return getppid();
}

uv_os_getpriority()

int uv_os_getpriority	(	uv_pid_t	pid,
		int *	priority
	)

Definition at line 1407 of file core.c.

                                                   {
  int r;
 
  if (priority == NULL)
    return UV_EINVAL;
 
  errno = 0;
  r = getpriority(PRIO_PROCESS, (int) pid);
 
  if (r == -1 && errno != 0)
    return UV__ERR(errno);
 
  *priority = r;
  return 0;
}

uv_os_homedir()

int uv_os_homedir	(	char *	buffer,
		size_t *	size
	)

Definition at line 1059 of file core.c.

                                              {
  uv_passwd_t pwd;
  size_t len;
  int r;
 
  /* Check if the HOME environment variable is set first. The task of
     performing input validation on buffer and size is taken care of by
     uv_os_getenv(). */
  r = uv_os_getenv("HOME", buffer, size);
 
  if (r != UV_ENOENT)
    return r;
 
  /* HOME is not set, so call uv__getpwuid_r() */
  r = uv__getpwuid_r(&pwd);
 
  if (r != 0) {
    return r;
  }
 
  len = strlen(pwd.homedir);
 
  if (len >= *size) {
    *size = len + 1;
    uv_os_free_passwd(&pwd);
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, pwd.homedir, len + 1);
  *size = len;
  uv_os_free_passwd(&pwd);
 
  return 0;
}

uv_os_setenv()

int uv_os_setenv	(	const char *	name,
		const char *	value
	)

Definition at line 1337 of file core.c.

                                                      {
  if (name == NULL || value == NULL)
    return UV_EINVAL;
 
  if (setenv(name, value, 1) != 0)
    return UV__ERR(errno);
 
  return 0;
}

uv_os_setpriority()

int uv_os_setpriority	(	uv_pid_t	pid,
		int	priority
	)

Definition at line 1424 of file core.c.

                                                  {
  if (priority < UV_PRIORITY_HIGHEST || priority > UV_PRIORITY_LOW)
    return UV_EINVAL;
 
  if (setpriority(PRIO_PROCESS, (int) pid, priority) != 0)
    return UV__ERR(errno);
 
  return 0;
}

uv_os_tmpdir()

int uv_os_tmpdir	(	char *	buffer,
		size_t *	size
	)

Definition at line 1095 of file core.c.

                                             {
  const char* buf;
  size_t len;
 
  if (buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
#define CHECK_ENV_VAR(name)                                                   \
  do {                                                                        \
    buf = getenv(name);                                                       \
    if (buf != NULL)                                                          \
      goto return_buffer;                                                     \
  }                                                                           \
  while (0)
 
  /* Check the TMPDIR, TMP, TEMP, and TEMPDIR environment variables in order */
  CHECK_ENV_VAR("TMPDIR");
  CHECK_ENV_VAR("TMP");
  CHECK_ENV_VAR("TEMP");
  CHECK_ENV_VAR("TEMPDIR");
 
#undef CHECK_ENV_VAR
 
  /* No temp environment variables defined */
  #if defined(__ANDROID__)
    buf = "/data/local/tmp";
  #else
    buf = "/tmp";
  #endif
 
return_buffer:
  len = strlen(buf);
 
  if (len >= *size) {
    *size = len + 1;
    return UV_ENOBUFS;
  }
 
  /* The returned directory should not have a trailing slash. */
  if (len > 1 && buf[len - 1] == '/') {
    len--;
  }
 
  memcpy(buffer, buf, len + 1);
  buffer[len] = '\0';
  *size = len;
 
  return 0;
}

uv_os_uname()

int uv_os_uname

(

uv_utsname_t *

buffer

)

Definition at line 1435 of file core.c.

                                      {
  struct utsname buf;
  int r;
 
  if (buffer == NULL)
    return UV_EINVAL;
 
  if (uname(&buf) == -1) {
    r = UV__ERR(errno);
    goto error;
  }
 
  r = uv__strscpy(buffer->sysname, buf.sysname, sizeof(buffer->sysname));
  if (r == UV_E2BIG)
    goto error;
 
#ifdef _AIX
  r = snprintf(buffer->release,
               sizeof(buffer->release),
               "%s.%s",
               buf.version,
               buf.release);
  if (r >= sizeof(buffer->release)) {
    r = UV_E2BIG;
    goto error;
  }
#else
  r = uv__strscpy(buffer->release, buf.release, sizeof(buffer->release));
  if (r == UV_E2BIG)
    goto error;
#endif
 
  r = uv__strscpy(buffer->version, buf.version, sizeof(buffer->version));
  if (r == UV_E2BIG)
    goto error;
 
#if defined(_AIX) || defined(__PASE__)
  r = uv__strscpy(buffer->machine, "ppc64", sizeof(buffer->machine));
#else
  r = uv__strscpy(buffer->machine, buf.machine, sizeof(buffer->machine));
#endif
 
  if (r == UV_E2BIG)
    goto error;
 
  return 0;
 
error:
  buffer->sysname[0] = '\0';
  buffer->release[0] = '\0';
  buffer->version[0] = '\0';
  buffer->machine[0] = '\0';
  return r;
}

uv_os_unsetenv()

int uv_os_unsetenv

(

const char *

name

)

Definition at line 1348 of file core.c.

                                     {
  if (name == NULL)
    return UV_EINVAL;
 
  if (unsetenv(name) != 0)
    return UV__ERR(errno);
 
  return 0;
}

uv_run()

int uv_run	(	uv_loop_t *	loop,
		uv_run_mode	mode
	)

Definition at line 365 of file core.c.

                                              {
  int timeout;
  int r;
  int ran_pending;
 
  r = uv__loop_alive(loop);
  if (!r)
    uv__update_time(loop);
 
  while (r != 0 && loop->stop_flag == 0) {
    uv__update_time(loop);
    uv__run_timers(loop);
    ran_pending = uv__run_pending(loop);
    uv__run_idle(loop);
    uv__run_prepare(loop);
 
    timeout = 0;
    if ((mode == UV_RUN_ONCE && !ran_pending) || mode == UV_RUN_DEFAULT)
      timeout = uv_backend_timeout(loop);
 
    uv__io_poll(loop, timeout);
 
    /* Run one final update on the provider_idle_time in case uv__io_poll
     * returned because the timeout expired, but no events were received. This
     * call will be ignored if the provider_entry_time was either never set (if
     * the timeout == 0) or was already updated b/c an event was received.
     */
    uv__metrics_update_idle_time(loop);
 
    uv__run_check(loop);
    uv__run_closing_handles(loop);
 
    if (mode == UV_RUN_ONCE) {
      /* UV_RUN_ONCE implies forward progress: at least one callback must have
       * been invoked when it returns. uv__io_poll() can return without doing
       * I/O (meaning: no callbacks) when its timeout expires - which means we
       * have pending timers that satisfy the forward progress constraint.
       *
       * UV_RUN_NOWAIT makes no guarantees about progress so it's omitted from
       * the check.
       */
      uv__update_time(loop);
      uv__run_timers(loop);
    }
 
    r = uv__loop_alive(loop);
    if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT)
      break;
  }
 
  /* The if statement lets gcc compile it to a conditional store. Avoids
   * dirtying a cache line.
   */
  if (loop->stop_flag != 0)
    loop->stop_flag = 0;
 
  return r;
}

uv_sleep()

void uv_sleep

(

unsigned int

msec

)

Definition at line 1526 of file core.c.

                                 {
  struct timespec timeout;
  int rc;
 
  timeout.tv_sec = msec / 1000;
  timeout.tv_nsec = (msec % 1000) * 1000 * 1000;
 
  do
    rc = nanosleep(&timeout, &timeout);
  while (rc == -1 && errno == EINTR);
 
  assert(rc == 0);
}

uv_translate_sys_error()

int uv_translate_sys_error

(

int

sys_errno

)

Definition at line 1249 of file core.c.

                                          {
  /* If < 0 then it's already a libuv error. */
  return sys_errno <= 0 ? sys_errno : -sys_errno;
}

Referenced by uv__getsockpeername(), uv__socket_sockopt(), and uv_loop_init().

uv_update_time()

void uv_update_time

(

uv_loop_t *

loop

)

Definition at line 425 of file core.c.

                                     {
  uv__update_time(loop);
}

Referenced by uv__poll(), uv__poll_wine(), uv_loop_init(), and uv_run().

Variable Documentation

environ

char** environ

extern

Referenced by create_child_env(), rz_sys_clearenv(), rz_sys_get_environ(), rz_sys_set_environ(), and uv_os_environ().