uv-common.c File Reference

#include "uv.h"
#include "uv-common.h"
#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <net/if.h>
#include <sys/un.h>

Go to the source code of this file.

Classes
struct	uv__allocator_t

Macros
#define	XX(uc, lc)   case UV_##uc: return sizeof(uv_##lc##_t);
#define	UV_ERR_NAME_GEN_R(name, _)
#define	UV_ERR_NAME_GEN(name, _)   case UV_ ## name: return #name;
#define	UV_STRERROR_GEN_R(name, msg)
#define	UV_STRERROR_GEN(name, msg)   case UV_ ## name: return msg;
#define	X(uc, lc)   case UV_##uc: type = #lc; break;
#define	uv__fs_scandir_free   free

Functions
char *	uv__strdup (const char *s)
char *	uv__strndup (const char *s, size_t n)
void *	uv__malloc (size_t size)
void	uv__free (void *ptr)
void *	uv__calloc (size_t count, size_t size)
void *	uv__realloc (void *ptr, size_t size)
void *	uv__reallocf (void *ptr, size_t size)
int	uv_replace_allocator (uv_malloc_func malloc_func, uv_realloc_func realloc_func, uv_calloc_func calloc_func, uv_free_func free_func)
size_t	uv_handle_size (uv_handle_type type)
size_t	uv_req_size (uv_req_type type)
size_t	uv_loop_size (void)
uv_buf_t	uv_buf_init (char *base, unsigned int len)
static const char *	uv__unknown_err_code (int err)
char *	uv_err_name_r (int err, char *buf, size_t buflen)
const char *	uv_err_name (int err)
char *	uv_strerror_r (int err, char *buf, size_t buflen)
const char *	uv_strerror (int err)
int	uv_ip4_addr (const char *ip, int port, struct sockaddr_in *addr)
int	uv_ip6_addr (const char *ip, int port, struct sockaddr_in6 *addr)
int	uv_ip4_name (const struct sockaddr_in *src, char *dst, size_t size)
int	uv_ip6_name (const struct sockaddr_in6 *src, char *dst, size_t size)
int	uv_tcp_bind (uv_tcp_t *handle, const struct sockaddr *addr, unsigned int flags)
int	uv_udp_init_ex (uv_loop_t *loop, uv_udp_t *handle, unsigned flags)
int	uv_udp_init (uv_loop_t *loop, uv_udp_t *handle)
int	uv_udp_bind (uv_udp_t *handle, const struct sockaddr *addr, unsigned int flags)
int	uv_tcp_connect (uv_connect_t *req, uv_tcp_t *handle, const struct sockaddr *addr, uv_connect_cb cb)
int	uv_udp_connect (uv_udp_t *handle, const struct sockaddr *addr)
int	uv__udp_is_connected (uv_udp_t *handle)
int	uv__udp_check_before_send (uv_udp_t *handle, const struct sockaddr *addr)
int	uv_udp_send (uv_udp_send_t *req, uv_udp_t *handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr *addr, uv_udp_send_cb send_cb)
int	uv_udp_try_send (uv_udp_t *handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr *addr)
int	uv_udp_recv_start (uv_udp_t *handle, uv_alloc_cb alloc_cb, uv_udp_recv_cb recv_cb)
int	uv_udp_recv_stop (uv_udp_t *handle)
void	uv_walk (uv_loop_t *loop, uv_walk_cb walk_cb, void *arg)
static void	uv__print_handles (uv_loop_t *loop, int only_active, FILE *stream)
void	uv_print_all_handles (uv_loop_t *loop, FILE *stream)
void	uv_print_active_handles (uv_loop_t *loop, FILE *stream)
void	uv_ref (uv_handle_t *handle)
void	uv_unref (uv_handle_t *handle)
int	uv_has_ref (const uv_handle_t *handle)
void	uv_stop (uv_loop_t *loop)
uint64_t	uv_now (const uv_loop_t *loop)
size_t	uv__count_bufs (const uv_buf_t bufs[], unsigned int nbufs)
int	uv_recv_buffer_size (uv_handle_t *handle, int *value)
int	uv_send_buffer_size (uv_handle_t *handle, int *value)
int	uv_fs_event_getpath (uv_fs_event_t *handle, char *buffer, size_t *size)
static unsigned int *	uv__get_nbufs (uv_fs_t *req)
void	uv__fs_scandir_cleanup (uv_fs_t *req)
int	uv_fs_scandir_next (uv_fs_t *req, uv_dirent_t *ent)
uv_dirent_type_t	uv__fs_get_dirent_type (uv__dirent_t *dent)
void	uv__fs_readdir_cleanup (uv_fs_t *req)
int	uv_loop_configure (uv_loop_t *loop, uv_loop_option option,...)
uv_loop_t *	uv_default_loop (void)
uv_loop_t *	uv_loop_new (void)
int	uv_loop_close (uv_loop_t *loop)
void	uv_loop_delete (uv_loop_t *loop)
void	uv_os_free_environ (uv_env_item_t *envitems, int count)
void	uv_free_cpu_info (uv_cpu_info_t *cpu_infos, int count)
void	uv_library_shutdown (void)
void	uv__metrics_update_idle_time (uv_loop_t *loop)
void	uv__metrics_set_provider_entry_time (uv_loop_t *loop)
uint64_t	uv_metrics_idle_time (uv_loop_t *loop)

Variables
static uv__allocator_t	uv__allocator
static uv_loop_t	default_loop_struct
static uv_loop_t *	default_loop_ptr

Macro Definition Documentation

uv__fs_scandir_free

#define uv__fs_scandir_free   free

Definition at line 632 of file uv-common.c.

UV_ERR_NAME_GEN

#define UV_ERR_NAME_GEN	(		name,
			_
	)		case UV_ ## name: return #name;

Definition at line 188 of file uv-common.c.

UV_ERR_NAME_GEN_R

#define UV_ERR_NAME_GEN_R	(		name,
			_
	)

Value:

case UV_## name: \
  uv__strscpy(buf, #name, buflen); break;

Definition at line 175 of file uv-common.c.

UV_STRERROR_GEN

#define UV_STRERROR_GEN	(		name,
			msg
	)		case UV_ ## name: return msg;

