internal.h File Reference

#include "uv.h"
#include "../uv-common.h"
#include "uv/tree.h"
#include "winapi.h"
#include "winsock.h"

Go to the source code of this file.

Classes
struct	uv__ipc_socket_xfer_info_t

Macros
#define	INLINE   inline
#define	UV_THREAD_LOCAL   __thread
#define	UV_BEGIN_DISABLE_CRT_ASSERT()
#define	UV_END_DISABLE_CRT_ASSERT()

Typedefs
typedef int(WINAPI *	uv__peersockfunc) (SOCKET, struct sockaddr *, int *)

Enumerations
enum	uv__ipc_socket_xfer_type_t { UV__IPC_SOCKET_XFER_NONE = 0 , UV__IPC_SOCKET_XFER_TCP_CONNECTION , UV__IPC_SOCKET_XFER_TCP_SERVER }

Functions
int	uv_tcp_listen (uv_tcp_t *handle, int backlog, uv_connection_cb cb)
int	uv_tcp_accept (uv_tcp_t *server, uv_tcp_t *client)
int	uv_tcp_read_start (uv_tcp_t *handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
int	uv_tcp_write (uv_loop_t *loop, uv_write_t *req, uv_tcp_t *handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
int	uv__tcp_try_write (uv_tcp_t *handle, const uv_buf_t bufs[], unsigned int nbufs)
void	uv_process_tcp_read_req (uv_loop_t *loop, uv_tcp_t *handle, uv_req_t *req)
void	uv_process_tcp_write_req (uv_loop_t *loop, uv_tcp_t *handle, uv_write_t *req)
void	uv_process_tcp_accept_req (uv_loop_t *loop, uv_tcp_t *handle, uv_req_t *req)
void	uv_process_tcp_connect_req (uv_loop_t *loop, uv_tcp_t *handle, uv_connect_t *req)
void	uv_tcp_close (uv_loop_t *loop, uv_tcp_t *tcp)
void	uv_tcp_endgame (uv_loop_t *loop, uv_tcp_t *handle)
int	uv__tcp_xfer_export (uv_tcp_t *handle, int pid, uv__ipc_socket_xfer_type_t *xfer_type, uv__ipc_socket_xfer_info_t *xfer_info)
int	uv__tcp_xfer_import (uv_tcp_t *tcp, uv__ipc_socket_xfer_type_t xfer_type, uv__ipc_socket_xfer_info_t *xfer_info)
void	uv_process_udp_recv_req (uv_loop_t *loop, uv_udp_t *handle, uv_req_t *req)
void	uv_process_udp_send_req (uv_loop_t *loop, uv_udp_t *handle, uv_udp_send_t *req)
void	uv_udp_close (uv_loop_t *loop, uv_udp_t *handle)
void	uv_udp_endgame (uv_loop_t *loop, uv_udp_t *handle)
int	uv_stdio_pipe_server (uv_loop_t *loop, uv_pipe_t *handle, DWORD access, char *name, size_t nameSize)
int	uv_pipe_listen (uv_pipe_t *handle, int backlog, uv_connection_cb cb)
int	uv_pipe_accept (uv_pipe_t *server, uv_stream_t *client)
int	uv_pipe_read_start (uv_pipe_t *handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
void	uv__pipe_read_stop (uv_pipe_t *handle)
int	uv__pipe_write (uv_loop_t *loop, uv_write_t *req, uv_pipe_t *handle, const uv_buf_t bufs[], size_t nbufs, uv_stream_t *send_handle, uv_write_cb cb)
void	uv_process_pipe_read_req (uv_loop_t *loop, uv_pipe_t *handle, uv_req_t *req)
void	uv_process_pipe_write_req (uv_loop_t *loop, uv_pipe_t *handle, uv_write_t *req)
void	uv_process_pipe_accept_req (uv_loop_t *loop, uv_pipe_t *handle, uv_req_t *raw_req)
void	uv_process_pipe_connect_req (uv_loop_t *loop, uv_pipe_t *handle, uv_connect_t *req)
void	uv_process_pipe_shutdown_req (uv_loop_t *loop, uv_pipe_t *handle, uv_shutdown_t *req)
void	uv_pipe_close (uv_loop_t *loop, uv_pipe_t *handle)
void	uv_pipe_cleanup (uv_loop_t *loop, uv_pipe_t *handle)
void	uv_pipe_endgame (uv_loop_t *loop, uv_pipe_t *handle)
void	uv_console_init (void)
int	uv_tty_read_start (uv_tty_t *handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
int	uv_tty_read_stop (uv_tty_t *handle)
int	uv_tty_write (uv_loop_t *loop, uv_write_t *req, uv_tty_t *handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
int	uv__tty_try_write (uv_tty_t *handle, const uv_buf_t bufs[], unsigned int nbufs)
void	uv_tty_close (uv_tty_t *handle)
void	uv_process_tty_read_req (uv_loop_t *loop, uv_tty_t *handle, uv_req_t *req)
void	uv_process_tty_write_req (uv_loop_t *loop, uv_tty_t *handle, uv_write_t *req)
void	uv_process_tty_accept_req (uv_loop_t *loop, uv_tty_t *handle, uv_req_t *raw_req)
void	uv_process_tty_connect_req (uv_loop_t *loop, uv_tty_t *handle, uv_connect_t *req)
void	uv_tty_endgame (uv_loop_t *loop, uv_tty_t *handle)
void	uv_process_poll_req (uv_loop_t *loop, uv_poll_t *handle, uv_req_t *req)
int	uv_poll_close (uv_loop_t *loop, uv_poll_t *handle)
void	uv_poll_endgame (uv_loop_t *loop, uv_poll_t *handle)
void	uv_loop_watcher_endgame (uv_loop_t *loop, uv_handle_t *handle)
void	uv_prepare_invoke (uv_loop_t *loop)
void	uv_check_invoke (uv_loop_t *loop)
void	uv_idle_invoke (uv_loop_t *loop)
void	uv__once_init (void)
void	uv_async_close (uv_loop_t *loop, uv_async_t *handle)
void	uv_async_endgame (uv_loop_t *loop, uv_async_t *handle)
void	uv_process_async_wakeup_req (uv_loop_t *loop, uv_async_t *handle, uv_req_t *req)
void	uv_signals_init (void)
int	uv__signal_dispatch (int signum)
void	uv_signal_close (uv_loop_t *loop, uv_signal_t *handle)
void	uv_signal_endgame (uv_loop_t *loop, uv_signal_t *handle)
void	uv_process_signal_req (uv_loop_t *loop, uv_signal_t *handle, uv_req_t *req)
void	uv_process_proc_exit (uv_loop_t *loop, uv_process_t *handle)
void	uv_process_close (uv_loop_t *loop, uv_process_t *handle)
void	uv_process_endgame (uv_loop_t *loop, uv_process_t *handle)
int	uv_translate_sys_error (int sys_errno)
void	uv_fs_init (void)
void	uv_process_fs_event_req (uv_loop_t *loop, uv_req_t *req, uv_fs_event_t *handle)
void	uv_fs_event_close (uv_loop_t *loop, uv_fs_event_t *handle)
void	uv_fs_event_endgame (uv_loop_t *loop, uv_fs_event_t *handle)
void	uv__fs_poll_endgame (uv_loop_t *loop, uv_fs_poll_t *handle)
void	uv__util_init (void)
uint64_t	uv__hrtime (unsigned int scale)
	__declspec (noreturn) void uv_fatal_error(const int errorno
int	uv__getpwuid_r (uv_passwd_t *pwd)
int	uv__convert_utf16_to_utf8 (const WCHAR *utf16, int utf16len, char **utf8)
int	uv__convert_utf8_to_utf16 (const char *utf8, int utf8len, WCHAR **utf16)
int	uv__getsockpeername (const uv_handle_t *handle, uv__peersockfunc func, struct sockaddr *name, int *namelen, int delayed_error)
int	uv__random_rtlgenrandom (void *buf, size_t buflen)
int	uv__stdio_create (uv_loop_t *loop, const uv_process_options_t *options, BYTE **buffer_ptr)
void	uv__stdio_destroy (BYTE *buffer)
void	uv__stdio_noinherit (BYTE *buffer)
int	uv__stdio_verify (BYTE *buffer, WORD size)
WORD	uv__stdio_size (BYTE *buffer)
HANDLE	uv__stdio_handle (BYTE *buffer, int fd)
void	uv_winapi_init (void)
void	uv_winsock_init (void)
int	uv_ntstatus_to_winsock_error (NTSTATUS status)
BOOL	uv_get_acceptex_function (SOCKET socket, LPFN_ACCEPTEX *target)
BOOL	uv_get_connectex_function (SOCKET socket, LPFN_CONNECTEX *target)
int WSAAPI	uv_wsarecv_workaround (SOCKET socket, WSABUF *buffers, DWORD buffer_count, DWORD *bytes, DWORD *flags, WSAOVERLAPPED *overlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine)
int WSAAPI	uv_wsarecvfrom_workaround (SOCKET socket, WSABUF *buffers, DWORD buffer_count, DWORD *bytes, DWORD *flags, struct sockaddr *addr, int *addr_len, WSAOVERLAPPED *overlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine)
int WSAAPI	uv_msafd_poll (SOCKET socket, AFD_POLL_INFO *info_in, AFD_POLL_INFO *info_out, OVERLAPPED *overlapped)
void	uv__wake_all_loops (void)
void	uv__init_detect_system_wakeup (void)

Variables
const char *	syscall
int	uv_tcp_non_ifs_lsp_ipv4
int	uv_tcp_non_ifs_lsp_ipv6
struct sockaddr_in	uv_addr_ip4_any_
struct sockaddr_in6	uv_addr_ip6_any_

Macro Definition Documentation

INLINE

#define INLINE   inline

Definition at line 36 of file internal.h.

UV_BEGIN_DISABLE_CRT_ASSERT

#define UV_BEGIN_DISABLE_CRT_ASSERT

(

)

Definition at line 56 of file internal.h.

UV_END_DISABLE_CRT_ASSERT

#define UV_END_DISABLE_CRT_ASSERT

(

)

Definition at line 57 of file internal.h.

UV_THREAD_LOCAL

#define UV_THREAD_LOCAL   __thread

Definition at line 37 of file internal.h.

Typedef Documentation

uv__peersockfunc

typedef int(WINAPI * uv__peersockfunc) (SOCKET, struct sockaddr *, int *)

Definition at line 275 of file internal.h.

Enumeration Type Documentation

uv__ipc_socket_xfer_type_t

enum uv__ipc_socket_xfer_type_t

Enumerator
UV__IPC_SOCKET_XFER_NONE
UV__IPC_SOCKET_XFER_TCP_CONNECTION
UV__IPC_SOCKET_XFER_TCP_SERVER

Definition at line 64 of file internal.h.

             {
  UV__IPC_SOCKET_XFER_NONE = 0,
  UV__IPC_SOCKET_XFER_TCP_CONNECTION,
  UV__IPC_SOCKET_XFER_TCP_SERVER
} uv__ipc_socket_xfer_type_t;

Function Documentation

__declspec()

__declspec

(

noreturn

)

const

Referenced by fs__scandir().

uv__convert_utf16_to_utf8()

int uv__convert_utf16_to_utf8	(	const WCHAR *	utf16,
		int	utf16len,
		char **	utf8
	)

Definition at line 1280 of file util.c.

                                                                             {
  DWORD bufsize;
 
  if (utf16 == NULL)
    return UV_EINVAL;
 
  /* Check how much space we need */
  bufsize = WideCharToMultiByte(CP_UTF8,
                                0,
                                utf16,
                                utf16len,
                                NULL,
                                0,
                                NULL,
                                NULL);
 
  if (bufsize == 0)
    return uv_translate_sys_error(GetLastError());
 
  /* Allocate the destination buffer adding an extra byte for the terminating
   * NULL. If utf16len is not -1 WideCharToMultiByte will not add it, so
   * we do it ourselves always, just in case. */
  *utf8 = uv__malloc(bufsize + 1);
 
  if (*utf8 == NULL)
    return UV_ENOMEM;
 
  /* Convert to UTF-8 */
  bufsize = WideCharToMultiByte(CP_UTF8,
                                0,
                                utf16,
                                utf16len,
                                *utf8,
                                bufsize,
                                NULL,
                                NULL);
 
  if (bufsize == 0) {
    uv__free(*utf8);
    *utf8 = NULL;
    return uv_translate_sys_error(GetLastError());
  }
 
  (*utf8)[bufsize] = '\0';
  return 0;
}

References DWORD, NULL, uv__free(), uv__malloc(), and uv_translate_sys_error().

Referenced by fs__readdir(), uv__get_process_title(), uv__getpwuid_r(), uv_cpu_info(), uv_os_environ(), and uv_process_fs_event_req().

uv__convert_utf8_to_utf16()

int uv__convert_utf8_to_utf16	(	const char *	utf8,
		int	utf8len,
		WCHAR **	utf16
	)

Definition at line 1335 of file util.c.

                                                                            {
  int bufsize;
 
  if (utf8 == NULL)
    return UV_EINVAL;
 
  /* Check how much space we need */
  bufsize = MultiByteToWideChar(CP_UTF8, 0, utf8, utf8len, NULL, 0);
 
  if (bufsize == 0)
    return uv_translate_sys_error(GetLastError());
 
  /* Allocate the destination buffer adding an extra byte for the terminating
   * NULL. If utf8len is not -1 MultiByteToWideChar will not add it, so
   * we do it ourselves always, just in case. */
  *utf16 = uv__malloc(sizeof(WCHAR) * (bufsize + 1));
 
  if (*utf16 == NULL)
    return UV_ENOMEM;
 
  /* Convert to UTF-16 */
  bufsize = MultiByteToWideChar(CP_UTF8, 0, utf8, utf8len, *utf16, bufsize);
 
  if (bufsize == 0) {
    uv__free(*utf16);
    *utf16 = NULL;
    return uv_translate_sys_error(GetLastError());
  }
 
  (*utf16)[bufsize] = L'\0';
  return 0;
}

References L, NULL, uv__free(), uv__malloc(), and uv_translate_sys_error().

Referenced by uv_os_getenv(), uv_os_setenv(), and uv_os_unsetenv().

uv__fs_poll_endgame()

void uv__fs_poll_endgame	(	uv_loop_t *	loop,
		uv_fs_poll_t *	handle
	)

Referenced by uv_process_endgames().

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 ARRAY_SIZE, buf, DWORD, ERANGE, uv_passwd_s::gid, HANDLE, uv_passwd_s::homedir, memcpy(), NULL, path, r, uv_passwd_s::shell, uv_passwd_s::uid, UNLEN, uv_passwd_s::username, uv__convert_utf16_to_utf8(), uv__free(), uv__malloc(), and uv_translate_sys_error().

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,
		int	delayed_error
	)

Definition at line 727 of file core.c.

                                           {
 
  int result;
  uv_os_fd_t fd;
 
  result = uv_fileno(handle, &fd);
  if (result != 0)
    return result;
 
  if (delayed_error)
    return uv_translate_sys_error(delayed_error);
 
  result = func((SOCKET) fd, name, namelen);
  if (result != 0)
    return uv_translate_sys_error(WSAGetLastError());
 
  return 0;
}

References fd, handle, uv_fileno(), and uv_translate_sys_error().

uv__hrtime()

uint64_t uv__hrtime

(

unsigned int

scale

)

Definition at line 495 of file util.c.

                                        {
  LARGE_INTEGER counter;
  double scaled_freq;
  double result;
 
  assert(hrtime_frequency_ != 0);
  assert(scale != 0);
  if (!QueryPerformanceCounter(&counter)) {
    uv_fatal_error(GetLastError(), "QueryPerformanceCounter");
  }
  assert(counter.QuadPart != 0);
 
  /* Because we have no guarantee about the order of magnitude of the
   * performance counter interval, integer math could cause this computation
   * to overflow. Therefore we resort to floating point math.
   */
  scaled_freq = (double) hrtime_frequency_ / scale;
  result = (double) counter.QuadPart / scaled_freq;
  return (uint64_t) result;
}

References assert(), counter, hrtime_frequency_, and uv_fatal_error().

Referenced by uv_hrtime().

uv__init_detect_system_wakeup()

void uv__init_detect_system_wakeup

(

void

)

Definition at line 28 of file detect-wakeup.c.

                                         {
  /* Try registering system power event callback. This is the cleanest
   * method, but it will only work on Win8 and above.
   */
  uv__register_system_resume_callback();
}

References uv__register_system_resume_callback().

Referenced by uv_init().

uv__once_init()

void uv__once_init

(

void

)

Definition at line 329 of file core.c.

                         {
  uv_once(&uv_init_guard_, uv_init);
}

References uv_init(), uv_init_guard_, and uv_once().

Referenced by uv__pipe_getname(), uv__random(), uv_cpu_info(), uv_fs_req_init(), uv_get_process_title(), uv_hrtime(), uv_loop_init(), uv_os_gethostname(), uv_os_uname(), uv_pipe_open(), uv_set_process_title(), and uv_tty_init().

uv__pipe_read_stop()

void uv__pipe_read_stop

(

uv_pipe_t *

handle

)

Definition at line 775 of file pipe.c.

                                           {
  handle->flags &= ~UV_HANDLE_READING;
  DECREASE_ACTIVE_COUNT(handle->loop, handle);
 
  uv__pipe_interrupt_read(handle);
}

References DECREASE_ACTIVE_COUNT, handle, uv__pipe_interrupt_read(), and UV_HANDLE_READING.

Referenced by uv_read_stop().

uv__pipe_write()

int uv__pipe_write	(	uv_loop_t *	loop,
		uv_write_t *	req,
		uv_pipe_t *	handle,
		const uv_buf_t	bufs[],
		size_t	nbufs,
		uv_stream_t *	send_handle,
		uv_write_cb	cb
	)

Definition at line 1578 of file pipe.c.

                                   {
  if (handle->ipc) {
    /* IPC pipe write: use framing protocol. */
    return uv__pipe_write_ipc(loop, req, handle, bufs, nbufs, send_handle, cb);
  } else {
    /* Non-IPC pipe write: put data on the wire directly. */
    assert(send_handle == NULL);
    return uv__pipe_write_data(loop, req, handle, bufs, nbufs, cb, 0);
  }
}

References assert(), bufs, cb, handle, loop, NULL, req, uv__pipe_write_data(), and uv__pipe_write_ipc().

Referenced by uv_write(), and uv_write2().

uv__random_rtlgenrandom()

int uv__random_rtlgenrandom	(	void *	buf,
		size_t	buflen
	)

Definition at line 1965 of file util.c.

                                                      {
  if (buflen == 0)
    return 0;
 
  if (SystemFunction036(buf, buflen) == FALSE)
    return UV_EIO;
 
  return 0;
}

References buflen, FALSE, and SystemFunction036().

Referenced by fs__mktemp(), and uv__random().

uv__signal_dispatch()

int uv__signal_dispatch

(

int

signum

)

Definition at line 80 of file signal.c.

                                    {
  uv_signal_t lookup;
  uv_signal_t* handle;
  int dispatched;
 
  dispatched = 0;
 
  EnterCriticalSection(&uv__signal_lock);
 
  lookup.signum = signum;
  lookup.loop = NULL;
 
  for (handle = RB_NFIND(uv_signal_tree_s, &uv__signal_tree, &lookup);
       handle != NULL && handle->signum == signum;
       handle = RB_NEXT(uv_signal_tree_s, &uv__signal_tree, handle)) {
    unsigned long previous = InterlockedExchange(
            (volatile LONG*) &handle->pending_signum, signum);
 
    if (handle->flags & UV_SIGNAL_ONE_SHOT_DISPATCHED)
      continue;
 
    if (!previous) {
      POST_COMPLETION_FOR_REQ(handle->loop, &handle->signal_req);
    }
 
    dispatched = 1;
    if (handle->flags & UV_SIGNAL_ONE_SHOT)
      handle->flags |= UV_SIGNAL_ONE_SHOT_DISPATCHED;
  }
 
  LeaveCriticalSection(&uv__signal_lock);
 
  return dispatched;
}

References handle, InterlockedExchange, LONG, NULL, POST_COMPLETION_FOR_REQ, RB_NEXT, RB_NFIND, signum, uv_signal_s::signum, uv__signal_lock, uv__signal_tree, UV_SIGNAL_ONE_SHOT, and UV_SIGNAL_ONE_SHOT_DISPATCHED.

Referenced by uv__signal_control_handler(), and uv__tty_console_signal_resize().

uv__stdio_create()

int uv__stdio_create	(	uv_loop_t *	loop,
		const uv_process_options_t *	options,
		BYTE **	buffer_ptr
	)

Definition at line 265 of file process-stdio.c.

                                        {
  BYTE* buffer;
  int count, i;
  int err;
 
  count = options->stdio_count;
 
  if (count < 0 || count > 255) {
    /* Only support FDs 0-255 */
    return ERROR_NOT_SUPPORTED;
  } else if (count < 3) {
    /* There should always be at least 3 stdio handles. */
    count = 3;
  }
 
  /* Allocate the child stdio buffer */
  buffer = (BYTE*) uv__malloc(CHILD_STDIO_SIZE(count));
  if (buffer == NULL) {
    return ERROR_OUTOFMEMORY;
  }
 
  /* Prepopulate the buffer with INVALID_HANDLE_VALUE handles so we can clean
   * up on failure. */
  CHILD_STDIO_COUNT(buffer) = count;
  for (i = 0; i < count; i++) {
    CHILD_STDIO_CRT_FLAGS(buffer, i) = 0;
    CHILD_STDIO_HANDLE(buffer, i) = INVALID_HANDLE_VALUE;
  }
 
  for (i = 0; i < count; i++) {
    uv_stdio_container_t fdopt;
    if (i < options->stdio_count) {
      fdopt = options->stdio[i];
    } else {
      fdopt.flags = UV_IGNORE;
    }
 
    switch (fdopt.flags & (UV_IGNORE | UV_CREATE_PIPE | UV_INHERIT_FD |
            UV_INHERIT_STREAM)) {
      case UV_IGNORE:
        /* Starting a process with no stdin/stout/stderr can confuse it. So no
         * matter what the user specified, we make sure the first three FDs are
         * always open in their typical modes, e. g. stdin be readable and
         * stdout/err should be writable. For FDs > 2, don't do anything - all
         * handles in the stdio buffer are initialized with.
         * INVALID_HANDLE_VALUE, which should be okay. */
        if (i <= 2) {
          DWORD access = (i == 0) ? FILE_GENERIC_READ :
                                    FILE_GENERIC_WRITE | FILE_READ_ATTRIBUTES;
 
          err = uv__create_nul_handle(&CHILD_STDIO_HANDLE(buffer, i),
                                      access);
          if (err)
            goto error;
 
          CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FDEV;
        }
        break;
 
      case UV_CREATE_PIPE: {
        /* Create a pair of two connected pipe ends; one end is turned into an
         * uv_pipe_t for use by the parent. The other one is given to the
         * child. */
        uv_pipe_t* parent_pipe = (uv_pipe_t*) fdopt.data.stream;
        HANDLE child_pipe = INVALID_HANDLE_VALUE;
 
        /* Create a new, connected pipe pair. stdio[i]. stream should point to
         * an uninitialized, but not connected pipe handle. */
        assert(fdopt.data.stream->type == UV_NAMED_PIPE);
        assert(!(fdopt.data.stream->flags & UV_HANDLE_CONNECTION));
        assert(!(fdopt.data.stream->flags & UV_HANDLE_PIPESERVER));
 
        err = uv__create_stdio_pipe_pair(loop,
                                         parent_pipe,
                                         &child_pipe,
                                         fdopt.flags);
        if (err)
          goto error;
 
        CHILD_STDIO_HANDLE(buffer, i) = child_pipe;
        CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FPIPE;
        break;
      }
 
      case UV_INHERIT_FD: {
        /* Inherit a raw FD. */
        HANDLE child_handle;
 
        /* Make an inheritable duplicate of the handle. */
        err = uv__duplicate_fd(loop, fdopt.data.fd, &child_handle);
        if (err) {
          /* If fdopt. data. fd is not valid and fd <= 2, then ignore the
           * error. */
          if (fdopt.data.fd <= 2 && err == ERROR_INVALID_HANDLE) {
            CHILD_STDIO_CRT_FLAGS(buffer, i) = 0;
            CHILD_STDIO_HANDLE(buffer, i) = INVALID_HANDLE_VALUE;
            break;
          }
          goto error;
        }
 
        /* Figure out what the type is. */
        switch (GetFileType(child_handle)) {
          case FILE_TYPE_DISK:
            CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN;
            break;
 
          case FILE_TYPE_PIPE:
            CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FPIPE;
            break;
 
          case FILE_TYPE_CHAR:
          case FILE_TYPE_REMOTE:
            CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FDEV;
            break;
 
          case FILE_TYPE_UNKNOWN:
            if (GetLastError() != 0) {
              err = GetLastError();
              CloseHandle(child_handle);
              goto error;
            }
            CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FDEV;
            break;
 
          default:
            assert(0);
            return -1;
        }
 
        CHILD_STDIO_HANDLE(buffer, i) = child_handle;
        break;
      }
 
      case UV_INHERIT_STREAM: {
        /* Use an existing stream as the stdio handle for the child. */
        HANDLE stream_handle, child_handle;
        unsigned char crt_flags;
        uv_stream_t* stream = fdopt.data.stream;
 
        /* Leech the handle out of the stream. */
        if (stream->type == UV_TTY) {
          stream_handle = ((uv_tty_t*) stream)->handle;
          crt_flags = FOPEN | FDEV;
        } else if (stream->type == UV_NAMED_PIPE &&
                   stream->flags & UV_HANDLE_CONNECTION) {
          stream_handle = ((uv_pipe_t*) stream)->handle;
          crt_flags = FOPEN | FPIPE;
        } else {
          stream_handle = INVALID_HANDLE_VALUE;
          crt_flags = 0;
        }
 
        if (stream_handle == NULL ||
            stream_handle == INVALID_HANDLE_VALUE) {
          /* The handle is already closed, or not yet created, or the stream
           * type is not supported. */
          err = ERROR_NOT_SUPPORTED;
          goto error;
        }
 
        /* Make an inheritable copy of the handle. */
        err = uv__duplicate_handle(loop, stream_handle, &child_handle);
        if (err)
          goto error;
 
        CHILD_STDIO_HANDLE(buffer, i) = child_handle;
        CHILD_STDIO_CRT_FLAGS(buffer, i) = crt_flags;
        break;
      }
 
      default:
        assert(0);
        return -1;
    }
  }
 
  *buffer_ptr  = buffer;
  return 0;
 
 error:
  uv__stdio_destroy(buffer);
  return err;
}

References access, assert(), CHILD_STDIO_COUNT, CHILD_STDIO_CRT_FLAGS, CHILD_STDIO_HANDLE, CHILD_STDIO_SIZE, count, uv_stdio_container_s::data, DWORD, err, error(), uv_stdio_container_s::fd, FDEV, uv_stdio_container_s::flags, FOPEN, FPIPE, HANDLE, i, INVALID_HANDLE_VALUE, loop, NULL, options, uv_stdio_container_s::stream, uv__create_nul_handle(), uv__create_stdio_pipe_pair(), uv__duplicate_fd(), uv__duplicate_handle(), uv__malloc(), uv__stdio_destroy(), UV_CREATE_PIPE, UV_HANDLE_CONNECTION, UV_HANDLE_PIPESERVER, UV_IGNORE, UV_INHERIT_FD, and UV_INHERIT_STREAM.

Referenced by uv_spawn().

uv__stdio_destroy()

void uv__stdio_destroy

(

BYTE *

buffer

)

Definition at line 453 of file process-stdio.c.

                                     {
  int i, count;
 
  count = CHILD_STDIO_COUNT(buffer);
  for (i = 0; i < count; i++) {
    HANDLE handle = CHILD_STDIO_HANDLE(buffer, i);
    if (handle != INVALID_HANDLE_VALUE) {
      CloseHandle(handle);
    }
  }
 
  uv__free(buffer);
}

References CHILD_STDIO_COUNT, CHILD_STDIO_HANDLE, count, handle, HANDLE, i, INVALID_HANDLE_VALUE, and uv__free().

Referenced by uv__stdio_create(), and uv_spawn().

uv__stdio_handle()

HANDLE uv__stdio_handle	(	BYTE *	buffer,
		int	fd
	)

Definition at line 510 of file process-stdio.c.

                                              {
  return CHILD_STDIO_HANDLE(buffer, fd);
}

References CHILD_STDIO_HANDLE, and fd.

Referenced by uv_spawn().

uv__stdio_noinherit()

void uv__stdio_noinherit

(

BYTE *

buffer

)

Definition at line 468 of file process-stdio.c.

                                       {
  int i, count;
 
  count = CHILD_STDIO_COUNT(buffer);
  for (i = 0; i < count; i++) {
    HANDLE handle = CHILD_STDIO_HANDLE(buffer, i);
    if (handle != INVALID_HANDLE_VALUE) {
      SetHandleInformation(handle, HANDLE_FLAG_INHERIT, 0);
    }
  }
}

References CHILD_STDIO_COUNT, CHILD_STDIO_HANDLE, count, handle, HANDLE, i, and INVALID_HANDLE_VALUE.

Referenced by uv_disable_stdio_inheritance().

uv__stdio_size()

WORD uv__stdio_size

(

BYTE *

buffer

)

Definition at line 505 of file process-stdio.c.

                                  {
  return (WORD) CHILD_STDIO_SIZE(CHILD_STDIO_COUNT((buffer)));
}

References CHILD_STDIO_COUNT, and CHILD_STDIO_SIZE.

Referenced by uv_spawn().

uv__stdio_verify()

int uv__stdio_verify	(	BYTE *	buffer,
		WORD	size
	)

Definition at line 481 of file process-stdio.c.

                                              {
  unsigned int count;
 
  /* Check the buffer pointer. */
  if (buffer == NULL)
    return 0;
 
  /* Verify that the buffer is at least big enough to hold the count. */
  if (size < CHILD_STDIO_SIZE(0))
    return 0;
 
  /* Verify if the count is within range. */
  count = CHILD_STDIO_COUNT(buffer);
  if (count > 256)
    return 0;
 
  /* Verify that the buffer size is big enough to hold info for N FDs. */
  if (size < CHILD_STDIO_SIZE(count))
    return 0;
 
  return 1;
}

References CHILD_STDIO_COUNT, CHILD_STDIO_SIZE, count, and NULL.

Referenced by uv_disable_stdio_inheritance().

uv__tcp_try_write()

int uv__tcp_try_write	(	uv_tcp_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs
	)

Definition at line 968 of file tcp.c.

                                         {
  int result;
  DWORD bytes;
 
  if (handle->stream.conn.write_reqs_pending > 0)
    return UV_EAGAIN;
 
  result = WSASend(handle->socket,
                   (WSABUF*) bufs,
                   nbufs,
                   &bytes,
                   0,
                   NULL,
                   NULL);
 
  if (result == SOCKET_ERROR)
    return uv_translate_sys_error(WSAGetLastError());
  else
    return bytes;
}

References bufs, bytes, DWORD, handle, NULL, and uv_translate_sys_error().

Referenced by uv_try_write().

uv__tcp_xfer_export()

int uv__tcp_xfer_export	(	uv_tcp_t *	handle,
		int	pid,
		uv__ipc_socket_xfer_type_t *	xfer_type,
		uv__ipc_socket_xfer_info_t *	xfer_info
	)

Definition at line 1242 of file tcp.c.

                                                               {
  if (handle->flags & UV_HANDLE_CONNECTION) {
    *xfer_type = UV__IPC_SOCKET_XFER_TCP_CONNECTION;
  } else {
    *xfer_type = UV__IPC_SOCKET_XFER_TCP_SERVER;
    /* We're about to share the socket with another process. Because this is a
     * listening socket, we assume that the other process will be accepting
     * connections on it. Thus, before sharing the socket with another process,
     * we call listen here in the parent process. */
    if (!(handle->flags & UV_HANDLE_LISTENING)) {
      if (!(handle->flags & UV_HANDLE_BOUND)) {
        return ERROR_NOT_SUPPORTED;
      }
      if (handle->delayed_error == 0 &&
          listen(handle->socket, SOMAXCONN) == SOCKET_ERROR) {
        handle->delayed_error = WSAGetLastError();
      }
    }
  }
 
  if (WSADuplicateSocketW(handle->socket, target_pid, &xfer_info->socket_info))
    return WSAGetLastError();
  xfer_info->delayed_error = handle->delayed_error;
 
  /* Mark the local copy of the handle as 'shared' so we behave in a way that's
   * friendly to the process(es) that we share the socket with. */
  handle->flags |= UV_HANDLE_SHARED_TCP_SOCKET;
 
  return 0;
}

References uv__ipc_socket_xfer_info_t::delayed_error, handle, listen, uv__ipc_socket_xfer_info_t::socket_info, UV__IPC_SOCKET_XFER_TCP_CONNECTION, UV__IPC_SOCKET_XFER_TCP_SERVER, UV_HANDLE_BOUND, UV_HANDLE_CONNECTION, UV_HANDLE_LISTENING, and UV_HANDLE_SHARED_TCP_SOCKET.

Referenced by uv__pipe_write_ipc().

uv__tcp_xfer_import()

int uv__tcp_xfer_import	(	uv_tcp_t *	tcp,
		uv__ipc_socket_xfer_type_t	xfer_type,
		uv__ipc_socket_xfer_info_t *	xfer_info
	)

Definition at line 1277 of file tcp.c.

                                                               {
  int err;
  SOCKET socket;
 
  assert(xfer_type == UV__IPC_SOCKET_XFER_TCP_SERVER ||
         xfer_type == UV__IPC_SOCKET_XFER_TCP_CONNECTION);
 
  socket = WSASocketW(FROM_PROTOCOL_INFO,
                      FROM_PROTOCOL_INFO,
                      FROM_PROTOCOL_INFO,
                      &xfer_info->socket_info,
                      0,
                      WSA_FLAG_OVERLAPPED);
 
  if (socket == INVALID_SOCKET) {
    return WSAGetLastError();
  }
 
  err = uv_tcp_set_socket(
      tcp->loop, tcp, socket, xfer_info->socket_info.iAddressFamily, 1);
  if (err) {
    closesocket(socket);
    return err;
  }
 
  tcp->delayed_error = xfer_info->delayed_error;
  tcp->flags |= UV_HANDLE_BOUND | UV_HANDLE_SHARED_TCP_SOCKET;
 
  if (xfer_type == UV__IPC_SOCKET_XFER_TCP_CONNECTION) {
    uv_connection_init((uv_stream_t*)tcp);
    tcp->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
  }
 
  tcp->loop->active_tcp_streams++;
  return 0;
}

References assert(), uv__ipc_socket_xfer_info_t::delayed_error, err, socket, uv__ipc_socket_xfer_info_t::socket_info, UV__IPC_SOCKET_XFER_TCP_CONNECTION, UV__IPC_SOCKET_XFER_TCP_SERVER, uv_connection_init(), UV_HANDLE_BOUND, UV_HANDLE_READABLE, UV_HANDLE_SHARED_TCP_SOCKET, UV_HANDLE_WRITABLE, and uv_tcp_set_socket().

Referenced by uv_pipe_accept().

uv__tty_try_write()

int uv__tty_try_write	(	uv_tty_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs
	)

Definition at line 2212 of file tty.c.

                                          {
  DWORD error;
 
  if (handle->stream.conn.write_reqs_pending > 0)
    return UV_EAGAIN;
 
  if (uv_tty_write_bufs(handle, bufs, nbufs, &error))
    return uv_translate_sys_error(error);
 
  return uv__count_bufs(bufs, nbufs);
}

References bufs, DWORD, error(), handle, uv__count_bufs(), uv_translate_sys_error(), and uv_tty_write_bufs().

Referenced by uv_try_write().

uv__util_init()

void uv__util_init

(

void

)

Definition at line 79 of file util.c.

                         {
  LARGE_INTEGER perf_frequency;
 
  /* Initialize process title access mutex. */
  InitializeCriticalSection(&process_title_lock);
 
  /* Retrieve high-resolution timer frequency
   * and precompute its reciprocal.
   */
  if (QueryPerformanceFrequency(&perf_frequency)) {
    hrtime_frequency_ = perf_frequency.QuadPart;
  } else {
    uv_fatal_error(GetLastError(), "QueryPerformanceFrequency");
  }
}

References hrtime_frequency_, process_title_lock, and uv_fatal_error().

Referenced by uv_init().

uv__wake_all_loops()

void uv__wake_all_loops

(

void

)

Definition at line 162 of file core.c.

                              {
  int i;
  uv_loop_t* loop;
 
  uv_mutex_lock(&uv__loops_lock);
  for (i = 0; i < uv__loops_size; ++i) {
    loop = uv__loops[i];
    assert(loop);
    if (loop->iocp != INVALID_HANDLE_VALUE)
      PostQueuedCompletionStatus(loop->iocp, 0, 0, NULL);
  }
  uv_mutex_unlock(&uv__loops_lock);
}

References assert(), i, INVALID_HANDLE_VALUE, loop, NULL, uv__loops, uv__loops_lock, uv__loops_size, uv_mutex_lock(), and uv_mutex_unlock().

Referenced by uv__system_resume_callback().

uv_async_close()

void uv_async_close	(	uv_loop_t *	loop,
		uv_async_t *	handle
	)

Definition at line 57 of file async.c.

                                                         {
  if (!((uv_async_t*)handle)->async_sent) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
 
  uv__handle_closing(handle);
}

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

Referenced by uv_close().

uv_async_endgame()

void uv_async_endgame	(	uv_loop_t *	loop,
		uv_async_t *	handle
	)

Definition at line 31 of file async.c.

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

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

Referenced by uv_process_endgames().

uv_check_invoke()

void uv_check_invoke

(

uv_loop_t *

loop

)

Referenced by uv_run().

uv_console_init()

void uv_console_init

(

void

)

Definition at line 166 of file tty.c.

                           {
  if (uv_sem_init(&uv_tty_output_lock, 1))
    abort();
  uv__tty_console_handle = CreateFileW(L"CONOUT$",
                                       GENERIC_READ | GENERIC_WRITE,
                                       FILE_SHARE_WRITE,
                                       0,
                                       OPEN_EXISTING,
                                       0,
                                       0);
  if (uv__tty_console_handle != INVALID_HANDLE_VALUE) {
    CONSOLE_SCREEN_BUFFER_INFO sb_info;
    QueueUserWorkItem(uv__tty_console_resize_message_loop_thread,
                      NULL,
                      WT_EXECUTELONGFUNCTION);
    uv_mutex_init(&uv__tty_console_resize_mutex);
    if (GetConsoleScreenBufferInfo(uv__tty_console_handle, &sb_info)) {
      uv__tty_console_width = sb_info.dwSize.X;
      uv__tty_console_height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1;
    }
  }
}

References INVALID_HANDLE_VALUE, L, NULL, uv__tty_console_handle, uv__tty_console_height, uv__tty_console_resize_message_loop_thread(), uv__tty_console_resize_mutex, uv__tty_console_width, uv_mutex_init(), uv_sem_init(), and uv_tty_output_lock.

Referenced by uv_init().

uv_fs_event_close()

void uv_fs_event_close	(	uv_loop_t *	loop,
		uv_fs_event_t *	handle
	)

Definition at line 585 of file fs-event.c.

                                                               {
  uv_fs_event_stop(handle);
 
  uv__handle_closing(handle);
 
  if (!handle->req_pending) {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  }
 
}

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

Referenced by uv_close().

uv_fs_event_endgame()

void uv_fs_event_endgame	(	uv_loop_t *	loop,
		uv_fs_event_t *	handle
	)

Definition at line 597 of file fs-event.c.

                                                                 {
  if ((handle->flags & UV_HANDLE_CLOSING) && !handle->req_pending) {
    assert(!(handle->flags & UV_HANDLE_CLOSED));
 
    if (handle->buffer) {
      uv__free(handle->buffer);
      handle->buffer = NULL;
    }
 
    uv__handle_close(handle);
  }
}

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

Referenced by uv_process_endgames().

uv_fs_init()

void uv_fs_init

(

void

)

Definition at line 141 of file fs.c.

                      {
  SYSTEM_INFO system_info;
 
  GetSystemInfo(&system_info);
  uv__allocation_granularity = system_info.dwAllocationGranularity;
 
  uv__fd_hash_init();
}

References uv__allocation_granularity, and uv__fd_hash_init().

Referenced by uv_init().

uv_get_acceptex_function()

BOOL uv_get_acceptex_function	(	SOCKET	socket,
		LPFN_ACCEPTEX *	target
	)

Definition at line 65 of file winsock.c.

                                                                    {
  const GUID wsaid_acceptex = WSAID_ACCEPTEX;
  return uv_get_extension_function(socket, wsaid_acceptex, (void**)target);
}

References socket, uv_get_extension_function(), and WSAID_ACCEPTEX.

Referenced by uv_tcp_listen().

uv_get_connectex_function()

BOOL uv_get_connectex_function	(	SOCKET	socket,
		LPFN_CONNECTEX *	target
	)

Definition at line 71 of file winsock.c.

                                                                      {
  const GUID wsaid_connectex = WSAID_CONNECTEX;
  return uv_get_extension_function(socket, wsaid_connectex, (void**)target);
}

References socket, uv_get_extension_function(), and WSAID_CONNECTEX.

Referenced by uv_tcp_try_connect().

uv_idle_invoke()

void uv_idle_invoke

(

uv_loop_t *

loop

)

Referenced by uv_run().

uv_loop_watcher_endgame()

void uv_loop_watcher_endgame	(	uv_loop_t *	loop,
		uv_handle_t *	handle
	)

Definition at line 29 of file loop-watcher.c.

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

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

Referenced by uv_process_endgames().

uv_msafd_poll()

int WSAAPI uv_msafd_poll	(	SOCKET	socket,
		AFD_POLL_INFO *	info_in,
		AFD_POLL_INFO *	info_out,
		OVERLAPPED *	overlapped
	)

Definition at line 461 of file winsock.c.

                                                     {
  IO_STATUS_BLOCK iosb;
  IO_STATUS_BLOCK* iosb_ptr;
  HANDLE event = NULL;
  void* apc_context;
  NTSTATUS status;
  DWORD error;
 
  if (overlapped != NULL) {
    /* Overlapped operation. */
    iosb_ptr = (IO_STATUS_BLOCK*) &overlapped->Internal;
    event = overlapped->hEvent;
 
    /* Do not report iocp completion if hEvent is tagged. */
    if ((uintptr_t) event & 1) {
      event = (HANDLE)((uintptr_t) event & ~(uintptr_t) 1);
      apc_context = NULL;
    } else {
      apc_context = overlapped;
    }
 
  } else {
    /* Blocking operation. */
    iosb_ptr = &iosb;
    event = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (event == NULL) {
      return SOCKET_ERROR;
    }
    apc_context = NULL;
  }
 
  iosb_ptr->Status = STATUS_PENDING;
  status = pNtDeviceIoControlFile((HANDLE) socket,
                                  event,
                                  NULL,
                                  apc_context,
                                  iosb_ptr,
                                  IOCTL_AFD_POLL,
                                  info_in,
                                  sizeof *info_in,
                                  info_out,
                                  sizeof *info_out);
 
  if (overlapped == NULL) {
    /* If this is a blocking operation, wait for the event to become signaled,
     * and then grab the real status from the io status block. */
    if (status == STATUS_PENDING) {
      DWORD r = WaitForSingleObject(event, INFINITE);
 
      if (r == WAIT_FAILED) {
        DWORD saved_error = GetLastError();
        CloseHandle(event);
        WSASetLastError(saved_error);
        return SOCKET_ERROR;
      }
 
      status = iosb.Status;
    }
 
    CloseHandle(event);
  }
 
  switch (status) {
    case STATUS_SUCCESS:
      error = ERROR_SUCCESS;
      break;
 
    case STATUS_PENDING:
      error = WSA_IO_PENDING;
      break;
 
    default:
      error = uv_ntstatus_to_winsock_error(status);
      break;
  }
 
  WSASetLastError(error);
 
  if (error == ERROR_SUCCESS) {
    return 0;
  } else {
    return SOCKET_ERROR;
  }
}

References DWORD, error(), FALSE, HANDLE, if(), IOCTL_AFD_POLL, NULL, pNtDeviceIoControlFile, r, socket, status, _IO_STATUS_BLOCK::Status, STATUS_PENDING, STATUS_SUCCESS, and uv_ntstatus_to_winsock_error().

Referenced by uv__fast_poll_submit_poll_req(), and uv_poll_close().

uv_ntstatus_to_winsock_error()

int uv_ntstatus_to_winsock_error

(

NTSTATUS

status

)

Definition at line 137 of file winsock.c.

                                                  {
  switch (status) {
    case STATUS_SUCCESS:
      return ERROR_SUCCESS;
 
    case STATUS_PENDING:
      return ERROR_IO_PENDING;
 
    case STATUS_INVALID_HANDLE:
    case STATUS_OBJECT_TYPE_MISMATCH:
      return WSAENOTSOCK;
 
    case STATUS_INSUFFICIENT_RESOURCES:
    case STATUS_PAGEFILE_QUOTA:
    case STATUS_COMMITMENT_LIMIT:
    case STATUS_WORKING_SET_QUOTA:
    case STATUS_NO_MEMORY:
    case STATUS_QUOTA_EXCEEDED:
    case STATUS_TOO_MANY_PAGING_FILES:
    case STATUS_REMOTE_RESOURCES:
      return WSAENOBUFS;
 
    case STATUS_TOO_MANY_ADDRESSES:
    case STATUS_SHARING_VIOLATION:
    case STATUS_ADDRESS_ALREADY_EXISTS:
      return WSAEADDRINUSE;
 
    case STATUS_LINK_TIMEOUT:
    case STATUS_IO_TIMEOUT:
    case STATUS_TIMEOUT:
      return WSAETIMEDOUT;
 
    case STATUS_GRACEFUL_DISCONNECT:
      return WSAEDISCON;
 
    case STATUS_REMOTE_DISCONNECT:
    case STATUS_CONNECTION_RESET:
    case STATUS_LINK_FAILED:
    case STATUS_CONNECTION_DISCONNECTED:
    case STATUS_PORT_UNREACHABLE:
    case STATUS_HOPLIMIT_EXCEEDED:
      return WSAECONNRESET;
 
    case STATUS_LOCAL_DISCONNECT:
    case STATUS_TRANSACTION_ABORTED:
    case STATUS_CONNECTION_ABORTED:
      return WSAECONNABORTED;
 
    case STATUS_BAD_NETWORK_PATH:
    case STATUS_NETWORK_UNREACHABLE:
    case STATUS_PROTOCOL_UNREACHABLE:
      return WSAENETUNREACH;
 
    case STATUS_HOST_UNREACHABLE:
      return WSAEHOSTUNREACH;
 
    case STATUS_CANCELLED:
    case STATUS_REQUEST_ABORTED:
      return WSAEINTR;
 
    case STATUS_BUFFER_OVERFLOW:
    case STATUS_INVALID_BUFFER_SIZE:
      return WSAEMSGSIZE;
 
    case STATUS_BUFFER_TOO_SMALL:
    case STATUS_ACCESS_VIOLATION:
      return WSAEFAULT;
 
    case STATUS_DEVICE_NOT_READY:
    case STATUS_REQUEST_NOT_ACCEPTED:
      return WSAEWOULDBLOCK;
 
    case STATUS_INVALID_NETWORK_RESPONSE:
    case STATUS_NETWORK_BUSY:
    case STATUS_NO_SUCH_DEVICE:
    case STATUS_NO_SUCH_FILE:
    case STATUS_OBJECT_PATH_NOT_FOUND:
    case STATUS_OBJECT_NAME_NOT_FOUND:
    case STATUS_UNEXPECTED_NETWORK_ERROR:
      return WSAENETDOWN;
 
    case STATUS_INVALID_CONNECTION:
      return WSAENOTCONN;
 
    case STATUS_REMOTE_NOT_LISTENING:
    case STATUS_CONNECTION_REFUSED:
      return WSAECONNREFUSED;
 
    case STATUS_PIPE_DISCONNECTED:
      return WSAESHUTDOWN;
 
    case STATUS_CONFLICTING_ADDRESSES:
    case STATUS_INVALID_ADDRESS:
    case STATUS_INVALID_ADDRESS_COMPONENT:
      return WSAEADDRNOTAVAIL;
 
    case STATUS_NOT_SUPPORTED:
    case STATUS_NOT_IMPLEMENTED:
      return WSAEOPNOTSUPP;
 
    case STATUS_ACCESS_DENIED:
      return WSAEACCES;
 
    default:
      if ((status & (FACILITY_NTWIN32 << 16)) == (FACILITY_NTWIN32 << 16) &&
          (status & (ERROR_SEVERITY_ERROR | ERROR_SEVERITY_WARNING))) {
        /* It's a windows error that has been previously mapped to an ntstatus
         * code. */
        return (DWORD) (status & 0xffff);
      } else {
        /* The default fallback for unmappable ntstatus codes. */
        return WSAEINVAL;
      }
  }
}

References DWORD, FACILITY_NTWIN32, status, STATUS_ACCESS_DENIED, STATUS_ACCESS_VIOLATION, STATUS_ADDRESS_ALREADY_EXISTS, STATUS_BAD_NETWORK_PATH, STATUS_BUFFER_OVERFLOW, STATUS_BUFFER_TOO_SMALL, STATUS_CANCELLED, STATUS_COMMITMENT_LIMIT, STATUS_CONFLICTING_ADDRESSES, STATUS_CONNECTION_ABORTED, STATUS_CONNECTION_DISCONNECTED, STATUS_CONNECTION_REFUSED, STATUS_CONNECTION_RESET, STATUS_DEVICE_NOT_READY, STATUS_GRACEFUL_DISCONNECT, STATUS_HOPLIMIT_EXCEEDED, STATUS_HOST_UNREACHABLE, STATUS_INSUFFICIENT_RESOURCES, STATUS_INVALID_ADDRESS, STATUS_INVALID_ADDRESS_COMPONENT, STATUS_INVALID_BUFFER_SIZE, STATUS_INVALID_CONNECTION, STATUS_INVALID_HANDLE, STATUS_INVALID_NETWORK_RESPONSE, STATUS_IO_TIMEOUT, STATUS_LINK_FAILED, STATUS_LINK_TIMEOUT, STATUS_LOCAL_DISCONNECT, STATUS_NETWORK_BUSY, STATUS_NETWORK_UNREACHABLE, STATUS_NO_MEMORY, STATUS_NO_SUCH_DEVICE, STATUS_NO_SUCH_FILE, STATUS_NOT_IMPLEMENTED, STATUS_NOT_SUPPORTED, STATUS_OBJECT_NAME_NOT_FOUND, STATUS_OBJECT_PATH_NOT_FOUND, STATUS_OBJECT_TYPE_MISMATCH, STATUS_PAGEFILE_QUOTA, STATUS_PENDING, STATUS_PIPE_DISCONNECTED, STATUS_PORT_UNREACHABLE, STATUS_PROTOCOL_UNREACHABLE, STATUS_QUOTA_EXCEEDED, STATUS_REMOTE_DISCONNECT, STATUS_REMOTE_NOT_LISTENING, STATUS_REMOTE_RESOURCES, STATUS_REQUEST_ABORTED, STATUS_REQUEST_NOT_ACCEPTED, STATUS_SHARING_VIOLATION, STATUS_SUCCESS, STATUS_TIMEOUT, STATUS_TOO_MANY_ADDRESSES, STATUS_TOO_MANY_PAGING_FILES, STATUS_TRANSACTION_ABORTED, STATUS_UNEXPECTED_NETWORK_ERROR, and STATUS_WORKING_SET_QUOTA.

Referenced by uv_msafd_poll(), uv_wsarecv_workaround(), and uv_wsarecvfrom_workaround().

uv_pipe_accept()

int uv_pipe_accept	(	uv_pipe_t *	server,
		uv_stream_t *	client
	)

Definition at line 876 of file pipe.c.

                                                           {
  uv_loop_t* loop = server->loop;
  uv_pipe_t* pipe_client;
  uv_pipe_accept_t* req;
  QUEUE* q;
  uv__ipc_xfer_queue_item_t* item;
  int err;
 
  if (server->ipc) {
    if (QUEUE_EMPTY(&server->pipe.conn.ipc_xfer_queue)) {
      /* No valid pending sockets. */
      return WSAEWOULDBLOCK;
    }
 
    q = QUEUE_HEAD(&server->pipe.conn.ipc_xfer_queue);
    QUEUE_REMOVE(q);
    server->pipe.conn.ipc_xfer_queue_length--;
    item = QUEUE_DATA(q, uv__ipc_xfer_queue_item_t, member);
 
    err = uv__tcp_xfer_import(
        (uv_tcp_t*) client, item->xfer_type, &item->xfer_info);
    if (err != 0)
      return err;
 
    uv__free(item);
 
  } else {
    pipe_client = (uv_pipe_t*) client;
 
    /* Find a connection instance that has been connected, but not yet
     * accepted. */
    req = server->pipe.serv.pending_accepts;
 
    if (!req) {
      /* No valid connections found, so we error out. */
      return WSAEWOULDBLOCK;
    }
 
    /* Initialize the client handle and copy the pipeHandle to the client */
    uv_pipe_connection_init(pipe_client);
    pipe_client->handle = req->pipeHandle;
    pipe_client->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
 
    /* Prepare the req to pick up a new connection */
    server->pipe.serv.pending_accepts = req->next_pending;
    req->next_pending = NULL;
    req->pipeHandle = INVALID_HANDLE_VALUE;
 
    server->handle = INVALID_HANDLE_VALUE;
    if (!(server->flags & UV_HANDLE_CLOSING)) {
      uv_pipe_queue_accept(loop, server, req, FALSE);
    }
  }
 
  return 0;
}

References err, FALSE, INVALID_HANDLE_VALUE, uv_pipe_s::ipc, loop, NULL, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_REMOVE, req, uv__free(), uv__tcp_xfer_import(), UV_HANDLE_CLOSING, UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, uv_pipe_connection_init(), uv_pipe_queue_accept(), uv__ipc_xfer_queue_item_t::xfer_info, and uv__ipc_xfer_queue_item_t::xfer_type.

Referenced by uv_accept().

uv_pipe_cleanup()

void uv_pipe_cleanup	(	uv_loop_t *	loop,
		uv_pipe_t *	handle
	)

Definition at line 785 of file pipe.c.

                                                         {
  int i;
  HANDLE pipeHandle;
 
  uv__pipe_interrupt_read(handle);
 
  if (handle->name) {
    uv__free(handle->name);
    handle->name = NULL;
  }
 
  if (handle->flags & UV_HANDLE_PIPESERVER) {
    for (i = 0; i < handle->pipe.serv.pending_instances; i++) {
      pipeHandle = handle->pipe.serv.accept_reqs[i].pipeHandle;
      if (pipeHandle != INVALID_HANDLE_VALUE) {
        CloseHandle(pipeHandle);
        handle->pipe.serv.accept_reqs[i].pipeHandle = INVALID_HANDLE_VALUE;
      }
    }
    handle->handle = INVALID_HANDLE_VALUE;
  }
 
  if (handle->flags & UV_HANDLE_CONNECTION) {
    handle->flags &= ~UV_HANDLE_WRITABLE;
    eof_timer_destroy(handle);
  }
 
  if ((handle->flags & UV_HANDLE_CONNECTION)
      && handle->handle != INVALID_HANDLE_VALUE)
    close_pipe(handle);
}

References close_pipe(), eof_timer_destroy(), handle, HANDLE, i, INVALID_HANDLE_VALUE, NULL, uv__free(), uv__pipe_interrupt_read(), UV_HANDLE_CONNECTION, UV_HANDLE_PIPESERVER, and UV_HANDLE_WRITABLE.

Referenced by uv__create_stdio_pipe_pair(), and uv_pipe_close().

uv_pipe_close()

void uv_pipe_close	(	uv_loop_t *	loop,
		uv_pipe_t *	handle
	)

Definition at line 818 of file pipe.c.

                                                       {
  if (handle->flags & UV_HANDLE_READING) {
    handle->flags &= ~UV_HANDLE_READING;
    DECREASE_ACTIVE_COUNT(loop, handle);
  }
 
  if (handle->flags & UV_HANDLE_LISTENING) {
    handle->flags &= ~UV_HANDLE_LISTENING;
    DECREASE_ACTIVE_COUNT(loop, handle);
  }
 
  uv_pipe_cleanup(loop, handle);
 
  if (handle->reqs_pending == 0) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
 
  handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
  uv__handle_closing(handle);
}

References DECREASE_ACTIVE_COUNT, handle, loop, uv__handle_closing, UV_HANDLE_LISTENING, UV_HANDLE_READABLE, UV_HANDLE_READING, UV_HANDLE_WRITABLE, uv_pipe_cleanup(), and uv_want_endgame().

Referenced by uv_close().

uv_pipe_endgame()

void uv_pipe_endgame	(	uv_loop_t *	loop,
		uv_pipe_t *	handle
	)

Definition at line 382 of file pipe.c.

                                                         {
  int err;
  DWORD result;
  uv_shutdown_t* req;
  NTSTATUS nt_status;
  IO_STATUS_BLOCK io_status;
  FILE_PIPE_LOCAL_INFORMATION pipe_info;
  uv__ipc_xfer_queue_item_t* xfer_queue_item;
 
  if ((handle->flags & UV_HANDLE_CONNECTION) &&
      handle->stream.conn.shutdown_req != NULL &&
      handle->stream.conn.write_reqs_pending == 0) {
    req = handle->stream.conn.shutdown_req;
 
    /* Clear the shutdown_req field so we don't go here again. */
    handle->stream.conn.shutdown_req = NULL;
 
    if (handle->flags & UV_HANDLE_CLOSING) {
      UNREGISTER_HANDLE_REQ(loop, handle, req);
 
      /* Already closing. Cancel the shutdown. */
      if (req->cb) {
        req->cb(req, UV_ECANCELED);
      }
 
      DECREASE_PENDING_REQ_COUNT(handle);
      return;
    }
 
    /* Try to avoid flushing the pipe buffer in the thread pool. */
    nt_status = pNtQueryInformationFile(handle->handle,
                                        &io_status,
                                        &pipe_info,
                                        sizeof pipe_info,
                                        FilePipeLocalInformation);
 
    if (nt_status != STATUS_SUCCESS) {
      /* Failure */
      UNREGISTER_HANDLE_REQ(loop, handle, req);
 
      handle->flags |= UV_HANDLE_WRITABLE; /* Questionable */
      if (req->cb) {
        err = pRtlNtStatusToDosError(nt_status);
        req->cb(req, uv_translate_sys_error(err));
      }
 
      DECREASE_PENDING_REQ_COUNT(handle);
      return;
    }
 
    if (pipe_info.OutboundQuota == pipe_info.WriteQuotaAvailable) {
      /* Short-circuit, no need to call FlushFileBuffers. */
      uv_insert_pending_req(loop, (uv_req_t*) req);
      return;
    }
 
    /* Run FlushFileBuffers in the thread pool. */
    result = QueueUserWorkItem(pipe_shutdown_thread_proc,
                               req,
                               WT_EXECUTELONGFUNCTION);
    if (result) {
      return;
 
    } else {
      /* Failure. */
      UNREGISTER_HANDLE_REQ(loop, handle, req);
 
      handle->flags |= UV_HANDLE_WRITABLE; /* Questionable */
      if (req->cb) {
        err = GetLastError();
        req->cb(req, uv_translate_sys_error(err));
      }
 
      DECREASE_PENDING_REQ_COUNT(handle);
      return;
    }
  }
 
  if (handle->flags & UV_HANDLE_CLOSING &&
      handle->reqs_pending == 0) {
    assert(!(handle->flags & UV_HANDLE_CLOSED));
 
    if (handle->flags & UV_HANDLE_CONNECTION) {
      /* Free pending sockets */
      while (!QUEUE_EMPTY(&handle->pipe.conn.ipc_xfer_queue)) {
        QUEUE* q;
        SOCKET socket;
 
        q = QUEUE_HEAD(&handle->pipe.conn.ipc_xfer_queue);
        QUEUE_REMOVE(q);
        xfer_queue_item = QUEUE_DATA(q, uv__ipc_xfer_queue_item_t, member);
 
        /* Materialize socket and close it */
        socket = WSASocketW(FROM_PROTOCOL_INFO,
                            FROM_PROTOCOL_INFO,
                            FROM_PROTOCOL_INFO,
                            &xfer_queue_item->xfer_info.socket_info,
                            0,
                            WSA_FLAG_OVERLAPPED);
        uv__free(xfer_queue_item);
 
        if (socket != INVALID_SOCKET)
          closesocket(socket);
      }
      handle->pipe.conn.ipc_xfer_queue_length = 0;
 
      if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
        if (handle->read_req.wait_handle != INVALID_HANDLE_VALUE) {
          UnregisterWait(handle->read_req.wait_handle);
          handle->read_req.wait_handle = INVALID_HANDLE_VALUE;
        }
        if (handle->read_req.event_handle != NULL) {
          CloseHandle(handle->read_req.event_handle);
          handle->read_req.event_handle = NULL;
        }
      }
 
      if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE)
        DeleteCriticalSection(&handle->pipe.conn.readfile_thread_lock);
    }
 
    if (handle->flags & UV_HANDLE_PIPESERVER) {
      assert(handle->pipe.serv.accept_reqs);
      uv__free(handle->pipe.serv.accept_reqs);
      handle->pipe.serv.accept_reqs = NULL;
    }
 
    uv__handle_close(handle);
  }
}

References assert(), DECREASE_PENDING_REQ_COUNT, DWORD, err, FilePipeLocalInformation, handle, INVALID_HANDLE_VALUE, loop, NULL, _FILE_PIPE_LOCAL_INFORMATION::OutboundQuota, pipe_shutdown_thread_proc(), pNtQueryInformationFile, pRtlNtStatusToDosError, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_REMOVE, req, socket, uv__ipc_socket_xfer_info_t::socket_info, STATUS_SUCCESS, UNREGISTER_HANDLE_REQ, uv__free(), uv__handle_close, UV_HANDLE_CLOSED, UV_HANDLE_CLOSING, UV_HANDLE_CONNECTION, UV_HANDLE_EMULATE_IOCP, UV_HANDLE_NON_OVERLAPPED_PIPE, UV_HANDLE_PIPESERVER, UV_HANDLE_WRITABLE, uv_insert_pending_req(), uv_translate_sys_error(), _FILE_PIPE_LOCAL_INFORMATION::WriteQuotaAvailable, and uv__ipc_xfer_queue_item_t::xfer_info.

Referenced by uv_process_endgames().

uv_pipe_listen()

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

Definition at line 94 of file pipe.c.

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

References assert(), cb, handle, i, INCREASE_ACTIVE_COUNT, INVALID_HANDLE_VALUE, loop, UV_HANDLE_BOUND, UV_HANDLE_LISTENING, UV_HANDLE_PIPESERVER, UV_HANDLE_READING, and uv_pipe_queue_accept().

uv_pipe_read_start()

int uv_pipe_read_start	(	uv_pipe_t *	handle,
		uv_alloc_cb	alloc_cb,
		uv_read_cb	read_cb
	)

Definition at line 1177 of file pipe.c.

                                           {
  uv_loop_t* loop = handle->loop;
 
  handle->flags |= UV_HANDLE_READING;
  INCREASE_ACTIVE_COUNT(loop, handle);
  handle->read_cb = read_cb;
  handle->alloc_cb = alloc_cb;
 
  /* If reading was stopped and then started again, there could still be a read
   * request pending. */
  if (!(handle->flags & UV_HANDLE_READ_PENDING)) {
    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
        handle->read_req.event_handle == NULL) {
      handle->read_req.event_handle = CreateEvent(NULL, 0, 0, NULL);
      if (handle->read_req.event_handle == NULL) {
        uv_fatal_error(GetLastError(), "CreateEvent");
      }
    }
    uv_pipe_queue_read(loop, handle);
  }
 
  return 0;
}

References handle, INCREASE_ACTIVE_COUNT, loop, NULL, uv_fatal_error(), UV_HANDLE_EMULATE_IOCP, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, and uv_pipe_queue_read().

Referenced by uv_read_start().

uv_poll_close()

int uv_poll_close	(	uv_loop_t *	loop,
		uv_poll_t *	handle
	)

Definition at line 535 of file poll.c.

                                                      {
  AFD_POLL_INFO afd_poll_info;
  DWORD error;
  int result;
 
  handle->events = 0;
  uv__handle_closing(handle);
 
  if (handle->submitted_events_1 == 0 &&
      handle->submitted_events_2 == 0) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
    return 0;
  }
 
  if (handle->flags & UV_HANDLE_POLL_SLOW)
    return 0;
 
  /* Cancel outstanding poll requests by executing another, unique poll
   * request that forces the outstanding ones to return. */
  afd_poll_info.Exclusive = TRUE;
  afd_poll_info.NumberOfHandles = 1;
  afd_poll_info.Timeout.QuadPart = INT64_MAX;
  afd_poll_info.Handles[0].Handle = (HANDLE) handle->socket;
  afd_poll_info.Handles[0].Status = 0;
  afd_poll_info.Handles[0].Events = AFD_POLL_ALL;
 
  result = uv_msafd_poll(handle->socket,
                         &afd_poll_info,
                         uv__get_afd_poll_info_dummy(),
                         uv__get_overlapped_dummy());
 
  if (result == SOCKET_ERROR) {
    error = WSAGetLastError();
    if (error != WSA_IO_PENDING)
      return uv_translate_sys_error(error);
  }
 
  return 0;
}

References AFD_POLL_ALL, DWORD, error(), _AFD_POLL_HANDLE_INFO::Events, _AFD_POLL_INFO::Exclusive, handle, HANDLE, _AFD_POLL_HANDLE_INFO::Handle, _AFD_POLL_INFO::Handles, INT64_MAX, loop, _AFD_POLL_INFO::NumberOfHandles, _AFD_POLL_HANDLE_INFO::Status, _AFD_POLL_INFO::Timeout, TRUE, uv__get_afd_poll_info_dummy(), uv__get_overlapped_dummy(), uv__handle_closing, UV_HANDLE_POLL_SLOW, uv_msafd_poll(), uv_translate_sys_error(), and uv_want_endgame().

Referenced by uv_close().

uv_poll_endgame()

void uv_poll_endgame	(	uv_loop_t *	loop,
		uv_poll_t *	handle
	)

Definition at line 576 of file poll.c.

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

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

Referenced by uv_process_endgames().

uv_prepare_invoke()

void uv_prepare_invoke

(

uv_loop_t *

loop

)

Referenced by uv_run().

uv_process_async_wakeup_req()

void uv_process_async_wakeup_req	(	uv_loop_t *	loop,
		uv_async_t *	handle,
		uv_req_t *	req
	)

Definition at line 86 of file async.c.

                   {
  assert(handle->type == UV_ASYNC);
  assert(req->type == UV_WAKEUP);
 
  handle->async_sent = 0;
 
  if (handle->flags & UV_HANDLE_CLOSING) {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  } else if (handle->async_cb != NULL) {
    handle->async_cb(handle);
  }
}

References assert(), handle, loop, NULL, req, UV_HANDLE_CLOSING, and uv_want_endgame().

Referenced by uv_process_reqs().

uv_process_close()

void uv_process_close	(	uv_loop_t *	loop,
		uv_process_t *	handle
	)

Definition at line 903 of file process.c.

                                                             {
  uv__handle_closing(handle);
 
  if (handle->wait_handle != INVALID_HANDLE_VALUE) {
    /* This blocks until either the wait was cancelled, or the callback has
     * completed. */
    BOOL r = UnregisterWaitEx(handle->wait_handle, INVALID_HANDLE_VALUE);
    if (!r) {
      /* This should never happen, and if it happens, we can't recover... */
      uv_fatal_error(GetLastError(), "UnregisterWaitEx");
    }
 
    handle->wait_handle = INVALID_HANDLE_VALUE;
  }
 
  if (!handle->exit_cb_pending) {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  }
}

References handle, INVALID_HANDLE_VALUE, loop, r, uv__handle_closing, uv_fatal_error(), and uv_want_endgame().

Referenced by uv_close().

uv_process_endgame()

void uv_process_endgame	(	uv_loop_t *	loop,
		uv_process_t *	handle
	)

Definition at line 924 of file process.c.

                                                               {
  assert(!handle->exit_cb_pending);
  assert(handle->flags & UV_HANDLE_CLOSING);
  assert(!(handle->flags & UV_HANDLE_CLOSED));
 
  /* Clean-up the process handle. */
  CloseHandle(handle->process_handle);
 
  uv__handle_close(handle);
}

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

Referenced by uv_process_endgames().

uv_process_fs_event_req()

void uv_process_fs_event_req	(	uv_loop_t *	loop,
		uv_req_t *	req,
		uv_fs_event_t *	handle
	)

Definition at line 426 of file fs-event.c.

                           {
  FILE_NOTIFY_INFORMATION* file_info;
  int err, sizew, size;
  char* filename = NULL;
  WCHAR* filenamew = NULL;
  WCHAR* long_filenamew = NULL;
  DWORD offset = 0;
 
  assert(req->type == UV_FS_EVENT_REQ);
  assert(handle->req_pending);
  handle->req_pending = 0;
 
  /* Don't report any callbacks if:
   * - We're closing, just push the handle onto the endgame queue
   * - We are not active, just ignore the callback
   */
  if (!uv__is_active(handle)) {
    if (handle->flags & UV_HANDLE_CLOSING) {
      uv_want_endgame(loop, (uv_handle_t*) handle);
    }
    return;
  }
 
  file_info = (FILE_NOTIFY_INFORMATION*)(handle->buffer + offset);
 
  if (REQ_SUCCESS(req)) {
    if (req->u.io.overlapped.InternalHigh > 0) {
      do {
        file_info = (FILE_NOTIFY_INFORMATION*)((char*)file_info + offset);
        assert(!filename);
        assert(!filenamew);
        assert(!long_filenamew);
 
        /*
         * Fire the event only if we were asked to watch a directory,
         * or if the filename filter matches.
         */
        if (handle->dirw ||
            file_info_cmp(handle->filew,
                          file_info->FileName,
                          file_info->FileNameLength) == 0 ||
            file_info_cmp(handle->short_filew,
                          file_info->FileName,
                          file_info->FileNameLength) == 0) {
 
          if (handle->dirw) {
            /*
             * We attempt to resolve the long form of the file name explicitly.
             * We only do this for file names that might still exist on disk.
             * If this fails, we use the name given by ReadDirectoryChangesW.
             * This may be the long form or the 8.3 short name in some cases.
             */
            if (file_info->Action != FILE_ACTION_REMOVED &&
              file_info->Action != FILE_ACTION_RENAMED_OLD_NAME) {
              /* Construct a full path to the file. */
              size = wcslen(handle->dirw) +
                file_info->FileNameLength / sizeof(WCHAR) + 2;
 
              filenamew = (WCHAR*)uv__malloc(size * sizeof(WCHAR));
              if (!filenamew) {
                uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
              }
 
              _snwprintf(filenamew, size, L"%s\\%.*s", handle->dirw,
                file_info->FileNameLength / (DWORD)sizeof(WCHAR),
                file_info->FileName);
 
              filenamew[size - 1] = L'\0';
 
              /* Convert to long name. */
              size = GetLongPathNameW(filenamew, NULL, 0);
 
              if (size) {
                long_filenamew = (WCHAR*)uv__malloc(size * sizeof(WCHAR));
                if (!long_filenamew) {
                  uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
                }
 
                size = GetLongPathNameW(filenamew, long_filenamew, size);
                if (size) {
                  long_filenamew[size] = '\0';
                } else {
                  uv__free(long_filenamew);
                  long_filenamew = NULL;
                }
              }
 
              uv__free(filenamew);
 
              if (long_filenamew) {
                /* Get the file name out of the long path. */
                uv_relative_path(long_filenamew,
                                 handle->dirw,
                                 &filenamew);
                uv__free(long_filenamew);
                long_filenamew = filenamew;
                sizew = -1;
              } else {
                /* We couldn't get the long filename, use the one reported. */
                filenamew = file_info->FileName;
                sizew = file_info->FileNameLength / sizeof(WCHAR);
              }
            } else {
              /*
               * Removed or renamed events cannot be resolved to the long form.
               * We therefore use the name given by ReadDirectoryChangesW.
               * This may be the long form or the 8.3 short name in some cases.
               */
              filenamew = file_info->FileName;
              sizew = file_info->FileNameLength / sizeof(WCHAR);
            }
          } else {
            /* We already have the long name of the file, so just use it. */
            filenamew = handle->filew;
            sizew = -1;
          }
 
          /* Convert the filename to utf8. */
          uv__convert_utf16_to_utf8(filenamew, sizew, &filename);
 
          switch (file_info->Action) {
            case FILE_ACTION_ADDED:
            case FILE_ACTION_REMOVED:
            case FILE_ACTION_RENAMED_OLD_NAME:
            case FILE_ACTION_RENAMED_NEW_NAME:
              handle->cb(handle, filename, UV_RENAME, 0);
              break;
 
            case FILE_ACTION_MODIFIED:
              handle->cb(handle, filename, UV_CHANGE, 0);
              break;
          }
 
          uv__free(filename);
          filename = NULL;
          uv__free(long_filenamew);
          long_filenamew = NULL;
          filenamew = NULL;
        }
 
        offset = file_info->NextEntryOffset;
      } while (offset && !(handle->flags & UV_HANDLE_CLOSING));
    } else {
      handle->cb(handle, NULL, UV_CHANGE, 0);
    }
  } else {
    err = GET_REQ_ERROR(req);
    handle->cb(handle, NULL, 0, uv_translate_sys_error(err));
  }
 
  if (!(handle->flags & UV_HANDLE_CLOSING)) {
    uv_fs_event_queue_readdirchanges(loop, handle);
  } else {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  }
}

References assert(), DWORD, err, file_info_cmp(), GET_REQ_ERROR, handle, L, loop, NULL, req, REQ_SUCCESS, uv__convert_utf16_to_utf8(), uv__free(), uv__is_active, uv__malloc(), UV_CHANGE, uv_fatal_error(), uv_fs_event_queue_readdirchanges(), UV_HANDLE_CLOSING, uv_relative_path(), UV_RENAME, uv_translate_sys_error(), and uv_want_endgame().

Referenced by uv_process_reqs().

uv_process_pipe_accept_req()

void uv_process_pipe_accept_req	(	uv_loop_t *	loop,
		uv_pipe_t *	handle,
		uv_req_t *	raw_req
	)

Definition at line 1910 of file pipe.c.

                       {
  uv_pipe_accept_t* req = (uv_pipe_accept_t*) raw_req;
 
  assert(handle->type == UV_NAMED_PIPE);
 
  if (handle->flags & UV_HANDLE_CLOSING) {
    /* The req->pipeHandle should be freed already in uv_pipe_cleanup(). */
    assert(req->pipeHandle == INVALID_HANDLE_VALUE);
    DECREASE_PENDING_REQ_COUNT(handle);
    return;
  }
 
  if (REQ_SUCCESS(req)) {
    assert(req->pipeHandle != INVALID_HANDLE_VALUE);
    req->next_pending = handle->pipe.serv.pending_accepts;
    handle->pipe.serv.pending_accepts = req;
 
    if (handle->stream.serv.connection_cb) {
      handle->stream.serv.connection_cb((uv_stream_t*)handle, 0);
    }
  } else {
    if (req->pipeHandle != INVALID_HANDLE_VALUE) {
      CloseHandle(req->pipeHandle);
      req->pipeHandle = INVALID_HANDLE_VALUE;
    }
    if (!(handle->flags & UV_HANDLE_CLOSING)) {
      uv_pipe_queue_accept(loop, handle, req, FALSE);
    }
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References assert(), DECREASE_PENDING_REQ_COUNT, FALSE, handle, INVALID_HANDLE_VALUE, loop, req, REQ_SUCCESS, UV_HANDLE_CLOSING, and uv_pipe_queue_accept().

uv_process_pipe_connect_req()

void uv_process_pipe_connect_req	(	uv_loop_t *	loop,
		uv_pipe_t *	handle,
		uv_connect_t *	req
	)

Definition at line 1945 of file pipe.c.

                       {
  int err;
 
  assert(handle->type == UV_NAMED_PIPE);
 
  UNREGISTER_HANDLE_REQ(loop, handle, req);
 
  if (req->cb) {
    err = 0;
    if (REQ_SUCCESS(req)) {
      uv_pipe_connection_init(handle);
    } else {
      err = GET_REQ_ERROR(req);
    }
    req->cb(req, uv_translate_sys_error(err));
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

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

uv_process_pipe_read_req()

void uv_process_pipe_read_req	(	uv_loop_t *	loop,
		uv_pipe_t *	handle,
		uv_req_t *	req
	)

Definition at line 1789 of file pipe.c.

                                             {
  assert(handle->type == UV_NAMED_PIPE);
 
  handle->flags &= ~(UV_HANDLE_READ_PENDING | UV_HANDLE_CANCELLATION_PENDING);
  DECREASE_PENDING_REQ_COUNT(handle);
  eof_timer_stop(handle);
 
  /* At this point, we're done with bookkeeping. If the user has stopped
   * reading the pipe in the meantime, there is nothing left to do, since there
   * is no callback that we can call. */
  if (!(handle->flags & UV_HANDLE_READING))
    return;
 
  if (!REQ_SUCCESS(req)) {
    /* An error occurred doing the zero-read. */
    DWORD err = GET_REQ_ERROR(req);
 
    /* If the read was cancelled by uv__pipe_interrupt_read(), the request may
     * indicate an ERROR_OPERATION_ABORTED error. This error isn't relevant to
     * the user; we'll start a new zero-read at the end of this function. */
    if (err != ERROR_OPERATION_ABORTED)
      uv_pipe_read_error_or_eof(loop, handle, err, uv_null_buf_);
 
  } else {
    /* The zero-read completed without error, indicating there is data
     * available in the kernel buffer. */
    DWORD avail;
 
    /* Get the number of bytes available. */
    avail = 0;
    if (!PeekNamedPipe(handle->handle, NULL, 0, NULL, &avail, NULL))
      uv_pipe_read_error_or_eof(loop, handle, GetLastError(), uv_null_buf_);
 
    /* Read until we've either read all the bytes available, or the 'reading'
     * flag is cleared. */
    while (avail > 0 && handle->flags & UV_HANDLE_READING) {
      /* Depending on the type of pipe, read either IPC frames or raw data. */
      DWORD bytes_read =
          handle->ipc ? uv__pipe_read_ipc(loop, handle)
                      : uv__pipe_read_data(loop, handle, avail, (DWORD) -1);
 
      /* If no bytes were read, treat this as an indication that an error
       * occurred, and break out of the read loop. */
      if (bytes_read == 0)
        break;
 
      /* It is possible that more bytes were read than we thought were
       * available. To prevent `avail` from underflowing, break out of the loop
       * if this is the case. */
      if (bytes_read > avail)
        break;
 
      /* Recompute the number of bytes available. */
      avail -= bytes_read;
    }
  }
 
  /* Start another zero-read request if necessary. */
  if ((handle->flags & UV_HANDLE_READING) &&
      !(handle->flags & UV_HANDLE_READ_PENDING)) {
    uv_pipe_queue_read(loop, handle);
  }
}

References assert(), DECREASE_PENDING_REQ_COUNT, DWORD, eof_timer_stop(), err, GET_REQ_ERROR, handle, loop, NULL, req, REQ_SUCCESS, uv__pipe_read_data(), uv__pipe_read_ipc(), UV_HANDLE_CANCELLATION_PENDING, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, uv_null_buf_, uv_pipe_queue_read(), and uv_pipe_read_error_or_eof().

uv_process_pipe_shutdown_req()

void uv_process_pipe_shutdown_req	(	uv_loop_t *	loop,
		uv_pipe_t *	handle,
		uv_shutdown_t *	req
	)

Definition at line 1967 of file pipe.c.

                        {
  assert(handle->type == UV_NAMED_PIPE);
 
  UNREGISTER_HANDLE_REQ(loop, handle, req);
 
  if (handle->flags & UV_HANDLE_READABLE) {
    /* Initialize and optionally start the eof timer. Only do this if the pipe
     * is readable and we haven't seen EOF come in ourselves. */
    eof_timer_init(handle);
 
    /* If reading start the timer right now. Otherwise uv_pipe_queue_read will
     * start it. */
    if (handle->flags & UV_HANDLE_READ_PENDING) {
      eof_timer_start(handle);
    }
 
  } else {
    /* This pipe is not readable. We can just close it to let the other end
     * know that we're done writing. */
    close_pipe(handle);
  }
 
  if (req->cb) {
    req->cb(req, 0);
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References assert(), close_pipe(), DECREASE_PENDING_REQ_COUNT, eof_timer_init(), eof_timer_start(), handle, loop, req, UNREGISTER_HANDLE_REQ, UV_HANDLE_READ_PENDING, and UV_HANDLE_READABLE.

Referenced by uv_process_reqs().

uv_process_pipe_write_req()

void uv_process_pipe_write_req	(	uv_loop_t *	loop,
		uv_pipe_t *	handle,
		uv_write_t *	req
	)

Definition at line 1856 of file pipe.c.

                     {
  int err;
 
  assert(handle->type == UV_NAMED_PIPE);
 
  assert(handle->write_queue_size >= req->u.io.queued_bytes);
  handle->write_queue_size -= req->u.io.queued_bytes;
 
  UNREGISTER_HANDLE_REQ(loop, handle, req);
 
  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
    if (req->wait_handle != INVALID_HANDLE_VALUE) {
      UnregisterWait(req->wait_handle);
      req->wait_handle = INVALID_HANDLE_VALUE;
    }
    if (req->event_handle) {
      CloseHandle(req->event_handle);
      req->event_handle = NULL;
    }
  }
 
  err = GET_REQ_ERROR(req);
 
  /* If this was a coalesced write, extract pointer to the user_provided
   * uv_write_t structure so we can pass the expected pointer to the callback,
   * then free the heap-allocated write req. */
  if (req->coalesced) {
    uv__coalesced_write_t* coalesced_write =
        container_of(req, uv__coalesced_write_t, req);
    req = coalesced_write->user_req;
    uv__free(coalesced_write);
  }
  if (req->cb) {
    req->cb(req, uv_translate_sys_error(err));
  }
 
  handle->stream.conn.write_reqs_pending--;
 
  if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE &&
      handle->pipe.conn.non_overlapped_writes_tail) {
    assert(handle->stream.conn.write_reqs_pending > 0);
    uv_queue_non_overlapped_write(handle);
  }
 
  if (handle->stream.conn.shutdown_req != NULL &&
      handle->stream.conn.write_reqs_pending == 0) {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References assert(), container_of, DECREASE_PENDING_REQ_COUNT, err, GET_REQ_ERROR, handle, INVALID_HANDLE_VALUE, loop, NULL, req, UNREGISTER_HANDLE_REQ, uv__coalesced_write_t::user_req, uv__free(), UV_HANDLE_EMULATE_IOCP, UV_HANDLE_NON_OVERLAPPED_PIPE, uv_queue_non_overlapped_write(), uv_translate_sys_error(), and uv_want_endgame().

uv_process_poll_req()

void uv_process_poll_req	(	uv_loop_t *	loop,
		uv_poll_t *	handle,
		uv_req_t *	req
	)

Definition at line 526 of file poll.c.

                                                                            {
  if (!(handle->flags & UV_HANDLE_POLL_SLOW)) {
    uv__fast_poll_process_poll_req(loop, handle, req);
  } else {
    uv__slow_poll_process_poll_req(loop, handle, req);
  }
}

References handle, loop, req, uv__fast_poll_process_poll_req(), uv__slow_poll_process_poll_req(), and UV_HANDLE_POLL_SLOW.

Referenced by uv_process_reqs().

uv_process_proc_exit()

void uv_process_proc_exit	(	uv_loop_t *	loop,
		uv_process_t *	handle
	)

Definition at line 865 of file process.c.

                                                                 {
  int64_t exit_code;
  DWORD status;
 
  assert(handle->exit_cb_pending);
  handle->exit_cb_pending = 0;
 
  /* If we're closing, don't call the exit callback. Just schedule a close
   * callback now. */
  if (handle->flags & UV_HANDLE_CLOSING) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
    return;
  }
 
  /* Unregister from process notification. */
  if (handle->wait_handle != INVALID_HANDLE_VALUE) {
    UnregisterWait(handle->wait_handle);
    handle->wait_handle = INVALID_HANDLE_VALUE;
  }
 
  /* Set the handle to inactive: no callbacks will be made after the exit
   * callback. */
  uv__handle_stop(handle);
 
  if (GetExitCodeProcess(handle->process_handle, &status)) {
    exit_code = status;
  } else {
    /* Unable to obtain the exit code. This should never happen. */
    exit_code = uv_translate_sys_error(GetLastError());
  }
 
  /* Fire the exit callback. */
  if (handle->exit_cb) {
    handle->exit_cb(handle, exit_code, handle->exit_signal);
  }
}

References assert(), DWORD, handle, INVALID_HANDLE_VALUE, loop, status, uv__handle_stop, UV_HANDLE_CLOSING, uv_translate_sys_error(), and uv_want_endgame().

Referenced by uv_process_reqs().

uv_process_signal_req()

void uv_process_signal_req	(	uv_loop_t *	loop,
		uv_signal_t *	handle,
		uv_req_t *	req
	)

Definition at line 234 of file signal.c.

                   {
  long dispatched_signum;
 
  assert(handle->type == UV_SIGNAL);
  assert(req->type == UV_SIGNAL_REQ);
 
  dispatched_signum = InterlockedExchange(
          (volatile LONG*) &handle->pending_signum, 0);
  assert(dispatched_signum != 0);
 
  /* Check if the pending signal equals the signum that we are watching for.
   * These can get out of sync when the handler is stopped and restarted while
   * the signal_req is pending. */
  if (dispatched_signum == handle->signum)
    handle->signal_cb(handle, dispatched_signum);
 
  if (handle->flags & UV_SIGNAL_ONE_SHOT)
    uv_signal_stop(handle);
 
  if (handle->flags & UV_HANDLE_CLOSING) {
    /* When it is closing, it must be stopped at this point. */
    assert(handle->signum == 0);
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
}

References assert(), handle, InterlockedExchange, LONG, loop, req, UV_HANDLE_CLOSING, UV_SIGNAL_ONE_SHOT, uv_signal_stop(), and uv_want_endgame().

Referenced by uv_process_reqs().

uv_process_tcp_accept_req()

void uv_process_tcp_accept_req	(	uv_loop_t *	loop,
		uv_tcp_t *	handle,
		uv_req_t *	req
	)

Definition at line 1161 of file tcp.c.

                       {
  uv_tcp_accept_t* req = (uv_tcp_accept_t*) raw_req;
  int err;
 
  assert(handle->type == UV_TCP);
 
  /* If handle->accepted_socket is not a valid socket, then uv_queue_accept
   * must have failed. This is a serious error. We stop accepting connections
   * and report this error to the connection callback. */
  if (req->accept_socket == INVALID_SOCKET) {
    if (handle->flags & UV_HANDLE_LISTENING) {
      handle->flags &= ~UV_HANDLE_LISTENING;
      DECREASE_ACTIVE_COUNT(loop, handle);
      if (handle->stream.serv.connection_cb) {
        err = GET_REQ_SOCK_ERROR(req);
        handle->stream.serv.connection_cb((uv_stream_t*)handle,
                                      uv_translate_sys_error(err));
      }
    }
  } else if (REQ_SUCCESS(req) &&
      setsockopt(req->accept_socket,
                  SOL_SOCKET,
                  SO_UPDATE_ACCEPT_CONTEXT,
                  (char*)&handle->socket,
                  sizeof(handle->socket)) == 0) {
    req->next_pending = handle->tcp.serv.pending_accepts;
    handle->tcp.serv.pending_accepts = req;
 
    /* Accept and SO_UPDATE_ACCEPT_CONTEXT were successful. */
    if (handle->stream.serv.connection_cb) {
      handle->stream.serv.connection_cb((uv_stream_t*)handle, 0);
    }
  } else {
    /* Error related to accepted socket is ignored because the server socket
     * may still be healthy. If the server socket is broken uv_queue_accept
     * will detect it. */
    closesocket(req->accept_socket);
    req->accept_socket = INVALID_SOCKET;
    if (handle->flags & UV_HANDLE_LISTENING) {
      uv_tcp_queue_accept(handle, req);
    }
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References assert(), DECREASE_ACTIVE_COUNT, DECREASE_PENDING_REQ_COUNT, err, GET_REQ_SOCK_ERROR, handle, loop, req, REQ_SUCCESS, SOL_SOCKET, UV_HANDLE_LISTENING, uv_tcp_queue_accept(), and uv_translate_sys_error().

uv_process_tcp_connect_req()

void uv_process_tcp_connect_req	(	uv_loop_t *	loop,
		uv_tcp_t *	handle,
		uv_connect_t *	req
	)

Definition at line 1209 of file tcp.c.

                       {
  int err;
 
  assert(handle->type == UV_TCP);
 
  UNREGISTER_HANDLE_REQ(loop, handle, req);
 
  err = 0;
  if (REQ_SUCCESS(req)) {
    if (handle->flags & UV_HANDLE_CLOSING) {
      /* use UV_ECANCELED for consistency with Unix */
      err = ERROR_OPERATION_ABORTED;
    } else if (setsockopt(handle->socket,
                          SOL_SOCKET,
                          SO_UPDATE_CONNECT_CONTEXT,
                          NULL,
                          0) == 0) {
      uv_connection_init((uv_stream_t*)handle);
      handle->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
      loop->active_tcp_streams++;
    } else {
      err = WSAGetLastError();
    }
  } else {
    err = GET_REQ_SOCK_ERROR(req);
  }
  req->cb(req, uv_translate_sys_error(err));
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References assert(), DECREASE_PENDING_REQ_COUNT, err, GET_REQ_SOCK_ERROR, handle, loop, NULL, req, REQ_SUCCESS, SO_UPDATE_CONNECT_CONTEXT, SOL_SOCKET, UNREGISTER_HANDLE_REQ, uv_connection_init(), UV_HANDLE_CLOSING, UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, and uv_translate_sys_error().

uv_process_tcp_read_req()

void uv_process_tcp_read_req	(	uv_loop_t *	loop,
		uv_tcp_t *	handle,
		uv_req_t *	req
	)

Definition at line 992 of file tcp.c.

                   {
  DWORD bytes, flags, err;
  uv_buf_t buf;
  int count;
 
  assert(handle->type == UV_TCP);
 
  handle->flags &= ~UV_HANDLE_READ_PENDING;
 
  if (!REQ_SUCCESS(req)) {
    /* An error occurred doing the read. */
    if ((handle->flags & UV_HANDLE_READING) ||
        !(handle->flags & UV_HANDLE_ZERO_READ)) {
      handle->flags &= ~UV_HANDLE_READING;
      DECREASE_ACTIVE_COUNT(loop, handle);
      buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
            uv_buf_init(NULL, 0) : handle->tcp.conn.read_buffer;
 
      err = GET_REQ_SOCK_ERROR(req);
 
      if (err == WSAECONNABORTED) {
        /* Turn WSAECONNABORTED into UV_ECONNRESET to be consistent with Unix.
         */
        err = WSAECONNRESET;
      }
 
      handle->read_cb((uv_stream_t*)handle,
                      uv_translate_sys_error(err),
                      &buf);
    }
  } else {
    if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
      /* The read was done with a non-zero buffer length. */
      if (req->u.io.overlapped.InternalHigh > 0) {
        /* Successful read */
        handle->read_cb((uv_stream_t*)handle,
                        req->u.io.overlapped.InternalHigh,
                        &handle->tcp.conn.read_buffer);
        /* Read again only if bytes == buf.len */
        if (req->u.io.overlapped.InternalHigh < handle->tcp.conn.read_buffer.len) {
          goto done;
        }
      } else {
        /* Connection closed */
        if (handle->flags & UV_HANDLE_READING) {
          handle->flags &= ~UV_HANDLE_READING;
          DECREASE_ACTIVE_COUNT(loop, handle);
        }
        handle->flags &= ~UV_HANDLE_READABLE;
 
        buf.base = 0;
        buf.len = 0;
        handle->read_cb((uv_stream_t*)handle, UV_EOF, &handle->tcp.conn.read_buffer);
        goto done;
      }
    }
 
    /* Do nonblocking reads until the buffer is empty */
    count = 32;
    while ((handle->flags & UV_HANDLE_READING) && (count-- > 0)) {
      buf = uv_buf_init(NULL, 0);
      handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);
      if (buf.base == NULL || buf.len == 0) {
        handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
        break;
      }
      assert(buf.base != NULL);
 
      flags = 0;
      if (WSARecv(handle->socket,
                  (WSABUF*)&buf,
                  1,
                  &bytes,
                  &flags,
                  NULL,
                  NULL) != SOCKET_ERROR) {
        if (bytes > 0) {
          /* Successful read */
          handle->read_cb((uv_stream_t*)handle, bytes, &buf);
          /* Read again only if bytes == buf.len */
          if (bytes < buf.len) {
            break;
          }
        } else {
          /* Connection closed */
          handle->flags &= ~(UV_HANDLE_READING | UV_HANDLE_READABLE);
          DECREASE_ACTIVE_COUNT(loop, handle);
 
          handle->read_cb((uv_stream_t*)handle, UV_EOF, &buf);
          break;
        }
      } else {
        err = WSAGetLastError();
        if (err == WSAEWOULDBLOCK) {
          /* Read buffer was completely empty, report a 0-byte read. */
          handle->read_cb((uv_stream_t*)handle, 0, &buf);
        } else {
          /* Ouch! serious error. */
          handle->flags &= ~UV_HANDLE_READING;
          DECREASE_ACTIVE_COUNT(loop, handle);
 
          if (err == WSAECONNABORTED) {
            /* Turn WSAECONNABORTED into UV_ECONNRESET to be consistent with
             * Unix. */
            err = WSAECONNRESET;
          }
 
          handle->read_cb((uv_stream_t*)handle,
                          uv_translate_sys_error(err),
                          &buf);
        }
        break;
      }
    }
 
done:
    /* Post another read if still reading and not closing. */
    if ((handle->flags & UV_HANDLE_READING) &&
        !(handle->flags & UV_HANDLE_READ_PENDING)) {
      uv_tcp_queue_read(loop, handle);
    }
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References assert(), bytes, count, DECREASE_ACTIVE_COUNT, DECREASE_PENDING_REQ_COUNT, done, DWORD, err, flags, GET_REQ_SOCK_ERROR, handle, loop, NULL, req, REQ_SUCCESS, uv_buf_init(), UV_HANDLE_READ_PENDING, UV_HANDLE_READABLE, UV_HANDLE_READING, UV_HANDLE_ZERO_READ, uv_tcp_queue_read(), and uv_translate_sys_error().

uv_process_tcp_write_req()

void uv_process_tcp_write_req	(	uv_loop_t *	loop,
		uv_tcp_t *	handle,
		uv_write_t *	req
	)

Definition at line 1120 of file tcp.c.

                     {
  int err;
 
  assert(handle->type == UV_TCP);
 
  assert(handle->write_queue_size >= req->u.io.queued_bytes);
  handle->write_queue_size -= req->u.io.queued_bytes;
 
  UNREGISTER_HANDLE_REQ(loop, handle, req);
 
  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
    if (req->wait_handle != INVALID_HANDLE_VALUE) {
      UnregisterWait(req->wait_handle);
      req->wait_handle = INVALID_HANDLE_VALUE;
    }
    if (req->event_handle != NULL) {
      CloseHandle(req->event_handle);
      req->event_handle = NULL;
    }
  }
 
  if (req->cb) {
    err = uv_translate_sys_error(GET_REQ_SOCK_ERROR(req));
    if (err == UV_ECONNABORTED) {
      /* use UV_ECANCELED for consistency with Unix */
      err = UV_ECANCELED;
    }
    req->cb(req, err);
  }
 
  handle->stream.conn.write_reqs_pending--;
  if (handle->stream.conn.shutdown_req != NULL &&
      handle->stream.conn.write_reqs_pending == 0) {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References assert(), DECREASE_PENDING_REQ_COUNT, err, GET_REQ_SOCK_ERROR, handle, INVALID_HANDLE_VALUE, loop, NULL, req, UNREGISTER_HANDLE_REQ, UV_HANDLE_EMULATE_IOCP, uv_translate_sys_error(), and uv_want_endgame().

uv_process_tty_accept_req()

void uv_process_tty_accept_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_req_t *	raw_req
	)

Definition at line 2308 of file tty.c.

                       {
  abort();
}

uv_process_tty_connect_req()

void uv_process_tty_connect_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_connect_t *	req
	)

Definition at line 2318 of file tty.c.

                       {
  abort();
}

uv_process_tty_read_req()

void uv_process_tty_read_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_req_t *	req
	)

Definition at line 1002 of file tty.c.

                   {
  assert(handle->type == UV_TTY);
  assert(handle->flags & UV_HANDLE_TTY_READABLE);
 
  /* If the read_line_buffer member is zero, it must have been an raw read.
   * Otherwise it was a line-buffered read. FIXME: This is quite obscure. Use a
   * flag or something. */
  if (handle->tty.rd.read_line_buffer.len == 0) {
    uv_process_tty_read_raw_req(loop, handle, req);
  } else {
    uv_process_tty_read_line_req(loop, handle, req);
  }
}

References assert(), handle, loop, req, UV_HANDLE_TTY_READABLE, uv_process_tty_read_line_req(), and uv_process_tty_read_raw_req().

uv_process_tty_write_req()

void uv_process_tty_write_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_write_t *	req
	)

Definition at line 2227 of file tty.c.

                   {
  int err;
 
  handle->write_queue_size -= req->u.io.queued_bytes;
  UNREGISTER_HANDLE_REQ(loop, handle, req);
 
  if (req->cb) {
    err = GET_REQ_ERROR(req);
    req->cb(req, uv_translate_sys_error(err));
  }
 
  handle->stream.conn.write_reqs_pending--;
  if (handle->stream.conn.shutdown_req != NULL &&
      handle->stream.conn.write_reqs_pending == 0) {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References DECREASE_PENDING_REQ_COUNT, err, GET_REQ_ERROR, handle, loop, NULL, req, UNREGISTER_HANDLE_REQ, uv_translate_sys_error(), and uv_want_endgame().

uv_process_udp_recv_req()

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

Definition at line 453 of file udp.c.

                   {
  uv_buf_t buf;
  int partial;
 
  assert(handle->type == UV_UDP);
 
  handle->flags &= ~UV_HANDLE_READ_PENDING;
 
  if (!REQ_SUCCESS(req)) {
    DWORD err = GET_REQ_SOCK_ERROR(req);
    if (err == WSAEMSGSIZE) {
      /* Not a real error, it just indicates that the received packet was
       * bigger than the receive buffer. */
    } else if (err == WSAECONNRESET || err == WSAENETRESET) {
      /* A previous sendto operation failed; ignore this error. If zero-reading
       * we need to call WSARecv/WSARecvFrom _without_ the. MSG_PEEK flag to
       * clear out the error queue. For nonzero reads, immediately queue a new
       * receive. */
      if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
        goto done;
      }
    } else {
      /* A real error occurred. Report the error to the user only if we're
       * currently reading. */
      if (handle->flags & UV_HANDLE_READING) {
        uv_udp_recv_stop(handle);
        buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
              uv_buf_init(NULL, 0) : handle->recv_buffer;
        handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
      }
      goto done;
    }
  }
 
  if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
    /* Successful read */
    partial = !REQ_SUCCESS(req);
    handle->recv_cb(handle,
                    req->u.io.overlapped.InternalHigh,
                    &handle->recv_buffer,
                    (const struct sockaddr*) &handle->recv_from,
                    partial ? UV_UDP_PARTIAL : 0);
  } else if (handle->flags & UV_HANDLE_READING) {
    DWORD bytes, err, flags;
    struct sockaddr_storage from;
    int from_len;
 
    /* Do a nonblocking receive.
     * TODO: try to read multiple datagrams at once. FIONREAD maybe? */
    buf = uv_buf_init(NULL, 0);
    handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);
    if (buf.base == NULL || buf.len == 0) {
      handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
      goto done;
    }
    assert(buf.base != NULL);
 
    memset(&from, 0, sizeof from);
    from_len = sizeof from;
 
    flags = 0;
 
    if (WSARecvFrom(handle->socket,
                    (WSABUF*)&buf,
                    1,
                    &bytes,
                    &flags,
                    (struct sockaddr*) &from,
                    &from_len,
                    NULL,
                    NULL) != SOCKET_ERROR) {
 
      /* Message received */
      handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0);
    } else {
      err = WSAGetLastError();
      if (err == WSAEMSGSIZE) {
        /* Message truncated */
        handle->recv_cb(handle,
                        bytes,
                        &buf,
                        (const struct sockaddr*) &from,
                        UV_UDP_PARTIAL);
      } else if (err == WSAEWOULDBLOCK) {
        /* Kernel buffer empty */
        handle->recv_cb(handle, 0, &buf, NULL, 0);
      } else if (err == WSAECONNRESET || err == WSAENETRESET) {
        /* WSAECONNRESET/WSANETRESET is ignored because this just indicates
         * that a previous sendto operation failed.
         */
        handle->recv_cb(handle, 0, &buf, NULL, 0);
      } else {
        /* Any other error that we want to report back to the user. */
        uv_udp_recv_stop(handle);
        handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
      }
    }
  }
 
done:
  /* Post another read if still reading and not closing. */
  if ((handle->flags & UV_HANDLE_READING) &&
      !(handle->flags & UV_HANDLE_READ_PENDING)) {
    uv_udp_queue_recv(loop, handle);
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

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

Referenced by uv_process_reqs().

uv_process_udp_send_req()

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

Definition at line 564 of file udp.c.

                        {
  int err;
 
  assert(handle->type == UV_UDP);
 
  assert(handle->send_queue_size >= req->u.io.queued_bytes);
  assert(handle->send_queue_count >= 1);
  handle->send_queue_size -= req->u.io.queued_bytes;
  handle->send_queue_count--;
 
  UNREGISTER_HANDLE_REQ(loop, handle, req);
 
  if (req->cb) {
    err = 0;
    if (!REQ_SUCCESS(req)) {
      err = GET_REQ_SOCK_ERROR(req);
    }
    req->cb(req, uv_translate_sys_error(err));
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

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

Referenced by uv_process_reqs().

uv_signal_close()

void uv_signal_close	(	uv_loop_t *	loop,
		uv_signal_t *	handle
	)

Definition at line 262 of file signal.c.

                                                           {
  uv_signal_stop(handle);
  uv__handle_closing(handle);
 
  if (handle->pending_signum == 0) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
}

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

Referenced by uv_close().

uv_signal_endgame()

void uv_signal_endgame	(	uv_loop_t *	loop,
		uv_signal_t *	handle
	)

Definition at line 272 of file signal.c.

                                                             {
  assert(handle->flags & UV_HANDLE_CLOSING);
  assert(!(handle->flags & UV_HANDLE_CLOSED));
 
  assert(handle->signum == 0);
  assert(handle->pending_signum == 0);
 
  handle->flags |= UV_HANDLE_CLOSED;
 
  uv__handle_close(handle);
}

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

Referenced by uv_process_endgames().

uv_signals_init()

void uv_signals_init

(

void

)

Definition at line 42 of file signal.c.

                           {
  InitializeCriticalSection(&uv__signal_lock);
  if (!SetConsoleCtrlHandler(uv__signal_control_handler, TRUE))
    abort();
}

References TRUE, uv__signal_control_handler(), and uv__signal_lock.

Referenced by uv_init().

uv_stdio_pipe_server()

int uv_stdio_pipe_server	(	uv_loop_t *	loop,
		uv_pipe_t *	handle,
		DWORD	access,
		char *	name,
		size_t	nameSize
	)

Definition at line 205 of file pipe.c.

                                 {
  HANDLE pipeHandle;
  int err;
  char* ptr = (char*)handle;
 
  for (;;) {
    uv_unique_pipe_name(ptr, name, nameSize);
 
    pipeHandle = CreateNamedPipeA(name,
      access | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE | WRITE_DAC,
      PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, 65536, 65536, 0,
      NULL);
 
    if (pipeHandle != INVALID_HANDLE_VALUE) {
      /* No name collisions.  We're done. */
      break;
    }
 
    err = GetLastError();
    if (err != ERROR_PIPE_BUSY && err != ERROR_ACCESS_DENIED) {
      goto error;
    }
 
    /* Pipe name collision.  Increment the pointer and try again. */
    ptr++;
  }
 
  if (CreateIoCompletionPort(pipeHandle,
                             loop->iocp,
                             (ULONG_PTR)handle,
                             0) == NULL) {
    err = GetLastError();
    goto error;
  }
 
  uv_pipe_connection_init(handle);
  handle->handle = pipeHandle;
 
  return 0;
 
 error:
  if (pipeHandle != INVALID_HANDLE_VALUE)
    CloseHandle(pipeHandle);
 
  return err;
}

References access, err, error(), handle, HANDLE, INVALID_HANDLE_VALUE, loop, NULL, uv_pipe_connection_init(), and uv_unique_pipe_name().

Referenced by uv__create_stdio_pipe_pair().

uv_tcp_accept()

int uv_tcp_accept	(	uv_tcp_t *	server,
		uv_tcp_t *	client
	)

Definition at line 657 of file tcp.c.

                                                      {
  uv_loop_t* loop = server->loop;
  int err = 0;
  int family;
 
  uv_tcp_accept_t* req = server->tcp.serv.pending_accepts;
 
  if (!req) {
    /* No valid connections found, so we error out. */
    return WSAEWOULDBLOCK;
  }
 
  if (req->accept_socket == INVALID_SOCKET) {
    return WSAENOTCONN;
  }
 
  if (server->flags & UV_HANDLE_IPV6) {
    family = AF_INET6;
  } else {
    family = AF_INET;
  }
 
  err = uv_tcp_set_socket(client->loop,
                          client,
                          req->accept_socket,
                          family,
                          0);
  if (err) {
    closesocket(req->accept_socket);
  } else {
    uv_connection_init((uv_stream_t*) client);
    /* AcceptEx() implicitly binds the accepted socket. */
    client->flags |= UV_HANDLE_BOUND | UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
  }
 
  /* Prepare the req to pick up a new connection */
  server->tcp.serv.pending_accepts = req->next_pending;
  req->next_pending = NULL;
  req->accept_socket = INVALID_SOCKET;
 
  if (!(server->flags & UV_HANDLE_CLOSING)) {
    /* Check if we're in a middle of changing the number of pending accepts. */
    if (!(server->flags & UV_HANDLE_TCP_ACCEPT_STATE_CHANGING)) {
      uv_tcp_queue_accept(server, req);
    } else {
      /* We better be switching to a single pending accept. */
      assert(server->flags & UV_HANDLE_TCP_SINGLE_ACCEPT);
 
      server->tcp.serv.processed_accepts++;
 
      if (server->tcp.serv.processed_accepts >= uv_simultaneous_server_accepts) {
        server->tcp.serv.processed_accepts = 0;
        /*
         * All previously queued accept requests are now processed.
         * We now switch to queueing just a single accept.
         */
        uv_tcp_queue_accept(server, &server->tcp.serv.accept_reqs[0]);
        server->flags &= ~UV_HANDLE_TCP_ACCEPT_STATE_CHANGING;
        server->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
      }
    }
  }
 
  loop->active_tcp_streams++;
 
  return err;
}

References AF_INET, AF_INET6, assert(), err, loop, NULL, req, uv_connection_init(), UV_HANDLE_BOUND, UV_HANDLE_CLOSING, UV_HANDLE_IPV6, UV_HANDLE_READABLE, UV_HANDLE_TCP_ACCEPT_STATE_CHANGING, UV_HANDLE_TCP_SINGLE_ACCEPT, UV_HANDLE_WRITABLE, uv_simultaneous_server_accepts, uv_tcp_queue_accept(), and uv_tcp_set_socket().

Referenced by uv_accept().

uv_tcp_close()

void uv_tcp_close	(	uv_loop_t *	loop,
		uv_tcp_t *	tcp
	)

Definition at line 1426 of file tcp.c.

                                                  {
  int close_socket = 1;
 
  if (tcp->flags & UV_HANDLE_READ_PENDING) {
    /* In order for winsock to do a graceful close there must not be any any
     * pending reads, or the socket must be shut down for writing */
    if (!(tcp->flags & UV_HANDLE_SHARED_TCP_SOCKET)) {
      /* Just do shutdown on non-shared sockets, which ensures graceful close. */
      shutdown(tcp->socket, SD_SEND);
 
    } else if (uv_tcp_try_cancel_io(tcp) == 0) {
      /* In case of a shared socket, we try to cancel all outstanding I/O,. If
       * that works, don't close the socket yet - wait for the read req to
       * return and close the socket in uv_tcp_endgame. */
      close_socket = 0;
 
    } else {
      /* When cancelling isn't possible - which could happen when an LSP is
       * present on an old Windows version, we will have to close the socket
       * with a read pending. That is not nice because trailing sent bytes may
       * not make it to the other side. */
    }
 
  } else if ((tcp->flags & UV_HANDLE_SHARED_TCP_SOCKET) &&
             tcp->tcp.serv.accept_reqs != NULL) {
    /* Under normal circumstances closesocket() will ensure that all pending
     * accept reqs are canceled. However, when the socket is shared the
     * presence of another reference to the socket in another process will keep
     * the accept reqs going, so we have to ensure that these are canceled. */
    if (uv_tcp_try_cancel_io(tcp) != 0) {
      /* When cancellation is not possible, there is another option: we can
       * close the incoming sockets, which will also cancel the accept
       * operations. However this is not cool because we might inadvertently
       * close a socket that just accepted a new connection, which will cause
       * the connection to be aborted. */
      unsigned int i;
      for (i = 0; i < uv_simultaneous_server_accepts; i++) {
        uv_tcp_accept_t* req = &tcp->tcp.serv.accept_reqs[i];
        if (req->accept_socket != INVALID_SOCKET &&
            !HasOverlappedIoCompleted(&req->u.io.overlapped)) {
          closesocket(req->accept_socket);
          req->accept_socket = INVALID_SOCKET;
        }
      }
    }
  }
 
  if (tcp->flags & UV_HANDLE_READING) {
    tcp->flags &= ~UV_HANDLE_READING;
    DECREASE_ACTIVE_COUNT(loop, tcp);
  }
 
  if (tcp->flags & UV_HANDLE_LISTENING) {
    tcp->flags &= ~UV_HANDLE_LISTENING;
    DECREASE_ACTIVE_COUNT(loop, tcp);
  }
 
  if (close_socket) {
    closesocket(tcp->socket);
    tcp->socket = INVALID_SOCKET;
    tcp->flags |= UV_HANDLE_TCP_SOCKET_CLOSED;
  }
 
  tcp->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
  uv__handle_closing(tcp);
 
  if (tcp->reqs_pending == 0) {
    uv_want_endgame(tcp->loop, (uv_handle_t*)tcp);
  }
}

References DECREASE_ACTIVE_COUNT, i, loop, NULL, req, SD_SEND, uv__handle_closing, UV_HANDLE_LISTENING, UV_HANDLE_READ_PENDING, UV_HANDLE_READABLE, UV_HANDLE_READING, UV_HANDLE_SHARED_TCP_SOCKET, UV_HANDLE_TCP_SOCKET_CLOSED, UV_HANDLE_WRITABLE, uv_simultaneous_server_accepts, uv_tcp_try_cancel_io(), and uv_want_endgame().

Referenced by uv_close().

uv_tcp_endgame()

void uv_tcp_endgame	(	uv_loop_t *	loop,
		uv_tcp_t *	handle
	)

Definition at line 208 of file tcp.c.

                                                       {
  int err;
  unsigned int i;
  uv_tcp_accept_t* req;
 
  if (handle->flags & UV_HANDLE_CONNECTION &&
      handle->stream.conn.shutdown_req != NULL &&
      handle->stream.conn.write_reqs_pending == 0) {
 
    UNREGISTER_HANDLE_REQ(loop, handle, handle->stream.conn.shutdown_req);
 
    err = 0;
    if (handle->flags & UV_HANDLE_CLOSING) {
      err = ERROR_OPERATION_ABORTED;
    } else if (shutdown(handle->socket, SD_SEND) == SOCKET_ERROR) {
      err = WSAGetLastError();
    }
 
    if (handle->stream.conn.shutdown_req->cb) {
      handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req,
                               uv_translate_sys_error(err));
    }
 
    handle->stream.conn.shutdown_req = NULL;
    DECREASE_PENDING_REQ_COUNT(handle);
    return;
  }
 
  if (handle->flags & UV_HANDLE_CLOSING &&
      handle->reqs_pending == 0) {
    assert(!(handle->flags & UV_HANDLE_CLOSED));
 
    if (!(handle->flags & UV_HANDLE_TCP_SOCKET_CLOSED)) {
      closesocket(handle->socket);
      handle->socket = INVALID_SOCKET;
      handle->flags |= UV_HANDLE_TCP_SOCKET_CLOSED;
    }
 
    if (!(handle->flags & UV_HANDLE_CONNECTION) && handle->tcp.serv.accept_reqs) {
      if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
        for (i = 0; i < uv_simultaneous_server_accepts; i++) {
          req = &handle->tcp.serv.accept_reqs[i];
          if (req->wait_handle != INVALID_HANDLE_VALUE) {
            UnregisterWait(req->wait_handle);
            req->wait_handle = INVALID_HANDLE_VALUE;
          }
          if (req->event_handle != NULL) {
            CloseHandle(req->event_handle);
            req->event_handle = NULL;
          }
        }
      }
 
      uv__free(handle->tcp.serv.accept_reqs);
      handle->tcp.serv.accept_reqs = NULL;
    }
 
    if (handle->flags & UV_HANDLE_CONNECTION &&
        handle->flags & UV_HANDLE_EMULATE_IOCP) {
      if (handle->read_req.wait_handle != INVALID_HANDLE_VALUE) {
        UnregisterWait(handle->read_req.wait_handle);
        handle->read_req.wait_handle = INVALID_HANDLE_VALUE;
      }
      if (handle->read_req.event_handle != NULL) {
        CloseHandle(handle->read_req.event_handle);
        handle->read_req.event_handle = NULL;
      }
    }
 
    uv__handle_close(handle);
    loop->active_tcp_streams--;
  }
}

References assert(), DECREASE_PENDING_REQ_COUNT, err, handle, i, INVALID_HANDLE_VALUE, loop, NULL, req, SD_SEND, UNREGISTER_HANDLE_REQ, uv__free(), uv__handle_close, UV_HANDLE_CLOSED, UV_HANDLE_CLOSING, UV_HANDLE_CONNECTION, UV_HANDLE_EMULATE_IOCP, UV_HANDLE_TCP_SOCKET_CLOSED, uv_simultaneous_server_accepts, and uv_translate_sys_error().

Referenced by uv_process_endgames().

uv_tcp_listen()

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

Definition at line 328 of file tcp.c.

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

References assert(), cb, err, handle, i, INCREASE_ACTIVE_COUNT, INVALID_HANDLE_VALUE, listen, loop, NULL, req, uv__malloc(), uv_addr_ip4_any_, uv_fatal_error(), uv_get_acceptex_function(), UV_HANDLE_BOUND, UV_HANDLE_EMULATE_IOCP, UV_HANDLE_LISTENING, UV_HANDLE_READING, UV_HANDLE_SHARED_TCP_SOCKET, UV_HANDLE_TCP_SINGLE_ACCEPT, UV_REQ_INIT, uv_simultaneous_server_accepts, uv_tcp_queue_accept(), and uv_tcp_try_bind().

uv_tcp_read_start()

int uv_tcp_read_start	(	uv_tcp_t *	handle,
		uv_alloc_cb	alloc_cb,
		uv_read_cb	read_cb
	)

Definition at line 726 of file tcp.c.

                        {
  uv_loop_t* loop = handle->loop;
 
  handle->flags |= UV_HANDLE_READING;
  handle->read_cb = read_cb;
  handle->alloc_cb = alloc_cb;
  INCREASE_ACTIVE_COUNT(loop, handle);
 
  /* If reading was stopped and then started again, there could still be a read
   * request pending. */
  if (!(handle->flags & UV_HANDLE_READ_PENDING)) {
    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
        handle->read_req.event_handle == NULL) {
      handle->read_req.event_handle = CreateEvent(NULL, 0, 0, NULL);
      if (handle->read_req.event_handle == NULL) {
        uv_fatal_error(GetLastError(), "CreateEvent");
      }
    }
    uv_tcp_queue_read(loop, handle);
  }
 
  return 0;
}

References handle, INCREASE_ACTIVE_COUNT, loop, NULL, uv_fatal_error(), UV_HANDLE_EMULATE_IOCP, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, and uv_tcp_queue_read().

Referenced by uv_read_start().

uv_tcp_write()

int uv_tcp_write	(	uv_loop_t *	loop,
		uv_write_t *	req,
		uv_tcp_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		uv_write_cb	cb
	)

Definition at line 901 of file tcp.c.

                                 {
  int result;
  DWORD bytes;
 
  UV_REQ_INIT(req, UV_WRITE);
  req->handle = (uv_stream_t*) handle;
  req->cb = cb;
 
  /* Prepare the overlapped structure. */
  memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
    req->event_handle = CreateEvent(NULL, 0, 0, NULL);
    if (req->event_handle == NULL) {
      uv_fatal_error(GetLastError(), "CreateEvent");
    }
    req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
    req->wait_handle = INVALID_HANDLE_VALUE;
  }
 
  result = WSASend(handle->socket,
                   (WSABUF*) bufs,
                   nbufs,
                   &bytes,
                   0,
                   &req->u.io.overlapped,
                   NULL);
 
  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
    /* Request completed immediately. */
    req->u.io.queued_bytes = 0;
    handle->reqs_pending++;
    handle->stream.conn.write_reqs_pending++;
    REGISTER_HANDLE_REQ(loop, handle, req);
    uv_insert_pending_req(loop, (uv_req_t*) req);
  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
    /* Request queued by the kernel. */
    req->u.io.queued_bytes = uv__count_bufs(bufs, nbufs);
    handle->reqs_pending++;
    handle->stream.conn.write_reqs_pending++;
    REGISTER_HANDLE_REQ(loop, handle, req);
    handle->write_queue_size += req->u.io.queued_bytes;
    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
        !RegisterWaitForSingleObject(&req->wait_handle,
          req->event_handle, post_write_completion, (void*) req,
          INFINITE, WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE)) {
      SET_REQ_ERROR(req, GetLastError());
      uv_insert_pending_req(loop, (uv_req_t*)req);
    }
  } else {
    /* Send failed due to an error, report it later */
    req->u.io.queued_bytes = 0;
    handle->reqs_pending++;
    handle->stream.conn.write_reqs_pending++;
    REGISTER_HANDLE_REQ(loop, handle, req);
    SET_REQ_ERROR(req, WSAGetLastError());
    uv_insert_pending_req(loop, (uv_req_t*) req);
  }
 
  return 0;
}

References bufs, bytes, cb, DWORD, handle, HANDLE, INVALID_HANDLE_VALUE, loop, memset(), NULL, post_write_completion(), REGISTER_HANDLE_REQ, req, SET_REQ_ERROR, uv__count_bufs(), uv_fatal_error(), UV_HANDLE_EMULATE_IOCP, uv_insert_pending_req(), UV_REQ_INIT, UV_SUCCEEDED_WITH_IOCP, and UV_SUCCEEDED_WITHOUT_IOCP.

Referenced by uv_write().

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

References ERROR_ELEVATION_REQUIRED, and ERROR_SYMLINK_NOT_SUPPORTED.

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

uv_tty_close()

void uv_tty_close

(

uv_tty_t *

handle

)

Definition at line 2249 of file tty.c.

                                    {
  assert(handle->u.fd == -1 || handle->u.fd > 2);
  if (handle->flags & UV_HANDLE_READING)
    uv_tty_read_stop(handle);
 
  if (handle->u.fd == -1)
    CloseHandle(handle->handle);
  else
    close(handle->u.fd);
 
  handle->u.fd = -1;
  handle->handle = INVALID_HANDLE_VALUE;
  handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
  uv__handle_closing(handle);
 
  if (handle->reqs_pending == 0) {
    uv_want_endgame(handle->loop, (uv_handle_t*) handle);
  }
}

References assert(), close, handle, INVALID_HANDLE_VALUE, uv__handle_closing, UV_HANDLE_READABLE, UV_HANDLE_READING, UV_HANDLE_WRITABLE, uv_tty_read_stop(), and uv_want_endgame().

Referenced by uv_close().

uv_tty_endgame()

void uv_tty_endgame	(	uv_loop_t *	loop,
		uv_tty_t *	handle
	)

Definition at line 2270 of file tty.c.

                                                       {
  if (!(handle->flags & UV_HANDLE_TTY_READABLE) &&
      handle->stream.conn.shutdown_req != NULL &&
      handle->stream.conn.write_reqs_pending == 0) {
    UNREGISTER_HANDLE_REQ(loop, handle, handle->stream.conn.shutdown_req);
 
    /* TTY shutdown is really just a no-op */
    if (handle->stream.conn.shutdown_req->cb) {
      if (handle->flags & UV_HANDLE_CLOSING) {
        handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, UV_ECANCELED);
      } else {
        handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, 0);
      }
    }
 
    handle->stream.conn.shutdown_req = NULL;
 
    DECREASE_PENDING_REQ_COUNT(handle);
    return;
  }
 
  if (handle->flags & UV_HANDLE_CLOSING &&
      handle->reqs_pending == 0) {
    /* The wait handle used for raw reading should be unregistered when the
     * wait callback runs. */
    assert(!(handle->flags & UV_HANDLE_TTY_READABLE) ||
           handle->tty.rd.read_raw_wait == NULL);
 
    assert(!(handle->flags & UV_HANDLE_CLOSED));
    uv__handle_close(handle);
  }
}

References assert(), DECREASE_PENDING_REQ_COUNT, handle, loop, NULL, UNREGISTER_HANDLE_REQ, uv__handle_close, UV_HANDLE_CLOSED, UV_HANDLE_CLOSING, and UV_HANDLE_TTY_READABLE.

Referenced by uv_process_endgames().

uv_tty_read_start()

int uv_tty_read_start	(	uv_tty_t *	handle,
		uv_alloc_cb	alloc_cb,
		uv_read_cb	read_cb
	)

Definition at line 1018 of file tty.c.

                        {
  uv_loop_t* loop = handle->loop;
 
  if (!(handle->flags & UV_HANDLE_TTY_READABLE)) {
    return ERROR_INVALID_PARAMETER;
  }
 
  handle->flags |= UV_HANDLE_READING;
  INCREASE_ACTIVE_COUNT(loop, handle);
  handle->read_cb = read_cb;
  handle->alloc_cb = alloc_cb;
 
  /* If reading was stopped and then started again, there could still be a read
   * request pending. */
  if (handle->flags & UV_HANDLE_READ_PENDING) {
    return 0;
  }
 
  /* Maybe the user stopped reading half-way while processing key events.
   * Short-circuit if this could be the case. */
  if (handle->tty.rd.last_key_len > 0) {
    SET_REQ_SUCCESS(&handle->read_req);
    uv_insert_pending_req(handle->loop, (uv_req_t*) &handle->read_req);
    /* Make sure no attempt is made to insert it again until it's handled. */
    handle->flags |= UV_HANDLE_READ_PENDING;
    handle->reqs_pending++;
    return 0;
  }
 
  uv_tty_queue_read(loop, handle);
 
  return 0;
}

References handle, INCREASE_ACTIVE_COUNT, loop, SET_REQ_SUCCESS, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, UV_HANDLE_TTY_READABLE, uv_insert_pending_req(), and uv_tty_queue_read().

Referenced by uv_read_start(), and uv_tty_set_mode().

uv_tty_read_stop()

int uv_tty_read_stop

(

uv_tty_t *

handle

)

Definition at line 1054 of file tty.c.

                                       {
  INPUT_RECORD record;
  DWORD written, err;
 
  handle->flags &= ~UV_HANDLE_READING;
  DECREASE_ACTIVE_COUNT(handle->loop, handle);
 
  if (!(handle->flags & UV_HANDLE_READ_PENDING))
    return 0;
 
  if (handle->flags & UV_HANDLE_TTY_RAW) {
    /* Cancel raw read. Write some bullshit event to force the console wait to
     * return. */
    memset(&record, 0, sizeof record);
    record.EventType = FOCUS_EVENT;
    if (!WriteConsoleInputW(handle->handle, &record, 1, &written)) {
      return GetLastError();
    }
  } else if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING)) {
    /* Cancel line-buffered read if not already pending */
    err = uv__cancel_read_console(handle);
    if (err)
      return err;
 
    handle->flags |= UV_HANDLE_CANCELLATION_PENDING;
  }
 
  return 0;
}