Definition at line 211 of file uv-common.c.

UV_STRERROR_GEN_R

#define UV_STRERROR_GEN_R	(		name,
			msg
	)

Value:

case UV_ ## name: \
  snprintf(buf, buflen, "%s", msg); break;

Definition at line 198 of file uv-common.c.

X

#define X	(		uc,
			lc
	)		case UV_##uc: type = #lc; break;

XX

#define XX	(		uc,
			lc
	)		case UV_##uc: return sizeof(uv_##lc##_t);

Definition at line 131 of file uv-common.c.

Function Documentation

uv__calloc()

void* uv__calloc	(	size_t	count,
		size_t	size
	)

Definition at line 92 of file uv-common.c.

                                            {
  return uv__allocator.local_calloc(count, size);
}

References count, uv__allocator_t::local_calloc, and uv__allocator.

Referenced by uv__interface_addresses_v6(), uv__pipe_write_ipc(), uv_cpu_info(), uv_fs_poll_start(), uv_interface_addresses(), uv_loop_init(), and uv_os_environ().

uv__count_bufs()

size_t uv__count_bufs	(	const uv_buf_t	bufs[],
		unsigned int	nbufs
	)

Definition at line 573 of file uv-common.c.

                                                                 {
  unsigned int i;
  size_t bytes;
 
  bytes = 0;
  for (i = 0; i < nbufs; i++)
    bytes += (size_t) bufs[i].len;
 
  return bytes;
}

References bufs, bytes, and i.

Referenced by uv__send(), uv__tty_try_write(), uv__udp_run_completed(), uv__udp_send(), uv__write_req_size(), uv_tcp_write(), uv_try_write(), and uv_write2().

uv__free()

void uv__free

(

void *

ptr

)

Definition at line 81 of file uv-common.c.

                         {
  int saved_errno;
 
  /* Libuv expects that free() does not clobber errno.  The system allocator
   * honors that assumption but custom allocators may not be so careful.
   */
  saved_errno = errno;
  uv__allocator.local_free(ptr);
  errno = saved_errno;
}

References uv__allocator_t::local_free, and uv__allocator.

Referenced by child_fork(), eof_timer_close_cb(), epoll_queue_close(), freeifaddrs(), freeResultList(), fs__closedir(), fs__create_junction(), fs__opendir(), fs__readdir(), fs__realpath_handle(), fs__scandir(), fs__sendfile(), fs__statfs(), getNetlinkResponse(), make_program_args(), make_program_env(), maybe_free_watcher_list(), os390_readlink(), scandir(), search_path_join_test(), timer_close_cb(), uv__convert_utf16_to_utf8(), uv__convert_utf8_to_utf16(), uv__custom_sem_destroy(), uv__custom_sem_init(), uv__dlerror(), uv__fd_hash_remove(), uv__fs_closedir(), uv__fs_opendir(), uv__fs_read(), uv__fs_readdir(), uv__fs_readdir_cleanup(), uv__fs_readlink(), uv__fs_realpath(), uv__fs_write_all(), uv__getaddrinfo_done(), uv__getpwuid_r(), uv__inotify_fork(), uv__io_fork(), uv__loop_close(), uv__loops_remove(), uv__pipe_close(), uv__pipe_getname(), uv__pipe_write_ipc(), uv__platform_loop_delete(), uv__process_title_cleanup(), uv__realloc(), uv__reallocf(), uv__search_path(), uv__stdio_destroy(), uv__stream_close(), uv__thread_start(), uv__threadpool_cleanup(), uv__udp_run_completed(), uv__write_callbacks(), uv__write_req_finish(), uv_accept(), uv_barrier_destroy(), uv_barrier_init(), uv_chdir(), uv_cpu_info(), uv_cwd(), uv_dlclose(), uv_exepath(), uv_free_cpu_info(), uv_free_interface_addresses(), uv_freeaddrinfo(), uv_fs_event_endgame(), uv_fs_event_start(), uv_fs_event_stop(), uv_fs_poll_start(), uv_fs_req_cleanup(), uv_getaddrinfo(), uv_interface_addresses(), uv_loop_delete(), uv_loop_init(), uv_loop_new(), uv_os_environ(), uv_os_free_environ(), uv_os_free_passwd(), uv_os_getenv(), uv_os_setenv(), uv_os_tmpdir(), uv_os_unsetenv(), uv_pipe_accept(), uv_pipe_bind(), uv_pipe_chmod(), uv_pipe_cleanup(), uv_pipe_connect(), uv_pipe_endgame(), uv_process_fs_event_req(), uv_process_pipe_write_req(), uv_set_process_title(), uv_spawn(), uv_split_path(), uv_tcp_endgame(), uv_thread_create_ex(), uv_try_write(), and uv_uptime().

uv__fs_get_dirent_type()

uv_dirent_type_t uv__fs_get_dirent_type

(

uv__dirent_t *

dent

)

Definition at line 688 of file uv-common.c.

                                                            {
  uv_dirent_type_t type;
 
#ifdef HAVE_DIRENT_TYPES
  switch (dent->d_type) {
    case UV__DT_DIR:
      type = UV_DIRENT_DIR;
      break;
    case UV__DT_FILE:
      type = UV_DIRENT_FILE;
      break;
    case UV__DT_LINK:
      type = UV_DIRENT_LINK;
      break;
    case UV__DT_FIFO:
      type = UV_DIRENT_FIFO;
      break;
    case UV__DT_SOCKET:
      type = UV_DIRENT_SOCKET;
      break;
    case UV__DT_CHAR:
      type = UV_DIRENT_CHAR;
      break;
    case UV__DT_BLOCK:
      type = UV_DIRENT_BLOCK;
      break;
    default:
      type = UV_DIRENT_UNKNOWN;
  }
#else
  type = UV_DIRENT_UNKNOWN;
#endif
 
  return type;
}

References type, UV__DT_BLOCK, UV__DT_CHAR, UV__DT_DIR, UV__DT_FIFO, UV__DT_FILE, UV__DT_LINK, UV__DT_SOCKET, UV_DIRENT_BLOCK, UV_DIRENT_CHAR, UV_DIRENT_DIR, UV_DIRENT_FIFO, UV_DIRENT_FILE, UV_DIRENT_LINK, UV_DIRENT_SOCKET, and UV_DIRENT_UNKNOWN.