References DECREASE_ACTIVE_COUNT, DWORD, err, handle, memset(), uv__cancel_read_console(), UV_HANDLE_CANCELLATION_PENDING, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, and UV_HANDLE_TTY_RAW.

Referenced by uv_read_stop(), uv_tty_close(), and uv_tty_set_mode().

uv_tty_write()

int uv_tty_write	(	uv_loop_t *	loop,
		uv_write_t *	req,
		uv_tty_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		uv_write_cb	cb
	)

Definition at line 2182 of file tty.c.

                                 {
  DWORD error;
 
  UV_REQ_INIT(req, UV_WRITE);
  req->handle = (uv_stream_t*) handle;
  req->cb = cb;
 
  handle->reqs_pending++;
  handle->stream.conn.write_reqs_pending++;
  REGISTER_HANDLE_REQ(loop, handle, req);
 
  req->u.io.queued_bytes = 0;
 
  if (!uv_tty_write_bufs(handle, bufs, nbufs, &error)) {
    SET_REQ_SUCCESS(req);
  } else {
    SET_REQ_ERROR(req, error);
  }
 
  uv_insert_pending_req(loop, (uv_req_t*) req);
 
  return 0;
}

References bufs, cb, DWORD, error(), handle, loop, REGISTER_HANDLE_REQ, req, SET_REQ_ERROR, SET_REQ_SUCCESS, uv_insert_pending_req(), UV_REQ_INIT, and uv_tty_write_bufs().

Referenced by uv_write().

uv_udp_close()

void uv_udp_close	(	uv_loop_t *	loop,
		uv_udp_t *	handle
	)

Definition at line 170 of file udp.c.

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

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

Referenced by uv_close().

uv_udp_endgame()

void uv_udp_endgame	(	uv_loop_t *	loop,
		uv_udp_t *	handle
	)

Definition at line 183 of file udp.c.

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

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

Referenced by uv_process_endgames().

uv_winapi_init()

void uv_winapi_init

(

void

)

Definition at line 49 of file winapi.c.

                          {
  HMODULE ntdll_module;
  HMODULE powrprof_module;
  HMODULE user32_module;
  HMODULE kernel32_module;
 
  ntdll_module = GetModuleHandleA("ntdll.dll");
  if (ntdll_module == NULL) {
    uv_fatal_error(GetLastError(), "GetModuleHandleA");
  }
 
  pRtlGetVersion = (sRtlGetVersion) GetProcAddress(ntdll_module,
                                                   "RtlGetVersion");
 
  pRtlNtStatusToDosError = (sRtlNtStatusToDosError) GetProcAddress(
      ntdll_module,
      "RtlNtStatusToDosError");
  if (pRtlNtStatusToDosError == NULL) {
    uv_fatal_error(GetLastError(), "GetProcAddress");
  }
 
  pNtDeviceIoControlFile = (sNtDeviceIoControlFile) GetProcAddress(
      ntdll_module,
      "NtDeviceIoControlFile");
  if (pNtDeviceIoControlFile == NULL) {
    uv_fatal_error(GetLastError(), "GetProcAddress");
  }
 
  pNtQueryInformationFile = (sNtQueryInformationFile) GetProcAddress(
      ntdll_module,
      "NtQueryInformationFile");
  if (pNtQueryInformationFile == NULL) {
    uv_fatal_error(GetLastError(), "GetProcAddress");
  }
 
  pNtSetInformationFile = (sNtSetInformationFile) GetProcAddress(
      ntdll_module,
      "NtSetInformationFile");
  if (pNtSetInformationFile == NULL) {
    uv_fatal_error(GetLastError(), "GetProcAddress");
  }
 
  pNtQueryVolumeInformationFile = (sNtQueryVolumeInformationFile)
      GetProcAddress(ntdll_module, "NtQueryVolumeInformationFile");
  if (pNtQueryVolumeInformationFile == NULL) {
    uv_fatal_error(GetLastError(), "GetProcAddress");
  }
 
  pNtQueryDirectoryFile = (sNtQueryDirectoryFile)
      GetProcAddress(ntdll_module, "NtQueryDirectoryFile");
  if (pNtQueryVolumeInformationFile == NULL) {
    uv_fatal_error(GetLastError(), "GetProcAddress");
  }
 
  pNtQuerySystemInformation = (sNtQuerySystemInformation) GetProcAddress(
      ntdll_module,
      "NtQuerySystemInformation");
  if (pNtQuerySystemInformation == NULL) {
    uv_fatal_error(GetLastError(), "GetProcAddress");
  }
 
  pNtQueryInformationProcess = (sNtQueryInformationProcess) GetProcAddress(
      ntdll_module,
      "NtQueryInformationProcess");
  if (pNtQueryInformationProcess == NULL) {
    uv_fatal_error(GetLastError(), "GetProcAddress");
  }
 
  kernel32_module = GetModuleHandleA("kernel32.dll");
  if (kernel32_module == NULL) {
    uv_fatal_error(GetLastError(), "GetModuleHandleA");
  }
 
  pGetQueuedCompletionStatusEx = (sGetQueuedCompletionStatusEx) GetProcAddress(
      kernel32_module,
      "GetQueuedCompletionStatusEx");
 
  powrprof_module = LoadLibraryA("powrprof.dll");
  if (powrprof_module != NULL) {
    pPowerRegisterSuspendResumeNotification = (sPowerRegisterSuspendResumeNotification)
      GetProcAddress(powrprof_module, "PowerRegisterSuspendResumeNotification");
  }
 
  user32_module = LoadLibraryA("user32.dll");
  if (user32_module != NULL) {
    pSetWinEventHook = (sSetWinEventHook)
      GetProcAddress(user32_module, "SetWinEventHook");
  }
}