Referenced by fs__readdir(), uv__fs_readdir(), and uv_fs_scandir_next().

uv__fs_readdir_cleanup()

void uv__fs_readdir_cleanup

(

uv_fs_t *

req

)

Definition at line 724 of file uv-common.c.

                                          {
  uv_dir_t* dir;
  uv_dirent_t* dirents;
  int i;
 
  if (req->ptr == NULL)
    return;
 
  dir = req->ptr;
  dirents = dir->dirents;
  req->ptr = NULL;
 
  if (dirents == NULL)
    return;
 
  for (i = 0; i < req->result; ++i) {
    uv__free((char*) dirents[i].name);
    dirents[i].name = NULL;
  }
}

References uv_dir_s::dirents, i, uv_dirent_s::name, NULL, req, and uv__free().

Referenced by uv_fs_req_cleanup().

uv__fs_scandir_cleanup()

void uv__fs_scandir_cleanup

(

uv_fs_t *

req

)

Definition at line 635 of file uv-common.c.

                                          {
  uv__dirent_t** dents;
 
  unsigned int* nbufs = uv__get_nbufs(req);
 
  dents = req->ptr;
  if (*nbufs > 0 && *nbufs != (unsigned int) req->result)
    (*nbufs)--;
  for (; *nbufs < (unsigned int) req->result; (*nbufs)++)
    uv__fs_scandir_free(dents[*nbufs]);
 
  uv__fs_scandir_free(req->ptr);
  req->ptr = NULL;
}

References int, NULL, req, uv__fs_scandir_free, and uv__get_nbufs().

Referenced by uv_fs_req_cleanup().

uv__get_nbufs()

static unsigned int* uv__get_nbufs ( uv_fs_t *  req )

static

Definition at line 617 of file uv-common.c.

                                                 {
#ifdef _WIN32
  return &req->fs.info.nbufs;
#else
  return &req->nbufs;
#endif
}

References req.

Referenced by uv__fs_scandir_cleanup(), and uv_fs_scandir_next().

uv__malloc()

void* uv__malloc

(

size_t

size

)

Definition at line 75 of file uv-common.c.

                              {
  if (size > 0)
    return uv__allocator.local_malloc(size);
  return NULL;
}

References uv__allocator_t::local_malloc, NULL, and uv__allocator.

Referenced by eof_timer_init(), epoll_create1(), fs__capture_path(), fs__create_junction(), fs__opendir(), fs__realpath_handle(), fs__scandir(), fs__sendfile(), fs__statfs(), fs__wide_to_utf8(), getNetlinkResponse(), init_threads(), interpretAddr(), interpretLink(), make_program_args(), make_program_env(), newListItem(), os390_readlink(), scandir(), search_path_join_test(), uv__build_coalesced_write_req(), uv__convert_utf16_to_utf8(), uv__convert_utf8_to_utf16(), uv__custom_sem_init(), uv__fd_hash_add(), uv__fs_opendir(), uv__fs_readlink(), uv__fs_realpath(), uv__fs_statfs(), uv__getaddrinfo_done(), uv__getpwuid_r(), uv__interface_addresses_v6(), uv__pipe_getname(), uv__pipe_queue_ipc_xfer_info(), uv__stdio_create(), uv__strdup(), uv__stream_queue_fd(), uv__strndup(), uv__udp_send(), uv_barrier_init(), uv_chdir(), uv_cpu_info(), uv_cwd(), uv_exepath(), uv_fs_event_start(), uv_fs_read(), uv_fs_write(), uv_getaddrinfo(), uv_interface_addresses(), uv_loop_init(), uv_loop_new(), uv_os_getenv(), uv_os_tmpdir(), uv_pipe_bind(), uv_pipe_chmod(), uv_pipe_connect(), uv_process_fs_event_req(), uv_relative_path(), uv_set_process_title(), uv_setup_args(), uv_spawn(), uv_split_path(), uv_tcp_listen(), uv_thread_create_ex(), uv_uptime(), uv_utf8_to_utf16_alloc(), and uv_write2().

uv__metrics_set_provider_entry_time()

void uv__metrics_set_provider_entry_time

(

uv_loop_t *

loop

)

Definition at line 899 of file uv-common.c.

                                                          {
  uv__loop_metrics_t* loop_metrics;
  uint64_t now;
 
  if (!(uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME))
    return;
 
  now = uv_hrtime();
  loop_metrics = uv__get_loop_metrics(loop);
  uv_mutex_lock(&loop_metrics->lock);
  loop_metrics->provider_entry_time = now;
  uv_mutex_unlock(&loop_metrics->lock);
}

References flags, uv__loop_metrics_s::lock, loop, uv__loop_metrics_s::provider_entry_time, uv__get_internal_fields, uv__get_loop_metrics, uv_hrtime(), UV_METRICS_IDLE_TIME, uv_mutex_lock(), and uv_mutex_unlock().

Referenced by uv__io_poll(), uv__poll(), and uv__poll_wine().

uv__metrics_update_idle_time()

void uv__metrics_update_idle_time

(

uv_loop_t *

loop

)

Definition at line 872 of file uv-common.c.

                                                   {
  uv__loop_metrics_t* loop_metrics;
  uint64_t entry_time;
  uint64_t exit_time;
 
  if (!(uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME))
    return;
 
  loop_metrics = uv__get_loop_metrics(loop);
 
  /* The thread running uv__metrics_update_idle_time() is always the same
   * thread that sets provider_entry_time. So it's unnecessary to lock before
   * retrieving this value.
   */
  if (loop_metrics->provider_entry_time == 0)
    return;
 
  exit_time = uv_hrtime();
 
  uv_mutex_lock(&loop_metrics->lock);
  entry_time = loop_metrics->provider_entry_time;
  loop_metrics->provider_entry_time = 0;
  loop_metrics->provider_idle_time += exit_time - entry_time;
  uv_mutex_unlock(&loop_metrics->lock);
}

References flags, uv__loop_metrics_s::lock, loop, uv__loop_metrics_s::provider_entry_time, uv__loop_metrics_s::provider_idle_time, uv__get_internal_fields, uv__get_loop_metrics, uv_hrtime(), UV_METRICS_IDLE_TIME, uv_mutex_lock(), and uv_mutex_unlock().

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

uv__print_handles()

static void uv__print_handles ( uv_loop_t *  loop, int  only_active, FILE *  stream  )

static

Definition at line 505 of file uv-common.c.

                                                                              {
  const char* type;
  QUEUE* q;
  uv_handle_t* h;
 
  if (loop == NULL)
    loop = uv_default_loop();
 
  QUEUE_FOREACH(q, &loop->handle_queue) {
    h = QUEUE_DATA(q, uv_handle_t, handle_queue);
 
    if (only_active && !uv__is_active(h))
      continue;
 
    switch (h->type) {
#define X(uc, lc) case UV_##uc: type = #lc; break;
      UV_HANDLE_TYPE_MAP(X)
#undef X
      default: type = "<unknown>";
    }
 
    fprintf(stream,
            "[%c%c%c] %-8s %p\n",
            "R-"[!(h->flags & UV_HANDLE_REF)],
            "A-"[!(h->flags & UV_HANDLE_ACTIVE)],
            "I-"[!(h->flags & UV_HANDLE_INTERNAL)],
            type,
            (void*)h);
  }
}

References h, uv_loop_s::handle_queue, loop, NULL, QUEUE_DATA, QUEUE_FOREACH, type, uv__is_active, uv_default_loop(), UV_HANDLE_ACTIVE, UV_HANDLE_INTERNAL, UV_HANDLE_REF, UV_HANDLE_TYPE_MAP, and X.

Referenced by uv_print_active_handles(), and uv_print_all_handles().

uv__realloc()

void* uv__realloc	(	void *	ptr,
		size_t	size
	)

Definition at line 96 of file uv-common.c.

                                          {
  if (size > 0)
    return uv__allocator.local_realloc(ptr, size);
  uv__free(ptr);
  return NULL;
}

References uv__allocator_t::local_realloc, NULL, uv__allocator, and uv__free().

Referenced by fs__scandir(), scandir(), uv__loops_add(), uv__loops_remove(), uv__reallocf(), and uv__stream_queue_fd().

uv__reallocf()

void* uv__reallocf	(	void *	ptr,
		size_t	size
	)

Definition at line 103 of file uv-common.c.

                                           {
  void* newptr;
 
  newptr = uv__realloc(ptr, size);
  if (newptr == NULL)
    if (size > 0)
      uv__free(ptr);
 
  return newptr;
}

References NULL, uv__free(), and uv__realloc().

Referenced by fs__statfs(), maybe_resize(), uv__fs_readlink(), uv__pollfds_maybe_resize(), and uv_exepath().

uv__strdup()

char* uv__strdup

(

const char *

s

)

Definition at line 55 of file uv-common.c.

                                {
  size_t len = strlen(s) + 1;
  char* m = uv__malloc(len);
  if (m == NULL)
    return NULL;
  return memcpy(m, s, len);
}

References len, regress::m, memcpy(), NULL, s, and uv__malloc().

Referenced by uv__dlerror(), uv__fs_readdir(), uv__inotify_fork(), uv__interface_addresses_v6(), uv__search_path(), uv__unknown_err_code(), uv_cpu_info(), uv_fs_event_start(), uv_fs_mkdtemp(), uv_fs_mkstemp(), uv_interface_addresses(), uv_os_environ(), uv_pipe_bind(), uv_set_process_title(), and uv_setup_args().

uv__strndup()

char* uv__strndup	(	const char *	s,
		size_t	n
	)

Definition at line 63 of file uv-common.c.

                                           {
  char* m;
  size_t len = strlen(s);
  if (n < len)
    len = n;
  m = uv__malloc(len + 1);
  if (m == NULL)
    return NULL;
  m[len] = '\0';
  return memcpy(m, s, len);
}

References len, regress::m, memcpy(), n, NULL, s, and uv__malloc().

Referenced by read_models().

uv__udp_check_before_send()

int uv__udp_check_before_send	(	uv_udp_t *	handle,
		const struct sockaddr *	addr
	)

Definition at line 407 of file uv-common.c.

                                                                             {
  unsigned int addrlen;
 
  if (handle->type != UV_UDP)
    return UV_EINVAL;
 
  if (addr != NULL && (handle->flags & UV_HANDLE_UDP_CONNECTED))
    return UV_EISCONN;
 
  if (addr == NULL && !(handle->flags & UV_HANDLE_UDP_CONNECTED))
    return UV_EDESTADDRREQ;
 
  if (addr != NULL) {
    if (addr->sa_family == AF_INET)
      addrlen = sizeof(struct sockaddr_in);
    else if (addr->sa_family == AF_INET6)
      addrlen = sizeof(struct sockaddr_in6);
#if defined(AF_UNIX) && !defined(_WIN32)
    else if (addr->sa_family == AF_UNIX)
      addrlen = sizeof(struct sockaddr_un);
#endif
    else
      return UV_EINVAL;
  } else {
    addrlen = 0;
  }
 
  return addrlen;
}

References addr, addrlen, AF_INET, AF_INET6, AF_UNIX, handle, NULL, and UV_HANDLE_UDP_CONNECTED.

Referenced by uv_udp_send(), and uv_udp_try_send().

uv__udp_is_connected()

int uv__udp_is_connected

(

uv_udp_t *

handle

)

Definition at line 393 of file uv-common.c.

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

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

Referenced by uv_udp_open().

uv__unknown_err_code()

static const char* uv__unknown_err_code ( int  err )

static

Definition at line 165 of file uv-common.c.

                                                 {
  char buf[32];
  char* copy;
 
  snprintf(buf, sizeof(buf), "Unknown system error %d", err);
  copy = uv__strdup(buf);
 
  return copy != NULL ? copy : "Unknown system error";
}

References err, NULL, snprintf, and uv__strdup().

Referenced by uv_err_name(), and uv_strerror().

uv_buf_init()

uv_buf_t uv_buf_init	(	char *	base,
		unsigned int	len
	)