References NULL, pGetQueuedCompletionStatusEx, pNtDeviceIoControlFile, pNtQueryDirectoryFile, pNtQueryInformationFile, pNtQueryInformationProcess, pNtQuerySystemInformation, pNtQueryVolumeInformationFile, pNtSetInformationFile, pPowerRegisterSuspendResumeNotification, pRtlGetVersion, pRtlNtStatusToDosError, pSetWinEventHook, and uv_fatal_error().

Referenced by uv_init().

uv_winsock_init()

void uv_winsock_init

(

void

)

Definition at line 78 of file winsock.c.

                           {
  WSADATA wsa_data;
  int errorno;
  SOCKET dummy;
  WSAPROTOCOL_INFOW protocol_info;
  int opt_len;
 
  /* Set implicit binding address used by connectEx */
  if (uv_ip4_addr("0.0.0.0", 0, &uv_addr_ip4_any_)) {
    abort();
  }
 
  if (uv_ip6_addr("::", 0, &uv_addr_ip6_any_)) {
    abort();
  }
 
  /* Skip initialization in safe mode without network support */
  if (1 == GetSystemMetrics(SM_CLEANBOOT)) return;
 
  /* Initialize winsock */
  errorno = WSAStartup(MAKEWORD(2, 2), &wsa_data);
  if (errorno != 0) {
    uv_fatal_error(errorno, "WSAStartup");
  }
 
  /* Try to detect non-IFS LSPs */
  uv_tcp_non_ifs_lsp_ipv4 = 1;
  dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
  if (dummy != INVALID_SOCKET) {
    opt_len = (int) sizeof protocol_info;
    if (getsockopt(dummy,
                   SOL_SOCKET,
                   SO_PROTOCOL_INFOW,
                   (char*) &protocol_info,
                   &opt_len) == 0) {
      if (protocol_info.dwServiceFlags1 & XP1_IFS_HANDLES)
        uv_tcp_non_ifs_lsp_ipv4 = 0;
    }
    closesocket(dummy);
  }
 
  /* Try to detect IPV6 support and non-IFS LSPs */
  uv_tcp_non_ifs_lsp_ipv6 = 1;
  dummy = socket(AF_INET6, SOCK_STREAM, IPPROTO_IP);
  if (dummy != INVALID_SOCKET) {
    opt_len = (int) sizeof protocol_info;
    if (getsockopt(dummy,
                   SOL_SOCKET,
                   SO_PROTOCOL_INFOW,
                   (char*) &protocol_info,
                   &opt_len) == 0) {
      if (protocol_info.dwServiceFlags1 & XP1_IFS_HANDLES)
        uv_tcp_non_ifs_lsp_ipv6 = 0;
    }
    closesocket(dummy);
  }
}