Definition at line 157 of file uv-common.c.

                                                   {
  uv_buf_t buf;
  buf.base = base;
  buf.len = len;
  return buf;
}

References len.

Referenced by alloc_buffer(), echo_read(), main(), on_new_connection(), on_open(), on_type(), uv__build_coalesced_write_req(), uv__pipe_read_data(), uv__pipe_write_ipc(), uv__read(), uv__udp_recvmsg(), uv_process_tcp_read_req(), uv_process_tty_read_raw_req(), uv_process_udp_recv_req(), uv_tcp_queue_read(), uv_tty_queue_read_line(), uv_udp_queue_recv(), and write_data().

uv_default_loop()

uv_loop_t* uv_default_loop

(

void

)

Definition at line 763 of file uv-common.c.

                                 {
  if (default_loop_ptr != NULL)
    return default_loop_ptr;
 
  if (uv_loop_init(&default_loop_struct))
    return NULL;
 
  default_loop_ptr = &default_loop_struct;
  return default_loop_ptr;
}

References default_loop_ptr, default_loop_struct, NULL, and uv_loop_init().

Referenced by idle_cb(), main(), on_open(), on_read(), on_write(), and uv__print_handles().

uv_err_name()

const char* uv_err_name

(

int

err

)

Definition at line 189 of file uv-common.c.

                                 {
  switch (err) {
    UV_ERRNO_MAP(UV_ERR_NAME_GEN)
  }
  return uv__unknown_err_code(err);
}

References err, uv__unknown_err_code(), UV_ERR_NAME_GEN, and UV_ERRNO_MAP.

Referenced by echo_read(), echo_write(), main(), on_connect(), on_new_connection(), on_read(), and on_resolved().

uv_err_name_r()

char* uv_err_name_r	(	int	err,
		char *	buf,
		size_t	buflen
	)

Definition at line 178 of file uv-common.c.

                                                       {
  switch (err) {
    UV_ERRNO_MAP(UV_ERR_NAME_GEN_R)
    default: snprintf(buf, buflen, "Unknown system error %d", err);
  }
  return buf;
}

References buflen, err, snprintf, UV_ERR_NAME_GEN_R, and UV_ERRNO_MAP.

uv_free_cpu_info()

void uv_free_cpu_info	(	uv_cpu_info_t *	cpu_infos,
		int	count
	)

Definition at line 846 of file uv-common.c.

                                                           {
  int i;
 
  for (i = 0; i < count; i++)
    uv__free(cpu_infos[i].model);
 
  uv__free(cpu_infos);
}

References count, i, and uv__free().

Referenced by setup_workers(), and uv_cpu_info().

uv_fs_event_getpath()

int uv_fs_event_getpath	(	uv_fs_event_t *	handle,
		char *	buffer,
		size_t *	size
	)

Definition at line 592 of file uv-common.c.

                                                                           {
  size_t required_len;
 
  if (!uv__is_active(handle)) {
    *size = 0;
    return UV_EINVAL;
  }
 
  required_len = strlen(handle->path);
  if (required_len >= *size) {
    *size = required_len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, handle->path, required_len);
  *size = required_len;
  buffer[required_len] = '\0';
 
  return 0;
}

References handle, memcpy(), and uv__is_active.

Referenced by run_command().

uv_fs_scandir_next()

int uv_fs_scandir_next	(	uv_fs_t *	req,
		uv_dirent_t *	ent
	)

Definition at line 651 of file uv-common.c.

                                                       {
  uv__dirent_t** dents;
  uv__dirent_t* dent;
  unsigned int* nbufs;
 
  /* Check to see if req passed */
  if (req->result < 0)
    return req->result;
 
  /* Ptr will be null if req was canceled or no files found */
  if (!req->ptr)
    return UV_EOF;
 
  nbufs = uv__get_nbufs(req);
  assert(nbufs);
 
  dents = req->ptr;
 
  /* Free previous entity */
  if (*nbufs > 0)
    uv__fs_scandir_free(dents[*nbufs - 1]);
 
  /* End was already reached */
  if (*nbufs == (unsigned int) req->result) {
    uv__fs_scandir_free(dents);
    req->ptr = NULL;
    return UV_EOF;
  }
 
  dent = dents[(*nbufs)++];
 
  ent->name = dent->d_name;
  ent->type = uv__fs_get_dirent_type(dent);
 
  return 0;
}

References assert(), dirent::d_name, uv_dirent_s::name, NULL, req, uv_dirent_s::type, uv__fs_get_dirent_type(), uv__fs_scandir_free, and uv__get_nbufs().

uv_handle_size()

size_t uv_handle_size

(

uv_handle_type

type

)

Definition at line 133 of file uv-common.c.

                                           {
  switch (type) {
    UV_HANDLE_TYPE_MAP(XX)
    default:
      return -1;
  }
}

References type, UV_HANDLE_TYPE_MAP, and XX.

uv_has_ref()

int uv_has_ref

(

const uv_handle_t *

handle

)

Definition at line 557 of file uv-common.c.

                                          {
  return uv__has_ref(handle);
}

References handle, and uv__has_ref.

uv_ip4_addr()

int uv_ip4_addr	(	const char *	ip,
		int	port,
		struct sockaddr_in *	addr
	)

Definition at line 221 of file uv-common.c.

                                                                    {
  memset(addr, 0, sizeof(*addr));
  addr->sin_family = AF_INET;
  addr->sin_port = htons(port);
#ifdef SIN6_LEN
  addr->sin_len = sizeof(*addr);
#endif
  return uv_inet_pton(AF_INET, ip, &(addr->sin_addr.s_addr));
}

References addr, AF_INET, htons, ip, memset(), and uv_inet_pton().

Referenced by main(), uv_udp_set_membership(), uv_udp_set_multicast_interface(), uv_udp_set_source_membership(), and uv_winsock_init().

uv_ip4_name()

int uv_ip4_name	(	const struct sockaddr_in *	src,
		char *	dst,
		size_t	size
	)

Definition at line 267 of file uv-common.c.

                                                                       {
  return uv_inet_ntop(AF_INET, &src->sin_addr, dst, size);
}

References AF_INET, dst, src, and uv_inet_ntop().

Referenced by main(), on_read(), and on_resolved().

uv_ip6_addr()

int uv_ip6_addr	(	const char *	ip,
		int	port,
		struct sockaddr_in6 *	addr
	)

Definition at line 232 of file uv-common.c.

                                                                     {
  char address_part[40];
  size_t address_part_size;
  const char* zone_index;
 
  memset(addr, 0, sizeof(*addr));
  addr->sin6_family = AF_INET6;
  addr->sin6_port = htons(port);
#ifdef SIN6_LEN
  addr->sin6_len = sizeof(*addr);
#endif
 
  zone_index = strchr(ip, '%');
  if (zone_index != NULL) {
    address_part_size = zone_index - ip;
    if (address_part_size >= sizeof(address_part))
      address_part_size = sizeof(address_part) - 1;
 
    memcpy(address_part, ip, address_part_size);
    address_part[address_part_size] = '\0';
    ip = address_part;
 
    zone_index++; /* skip '%' */
    /* NOTE: unknown interface (id=0) is silently ignored */
#ifdef _WIN32
    addr->sin6_scope_id = atoi(zone_index);
#else
    addr->sin6_scope_id = if_nametoindex(zone_index);
#endif
  }
 
  return uv_inet_pton(AF_INET6, ip, &addr->sin6_addr);
}

References addr, AF_INET6, htons, ip, memcpy(), memset(), NULL, and uv_inet_pton().

Referenced by uv__udp_set_membership6(), uv__udp_set_source_membership6(), uv_udp_set_membership(), uv_udp_set_multicast_interface(), uv_udp_set_source_membership(), and uv_winsock_init().

uv_ip6_name()

int uv_ip6_name	(	const struct sockaddr_in6 *	src,
		char *	dst,
		size_t	size
	)

Definition at line 272 of file uv-common.c.

                                                                        {
  return uv_inet_ntop(AF_INET6, &src->sin6_addr, dst, size);
}

References AF_INET6, dst, src, and uv_inet_ntop().

Referenced by main().

uv_library_shutdown()

void uv_library_shutdown

(

void

)

Definition at line 859 of file uv-common.c.

                               {
  static int was_shutdown;
 
  if (uv__load_relaxed(&was_shutdown))
    return;
 
  uv__process_title_cleanup();
  uv__signal_cleanup();
  uv__threadpool_cleanup();
  uv__store_relaxed(&was_shutdown, 1);
}

References uv__load_relaxed, uv__process_title_cleanup(), uv__signal_cleanup(), uv__store_relaxed, and uv__threadpool_cleanup().

uv_loop_close()

int uv_loop_close

(

uv_loop_t *

loop

)

Definition at line 791 of file uv-common.c.

                                   {
  QUEUE* q;
  uv_handle_t* h;
#ifndef NDEBUG
  void* saved_data;
#endif
 
  if (uv__has_active_reqs(loop))
    return UV_EBUSY;
 
  QUEUE_FOREACH(q, &loop->handle_queue) {
    h = QUEUE_DATA(q, uv_handle_t, handle_queue);
    if (!(h->flags & UV_HANDLE_INTERNAL))
      return UV_EBUSY;
  }
 
  uv__loop_close(loop);
 
#ifndef NDEBUG
  saved_data = loop->data;
  memset(loop, -1, sizeof(*loop));
  loop->data = saved_data;
#endif
  if (loop == default_loop_ptr)
    default_loop_ptr = NULL;
 
  return 0;
}

References uv_loop_s::data, default_loop_ptr, h, uv_loop_s::handle_queue, loop, memset(), NULL, QUEUE_DATA, QUEUE_FOREACH, uv__has_active_reqs, uv__loop_close(), and UV_HANDLE_INTERNAL.

Referenced by main(), and uv_loop_delete().

uv_loop_configure()

int uv_loop_configure	(	uv_loop_t *	loop,
		uv_loop_option	option,
			...
	)

Definition at line 746 of file uv-common.c.

                                                                   {
  va_list ap;
  int err;
 
  va_start(ap, option);
  /* Any platform-agnostic options should be handled here. */
  err = uv__loop_configure(loop, option, ap);
  va_end(ap);
 
  return err;
}

References err, loop, and uv__loop_configure().

uv_loop_delete()

void uv_loop_delete

(

uv_loop_t *

loop

)

Definition at line 821 of file uv-common.c.

                                     {
  uv_loop_t* default_loop;
  int err;
 
  default_loop = default_loop_ptr;
 
  err = uv_loop_close(loop);
  (void) err;    /* Squelch compiler warnings. */
  assert(err == 0);
  if (loop != default_loop)
    uv__free(loop);
}

References assert(), default_loop_ptr, err, loop, uv__free(), and uv_loop_close().

uv_loop_new()

uv_loop_t* uv_loop_new

(

void

)

Definition at line 775 of file uv-common.c.

                             {
  uv_loop_t* loop;
 
  loop = uv__malloc(sizeof(*loop));
  if (loop == NULL)
    return NULL;
 
  if (uv_loop_init(loop)) {
    uv__free(loop);
    return NULL;
  }
 
  return loop;
}

References loop, NULL, uv__free(), uv__malloc(), and uv_loop_init().

uv_loop_size()

size_t uv_loop_size

(

void

)

Definition at line 152 of file uv-common.c.

                          {
  return sizeof(uv_loop_t);
}

uv_metrics_idle_time()

uint64_t uv_metrics_idle_time

(

uv_loop_t *

loop

)

Definition at line 914 of file uv-common.c.

                                               {
  uv__loop_metrics_t* loop_metrics;
  uint64_t entry_time;
  uint64_t idle_time;
 
  loop_metrics = uv__get_loop_metrics(loop);
  uv_mutex_lock(&loop_metrics->lock);
  idle_time = loop_metrics->provider_idle_time;
  entry_time = loop_metrics->provider_entry_time;
  uv_mutex_unlock(&loop_metrics->lock);
 
  if (entry_time > 0)
    idle_time += uv_hrtime() - entry_time;
  return idle_time;
}