References AF_INET, AF_INET6, int, SOCK_STREAM, socket, SOL_SOCKET, uv_addr_ip4_any_, uv_addr_ip6_any_, uv_fatal_error(), uv_ip4_addr(), uv_ip6_addr(), uv_tcp_non_ifs_lsp_ipv4, and uv_tcp_non_ifs_lsp_ipv6.

Referenced by uv_init().

uv_wsarecv_workaround()

int WSAAPI uv_wsarecv_workaround	(	SOCKET	socket,
		WSABUF *	buffers,
		DWORD	buffer_count,
		DWORD *	bytes,
		DWORD *	flags,
		WSAOVERLAPPED *	overlapped,
		LPWSAOVERLAPPED_COMPLETION_ROUTINE	completion_routine
	)

Definition at line 270 of file winsock.c.

                                                           {
  NTSTATUS status;
  void* apc_context;
  IO_STATUS_BLOCK* iosb = (IO_STATUS_BLOCK*) &overlapped->Internal;
  AFD_RECV_INFO info;
  DWORD error;
 
  if (overlapped == NULL || completion_routine != NULL) {
    WSASetLastError(WSAEINVAL);
    return SOCKET_ERROR;
  }
 
  info.BufferArray = buffers;
  info.BufferCount = buffer_count;
  info.AfdFlags = AFD_OVERLAPPED;
  info.TdiFlags = TDI_RECEIVE_NORMAL;
 
  if (*flags & MSG_PEEK) {
    info.TdiFlags |= TDI_RECEIVE_PEEK;
  }
 
  if (*flags & MSG_PARTIAL) {
    info.TdiFlags |= TDI_RECEIVE_PARTIAL;
  }
 
  if (!((intptr_t) overlapped->hEvent & 1)) {
    apc_context = (void*) overlapped;
  } else {
    apc_context = NULL;
  }
 
  iosb->Status = STATUS_PENDING;
  iosb->Pointer = 0;
 
  status = pNtDeviceIoControlFile((HANDLE) socket,
                                  overlapped->hEvent,
                                  NULL,
                                  apc_context,
                                  iosb,
                                  IOCTL_AFD_RECEIVE,
                                  &info,
                                  sizeof(info),
                                  NULL,
                                  0);
 
  *flags = 0;
  *bytes = (DWORD) iosb->Information;
 
  switch (status) {
    case STATUS_SUCCESS:
      error = ERROR_SUCCESS;
      break;
 
    case STATUS_PENDING:
      error = WSA_IO_PENDING;
      break;
 
    case STATUS_BUFFER_OVERFLOW:
      error = WSAEMSGSIZE;
      break;
 
    case STATUS_RECEIVE_EXPEDITED:
      error = ERROR_SUCCESS;
      *flags = MSG_OOB;
      break;
 
    case STATUS_RECEIVE_PARTIAL_EXPEDITED:
      error = ERROR_SUCCESS;
      *flags = MSG_PARTIAL | MSG_OOB;
      break;
 
    case STATUS_RECEIVE_PARTIAL:
      error = ERROR_SUCCESS;
      *flags = MSG_PARTIAL;
      break;
 
    default:
      error = uv_ntstatus_to_winsock_error(status);
      break;
  }
 
  WSASetLastError(error);
 
  if (error == ERROR_SUCCESS) {
    return 0;
  } else {
    return SOCKET_ERROR;
  }
}