References uv__loop_metrics_s::lock, loop, uv__loop_metrics_s::provider_entry_time, uv__loop_metrics_s::provider_idle_time, uv__get_loop_metrics, uv_hrtime(), uv_mutex_lock(), and uv_mutex_unlock().

uv_now()

uint64_t uv_now

(

const uv_loop_t *

loop

)

Definition at line 567 of file uv-common.c.

                                       {
  return loop->time;
}

References loop.

Referenced by poll_cb(), timer_cb(), and uv_fs_poll_start().

uv_os_free_environ()

void uv_os_free_environ	(	uv_env_item_t *	envitems,
		int	count
	)

Definition at line 835 of file uv-common.c.

                                                            {
  int i;
 
  for (i = 0; i < count; i++) {
    uv__free(envitems[i].name);
  }
 
  uv__free(envitems);
}

References count, i, and uv__free().

uv_print_active_handles()

void uv_print_active_handles	(	uv_loop_t *	loop,
		FILE *	stream
	)

Definition at line 542 of file uv-common.c.

                                                            {
  uv__print_handles(loop, 1, stream);
}

References loop, and uv__print_handles().

uv_print_all_handles()

void uv_print_all_handles	(	uv_loop_t *	loop,
		FILE *	stream
	)

Definition at line 537 of file uv-common.c.

                                                         {
  uv__print_handles(loop, 0, stream);
}

References loop, and uv__print_handles().

uv_recv_buffer_size()

int uv_recv_buffer_size	(	uv_handle_t *	handle,
		int *	value
	)

Definition at line 584 of file uv-common.c.

                                                         {
  return uv__socket_sockopt(handle, SO_RCVBUF, value);
}

References handle, SO_RCVBUF, uv__socket_sockopt(), and value.

uv_ref()

void uv_ref

(

uv_handle_t *

handle

)

Definition at line 547 of file uv-common.c.

                                 {
  uv__handle_ref(handle);
}

References handle, and uv__handle_ref.

uv_replace_allocator()

int uv_replace_allocator	(	uv_malloc_func	malloc_func,
		uv_realloc_func	realloc_func,
		uv_calloc_func	calloc_func,
		uv_free_func	free_func
	)

Definition at line 114 of file uv-common.c.

                                                 {
  if (malloc_func == NULL || realloc_func == NULL ||
      calloc_func == NULL || free_func == NULL) {
    return UV_EINVAL;
  }
 
  uv__allocator.local_malloc = malloc_func;
  uv__allocator.local_realloc = realloc_func;
  uv__allocator.local_calloc = calloc_func;
  uv__allocator.local_free = free_func;
 
  return 0;
}

References uv__allocator_t::local_calloc, uv__allocator_t::local_free, uv__allocator_t::local_malloc, uv__allocator_t::local_realloc, NULL, and uv__allocator.

uv_req_size()

size_t uv_req_size

(

uv_req_type

type

)

Definition at line 141 of file uv-common.c.

                                     {
  switch(type) {
    UV_REQ_TYPE_MAP(XX)
    default:
      return -1;
  }
}

References type, UV_REQ_TYPE_MAP, and XX.

uv_send_buffer_size()

int uv_send_buffer_size	(	uv_handle_t *	handle,
		int *	value
	)

Definition at line 588 of file uv-common.c.

                                                         {
  return uv__socket_sockopt(handle, SO_SNDBUF, value);
}

References handle, SO_SNDBUF, uv__socket_sockopt(), and value.

uv_stop()

void uv_stop

(

uv_loop_t *

loop

)

Definition at line 562 of file uv-common.c.

                              {
  loop->stop_flag = 1;
}

References loop, and uv_loop_s::stop_flag.

Referenced by idle_cb().

uv_strerror()

const char* uv_strerror

(

int

err

)

Definition at line 212 of file uv-common.c.

                                 {
  switch (err) {
    UV_ERRNO_MAP(UV_STRERROR_GEN)
  }
  return uv__unknown_err_code(err);
}

References err, uv__unknown_err_code(), UV_ERRNO_MAP, and UV_STRERROR_GEN.

Referenced by echo_write(), invoke_cgi_script(), main(), on_new_connection(), on_open(), on_read(), on_send(), on_type(), and on_write().

uv_strerror_r()

char* uv_strerror_r	(	int	err,
		char *	buf,
		size_t	buflen
	)

Definition at line 201 of file uv-common.c.

                                                       {
  switch (err) {
    UV_ERRNO_MAP(UV_STRERROR_GEN_R)
    default: snprintf(buf, buflen, "Unknown system error %d", err);
  }
  return buf;
}

References buflen, err, snprintf, UV_ERRNO_MAP, and UV_STRERROR_GEN_R.

uv_tcp_bind()

int uv_tcp_bind	(	uv_tcp_t *	handle,
		const struct sockaddr *	addr,
		unsigned int	flags
	)

Definition at line 277 of file uv-common.c.

                                    {
  unsigned int addrlen;
 
  if (handle->type != UV_TCP)
    return UV_EINVAL;
 
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
 
  return uv__tcp_bind(handle, addr, addrlen, flags);
}

References addr, addrlen, AF_INET, AF_INET6, flags, handle, and uv__tcp_bind().

Referenced by main().

uv_tcp_connect()

int uv_tcp_connect	(	uv_connect_t *	req,
		uv_tcp_t *	handle,
		const struct sockaddr *	addr,
		uv_connect_cb	cb
	)

Definition at line 345 of file uv-common.c.

                                     {
  unsigned int addrlen;
 
  if (handle->type != UV_TCP)
    return UV_EINVAL;
 
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
 
  return uv__tcp_connect(req, handle, addr, addrlen, cb);
}

References addr, addrlen, AF_INET, AF_INET6, cb, handle, req, and uv__tcp_connect().

Referenced by on_resolved().

uv_udp_bind()

int uv_udp_bind	(	uv_udp_t *	handle,
		const struct sockaddr *	addr,
		unsigned int	flags
	)

Definition at line 326 of file uv-common.c.

                                    {
  unsigned int addrlen;
 
  if (handle->type != UV_UDP)
    return UV_EINVAL;
 
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
 
  return uv__udp_bind(handle, addr, addrlen, flags);
}

References addr, addrlen, AF_INET, AF_INET6, flags, handle, and uv__udp_bind().

Referenced by main().

uv_udp_connect()

int uv_udp_connect	(	uv_udp_t *	handle,
		const struct sockaddr *	addr
	)

Definition at line 365 of file uv-common.c.

                                                                  {
  unsigned int addrlen;
 
  if (handle->type != UV_UDP)
    return UV_EINVAL;
 
  /* Disconnect the handle */
  if (addr == NULL) {
    if (!(handle->flags & UV_HANDLE_UDP_CONNECTED))
      return UV_ENOTCONN;
 
    return uv__udp_disconnect(handle);
  }
 
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
 
  if (handle->flags & UV_HANDLE_UDP_CONNECTED)
    return UV_EISCONN;
 
  return uv__udp_connect(handle, addr, addrlen);
}

References addr, addrlen, AF_INET, AF_INET6, handle, NULL, uv__udp_connect(), uv__udp_disconnect(), and UV_HANDLE_UDP_CONNECTED.

uv_udp_init()

int uv_udp_init	(	uv_loop_t *	loop,
		uv_udp_t *	handle
	)

Definition at line 321 of file uv-common.c.

                                                   {
  return uv_udp_init_ex(loop, handle, AF_UNSPEC);
}

References AF_UNSPEC, handle, loop, and uv_udp_init_ex().

Referenced by main().

uv_udp_init_ex()

int uv_udp_init_ex	(	uv_loop_t *	loop,
		uv_udp_t *	handle,
		unsigned	flags
	)

Definition at line 296 of file uv-common.c.

                                                                      {
  unsigned extra_flags;
  int domain;
  int rc;
 
  /* Use the lower 8 bits for the domain. */
  domain = flags & 0xFF;
  if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
    return UV_EINVAL;
 
  /* Use the higher bits for extra flags. */
  extra_flags = flags & ~0xFF;
  if (extra_flags & ~UV_UDP_RECVMMSG)
    return UV_EINVAL;
 
  rc = uv__udp_init_ex(loop, handle, flags, domain);
 
  if (rc == 0)
    if (extra_flags & UV_UDP_RECVMMSG)
      handle->flags |= UV_HANDLE_UDP_RECVMMSG;
 
  return rc;
}

References AF_INET, AF_INET6, AF_UNSPEC, domain, flags, handle, loop, uv__udp_init_ex(), UV_HANDLE_UDP_RECVMMSG, and UV_UDP_RECVMMSG.

Referenced by uv_udp_init().

uv_udp_recv_start()

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

Definition at line 468 of file uv-common.c.

                                              {
  if (handle->type != UV_UDP || alloc_cb == NULL || recv_cb == NULL)
    return UV_EINVAL;
  else
    return uv__udp_recv_start(handle, alloc_cb, recv_cb);
}

References handle, NULL, and uv__udp_recv_start().

Referenced by main().

uv_udp_recv_stop()

int uv_udp_recv_stop

(

uv_udp_t *

handle

)

Definition at line 478 of file uv-common.c.

                                       {
  if (handle->type != UV_UDP)
    return UV_EINVAL;
  else
    return uv__udp_recv_stop(handle);
}

References handle, and uv__udp_recv_stop().

Referenced by on_read(), uv_process_udp_recv_req(), and uv_udp_close().

uv_udp_send()

int uv_udp_send	(	uv_udp_send_t *	req,
		uv_udp_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		const struct sockaddr *	addr,
		uv_udp_send_cb	send_cb
	)

Definition at line 438 of file uv-common.c.

                                        {
  int addrlen;
 
  addrlen = uv__udp_check_before_send(handle, addr);
  if (addrlen < 0)
    return addrlen;
 
  return uv__udp_send(req, handle, bufs, nbufs, addr, addrlen, send_cb);
}

References addr, addrlen, bufs, handle, req, uv__udp_check_before_send(), and uv__udp_send().

Referenced by main().

uv_udp_try_send()

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

Definition at line 454 of file uv-common.c.

                                                 {
  int addrlen;
 
  addrlen = uv__udp_check_before_send(handle, addr);
  if (addrlen < 0)
    return addrlen;
 
  return uv__udp_try_send(handle, bufs, nbufs, addr, addrlen);
}

References addr, addrlen, bufs, handle, uv__udp_check_before_send(), and uv__udp_try_send().

uv_unref()

void uv_unref

(

uv_handle_t *

handle

)

Definition at line 552 of file uv-common.c.

                                   {
  uv__handle_unref(handle);
}

References handle, and uv__handle_unref.

Referenced by eof_timer_init(), and main().

uv_walk()

void uv_walk	(	uv_loop_t *	loop,
		uv_walk_cb	walk_cb,
		void *	arg
	)

Definition at line 486 of file uv-common.c.

                                                             {
  QUEUE queue;
  QUEUE* q;
  uv_handle_t* h;
 
  QUEUE_MOVE(&loop->handle_queue, &queue);
  while (!QUEUE_EMPTY(&queue)) {
    q = QUEUE_HEAD(&queue);
    h = QUEUE_DATA(q, uv_handle_t, handle_queue);
 
    QUEUE_REMOVE(q);
    QUEUE_INSERT_TAIL(&loop->handle_queue, q);
 
    if (h->flags & UV_HANDLE_INTERNAL) continue;
    walk_cb(h, arg);
  }
}

References h, uv_loop_s::handle_queue, loop, queue, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_INSERT_TAIL, QUEUE_MOVE, QUEUE_REMOVE, and UV_HANDLE_INTERNAL.

Variable Documentation

default_loop_ptr

uv_loop_t* default_loop_ptr

static

Definition at line 760 of file uv-common.c.

Referenced by uv_default_loop(), uv_loop_close(), and uv_loop_delete().

default_loop_struct

uv_loop_t default_loop_struct

static

Definition at line 759 of file uv-common.c.

Referenced by uv_default_loop().

uv__allocator

uv__allocator_t uv__allocator

static

Initial value:

= {
  malloc,
  realloc,
  calloc,
  free,
}

Definition at line 48 of file uv-common.c.

Referenced by uv__calloc(), uv__free(), uv__malloc(), uv__realloc(), and uv_replace_allocator().