References AFD_OVERLAPPED, bytes, DWORD, error(), flags, HANDLE, if(), info(), _IO_STATUS_BLOCK::Information, IOCTL_AFD_RECEIVE, NULL, pNtDeviceIoControlFile, _IO_STATUS_BLOCK::Pointer, socket, status, _IO_STATUS_BLOCK::Status, STATUS_BUFFER_OVERFLOW, STATUS_PENDING, STATUS_RECEIVE_EXPEDITED, STATUS_RECEIVE_PARTIAL, STATUS_RECEIVE_PARTIAL_EXPEDITED, STATUS_SUCCESS, TDI_RECEIVE_NORMAL, TDI_RECEIVE_PARTIAL, TDI_RECEIVE_PEEK, and uv_ntstatus_to_winsock_error().

Referenced by uv_udp_set_socket().

uv_wsarecvfrom_workaround()

int WSAAPI uv_wsarecvfrom_workaround	(	SOCKET	socket,
		WSABUF *	buffers,
		DWORD	buffer_count,
		DWORD *	bytes,
		DWORD *	flags,
		struct sockaddr *	addr,
		int *	addr_len,
		WSAOVERLAPPED *	overlapped,
		LPWSAOVERLAPPED_COMPLETION_ROUTINE	completion_routine
	)

Definition at line 364 of file winsock.c.

                                                           {
  NTSTATUS status;
  void* apc_context;
  IO_STATUS_BLOCK* iosb = (IO_STATUS_BLOCK*) &overlapped->Internal;
  AFD_RECV_DATAGRAM_INFO info;
  DWORD error;
 
  if (overlapped == NULL || addr == NULL || addr_len == NULL ||
      completion_routine != NULL) {
    WSASetLastError(WSAEINVAL);
    return SOCKET_ERROR;
  }
 
  info.BufferArray = buffers;
  info.BufferCount = buffer_count;
  info.AfdFlags = AFD_OVERLAPPED;
  info.TdiFlags = TDI_RECEIVE_NORMAL;
  info.Address = addr;
  info.AddressLength = addr_len;
 
  if (*flags & MSG_PEEK) {
    info.TdiFlags |= TDI_RECEIVE_PEEK;
  }
 
  if (*flags & MSG_PARTIAL) {
    info.TdiFlags |= TDI_RECEIVE_PARTIAL;
  }
 
  if (!((intptr_t) overlapped->hEvent & 1)) {
    apc_context = (void*) overlapped;
  } else {
    apc_context = NULL;
  }
 
  iosb->Status = STATUS_PENDING;
  iosb->Pointer = 0;
 
  status = pNtDeviceIoControlFile((HANDLE) socket,
                                  overlapped->hEvent,
                                  NULL,
                                  apc_context,
                                  iosb,
                                  IOCTL_AFD_RECEIVE_DATAGRAM,
                                  &info,
                                  sizeof(info),
                                  NULL,
                                  0);
 
  *flags = 0;
  *bytes = (DWORD) iosb->Information;
 
  switch (status) {
    case STATUS_SUCCESS:
      error = ERROR_SUCCESS;
      break;
 
    case STATUS_PENDING:
      error = WSA_IO_PENDING;
      break;
 
    case STATUS_BUFFER_OVERFLOW:
      error = WSAEMSGSIZE;
      break;
 
    case STATUS_RECEIVE_EXPEDITED:
      error = ERROR_SUCCESS;
      *flags = MSG_OOB;
      break;
 
    case STATUS_RECEIVE_PARTIAL_EXPEDITED:
      error = ERROR_SUCCESS;
      *flags = MSG_PARTIAL | MSG_OOB;
      break;
 
    case STATUS_RECEIVE_PARTIAL:
      error = ERROR_SUCCESS;
      *flags = MSG_PARTIAL;
      break;
 
    default:
      error = uv_ntstatus_to_winsock_error(status);
      break;
  }
 
  WSASetLastError(error);
 
  if (error == ERROR_SUCCESS) {
    return 0;
  } else {
    return SOCKET_ERROR;
  }
}

References addr, AFD_OVERLAPPED, bytes, DWORD, error(), flags, HANDLE, if(), info(), _IO_STATUS_BLOCK::Information, IOCTL_AFD_RECEIVE_DATAGRAM, NULL, pNtDeviceIoControlFile, _IO_STATUS_BLOCK::Pointer, socket, status, _IO_STATUS_BLOCK::Status, STATUS_BUFFER_OVERFLOW, STATUS_PENDING, STATUS_RECEIVE_EXPEDITED, STATUS_RECEIVE_PARTIAL, STATUS_RECEIVE_PARTIAL_EXPEDITED, STATUS_SUCCESS, TDI_RECEIVE_NORMAL, TDI_RECEIVE_PARTIAL, TDI_RECEIVE_PEEK, and uv_ntstatus_to_winsock_error().

Referenced by uv_udp_set_socket().

Variable Documentation

syscall

const char* syscall

Definition at line 270 of file internal.h.

Referenced by linux_kill_thread(), resolve_syscalls(), uv__close_nocancel(), uv__dup3(), uv__fs_copy_file_range(), uv__getrandom(), uv__preadv(), uv__pwritev(), uv__random_sysctl(), uv__recvmmsg(), uv__sendmmsg(), uv__statx(), and uv_fatal_error().

uv_addr_ip4_any_

struct sockaddr_in uv_addr_ip4_any_

extern

Definition at line 31 of file winsock.c.

Referenced by uv__udp_connect(), uv__udp_recv_start(), uv__udp_send(), uv__udp_set_membership4(), uv__udp_set_source_membership4(), uv__udp_try_send(), uv_tcp_listen(), uv_tcp_try_connect(), and uv_winsock_init().

uv_addr_ip6_any_

struct sockaddr_in6 uv_addr_ip6_any_

extern

Definition at line 31 of file winsock.c.

Referenced by uv__convert_to_localhost_if_unspecified(), uv__udp_connect(), uv__udp_send(), uv__udp_set_membership6(), uv__udp_set_source_membership6(), uv__udp_try_send(), uv_tcp_try_connect(), and uv_winsock_init().

uv_tcp_non_ifs_lsp_ipv4

int uv_tcp_non_ifs_lsp_ipv4

extern

Definition at line 30 of file winsock.c.

Referenced by uv_tcp_set_socket(), uv_tcp_try_cancel_io(), and uv_winsock_init().

uv_tcp_non_ifs_lsp_ipv6

int uv_tcp_non_ifs_lsp_ipv6

extern

Definition at line 31 of file winsock.c.

Referenced by uv_tcp_set_socket(), uv_tcp_try_cancel_io(), and uv_winsock_init().