/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 */

#ifndef _WIN32_WINNT

# define _WIN32_WINNT   0x0600

#endif

#if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED)

typedef intptr_t ssize_t;

# define SSIZE_MAX INTPTR_MAX

# define _SSIZE_T_

# define _SSIZE_T_DEFINED

#endif

#include <winsock2.h>

#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)

typedef struct pollfd {

  SOCKET fd;

  short  events;

  short  revents;

} WSAPOLLFD, *PWSAPOLLFD, *LPWSAPOLLFD;

#endif

#ifndef LOCALE_INVARIANT

# define LOCALE_INVARIANT 0x007f

#endif

#include <mswsock.h>

#include <ws2tcpip.h>

#include <windows.h>

#include <process.h>

#include <signal.h>

#include <fcntl.h>

#include <sys/stat.h>

#if defined(_MSC_VER) && _MSC_VER < 1600

# include "uv/stdint-msvc2008.h"

#else

# include <stdint.h>

#endif

#include "uv/tree.h"

#include "uv/threadpool.h"

#define MAX_PIPENAME_LEN 256

#ifndef S_IFLNK

# define S_IFLNK 0xA000

#endif

/* Additional signals supported by uv_signal and or uv_kill. The CRT defines

 * the following signals already:

 *

 *   #define SIGINT           2

 *   #define SIGILL           4

 *   #define SIGABRT_COMPAT   6

 *   #define SIGFPE           8

 *   #define SIGSEGV         11

 *   #define SIGTERM         15

 *   #define SIGBREAK        21

 *   #define SIGABRT         22

 *

 * The additional signals have values that are common on other Unix

 * variants (Linux and Darwin)

 */

#define SIGHUP                1

#define SIGKILL               9

#define SIGWINCH             28

/* Redefine NSIG to take SIGWINCH into consideration */

#if defined(NSIG) && NSIG <= SIGWINCH

# undef NSIG

#endif

#ifndef NSIG

# define NSIG SIGWINCH + 1

#endif

/* The CRT defines SIGABRT_COMPAT as 6, which equals SIGABRT on many unix-like

 * platforms. However MinGW doesn't define it, so we do. */

#ifndef SIGABRT_COMPAT

# define SIGABRT_COMPAT       6

#endif

/*

 * Guids and typedefs for winsock extension functions

 * Mingw32 doesn't have these :-(

 */

#ifndef WSAID_ACCEPTEX

# define WSAID_ACCEPTEX                                                       \

         {0xb5367df1, 0xcbac, 0x11cf,                                         \

         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}

# define WSAID_CONNECTEX                                                      \

         {0x25a207b9, 0xddf3, 0x4660,                                         \

         {0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e}}

# define WSAID_GETACCEPTEXSOCKADDRS                                           \

         {0xb5367df2, 0xcbac, 0x11cf,                                         \

         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}

# define WSAID_DISCONNECTEX                                                   \

         {0x7fda2e11, 0x8630, 0x436f,                                         \

         {0xa0, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57}}

# define WSAID_TRANSMITFILE                                                   \

         {0xb5367df0, 0xcbac, 0x11cf,                                         \

         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}

  typedef BOOL (PASCAL *LPFN_ACCEPTEX)

                      (SOCKET sListenSocket,

                       SOCKET sAcceptSocket,

                       PVOID lpOutputBuffer,

                       DWORD dwReceiveDataLength,

                       DWORD dwLocalAddressLength,

                       DWORD dwRemoteAddressLength,

                       LPDWORD lpdwBytesReceived,

                       LPOVERLAPPED lpOverlapped);

  typedef BOOL (PASCAL *LPFN_CONNECTEX)

                      (SOCKET s,

                       const struct sockaddr* name,

                       int namelen,

                       PVOID lpSendBuffer,

                       DWORD dwSendDataLength,

                       LPDWORD lpdwBytesSent,

                       LPOVERLAPPED lpOverlapped);

  typedef void (PASCAL *LPFN_GETACCEPTEXSOCKADDRS)

                      (PVOID lpOutputBuffer,

                       DWORD dwReceiveDataLength,

                       DWORD dwLocalAddressLength,

                       DWORD dwRemoteAddressLength,

                       LPSOCKADDR* LocalSockaddr,

                       LPINT LocalSockaddrLength,

                       LPSOCKADDR* RemoteSockaddr,

                       LPINT RemoteSockaddrLength);

  typedef BOOL (PASCAL *LPFN_DISCONNECTEX)

                      (SOCKET hSocket,

                       LPOVERLAPPED lpOverlapped,

                       DWORD dwFlags,

                       DWORD reserved);

  typedef BOOL (PASCAL *LPFN_TRANSMITFILE)

                      (SOCKET hSocket,

                       HANDLE hFile,

                       DWORD nNumberOfBytesToWrite,

                       DWORD nNumberOfBytesPerSend,

                       LPOVERLAPPED lpOverlapped,

                       LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,

                       DWORD dwFlags);

  typedef PVOID RTL_SRWLOCK;

  typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK;

#endif

typedef int (WSAAPI* LPFN_WSARECV)

            (SOCKET socket,

             LPWSABUF buffers,

             DWORD buffer_count,

             LPDWORD bytes,

             LPDWORD flags,

             LPWSAOVERLAPPED overlapped,

             LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);

typedef int (WSAAPI* LPFN_WSARECVFROM)

            (SOCKET socket,

             LPWSABUF buffers,

             DWORD buffer_count,

             LPDWORD bytes,

             LPDWORD flags,

             struct sockaddr* addr,

             LPINT addr_len,

             LPWSAOVERLAPPED overlapped,

             LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);

#ifndef _NTDEF_

  typedef LONG NTSTATUS;

  typedef NTSTATUS *PNTSTATUS;

#endif

#ifndef RTL_CONDITION_VARIABLE_INIT

  typedef PVOID CONDITION_VARIABLE, *PCONDITION_VARIABLE;

#endif

typedef struct _AFD_POLL_HANDLE_INFO {

  HANDLE Handle;

  ULONG Events;

  NTSTATUS Status;

} AFD_POLL_HANDLE_INFO, *PAFD_POLL_HANDLE_INFO;

typedef struct _AFD_POLL_INFO {

  LARGE_INTEGER Timeout;

  ULONG NumberOfHandles;

  ULONG Exclusive;

  AFD_POLL_HANDLE_INFO Handles[1];

} AFD_POLL_INFO, *PAFD_POLL_INFO;

#define UV_MSAFD_PROVIDER_COUNT 3

/**

 * It should be possible to cast uv_buf_t[] to WSABUF[]

 * see http://msdn.microsoft.com/en-us/library/ms741542(v=vs.85).aspx

 */

typedef struct uv_buf_t {

  ULONG len;

  char* base;

} uv_buf_t;

typedef int uv_file;

typedef SOCKET uv_os_sock_t;

typedef HANDLE uv_os_fd_t;

typedef int uv_pid_t;

typedef HANDLE uv_thread_t;

typedef HANDLE uv_sem_t;

typedef CRITICAL_SECTION uv_mutex_t;

/* This condition variable implementation is based on the SetEvent solution

 * (section 3.2) at http://www.cs.wustl.edu/~schmidt/win32-cv-1.html

 * We could not use the SignalObjectAndWait solution (section 3.4) because

 * it want the 2nd argument (type uv_mutex_t) of uv_cond_wait() and

 * uv_cond_timedwait() to be HANDLEs, but we use CRITICAL_SECTIONs.

 */

typedef union {

  CONDITION_VARIABLE cond_var;

  struct {

    unsigned int waiters_count;

    CRITICAL_SECTION waiters_count_lock;

    HANDLE signal_event;

    HANDLE broadcast_event;

  } unused_; /* TODO: retained for ABI compatibility; remove me in v2.x. */

} uv_cond_t;

typedef union {

  struct {

    unsigned int num_readers_;

    CRITICAL_SECTION num_readers_lock_;

    HANDLE write_semaphore_;

  } state_;

  /* TODO: remove me in v2.x. */

  struct {

    SRWLOCK unused_;

  } unused1_;

  /* TODO: remove me in v2.x. */

  struct {

    uv_mutex_t unused1_;

    uv_mutex_t unused2_;

  } unused2_;

} uv_rwlock_t;

typedef struct {

  unsigned int n;

  unsigned int count;

  uv_mutex_t mutex;

  uv_sem_t turnstile1;

  uv_sem_t turnstile2;

} uv_barrier_t;

typedef struct {

  DWORD tls_index;

} uv_key_t;

#define UV_ONCE_INIT { 0, NULL }

typedef struct uv_once_s {

  unsigned char ran;

  HANDLE event;

} uv_once_t;

/* Platform-specific definitions for uv_spawn support. */

typedef unsigned char uv_uid_t;

typedef unsigned char uv_gid_t;

typedef struct uv__dirent_s {

  int d_type;

  char d_name[1];

} uv__dirent_t;

#define UV_DIR_PRIVATE_FIELDS \

  HANDLE dir_handle;          \

  WIN32_FIND_DATAW find_data; \

  BOOL need_find_call;

#define HAVE_DIRENT_TYPES

#define UV__DT_DIR     UV_DIRENT_DIR

#define UV__DT_FILE    UV_DIRENT_FILE

#define UV__DT_LINK    UV_DIRENT_LINK

#define UV__DT_FIFO    UV_DIRENT_FIFO

#define UV__DT_SOCKET  UV_DIRENT_SOCKET

#define UV__DT_CHAR    UV_DIRENT_CHAR

#define UV__DT_BLOCK   UV_DIRENT_BLOCK

/* Platform-specific definitions for uv_dlopen support. */

#define UV_DYNAMIC FAR WINAPI

typedef struct {

  HMODULE handle;

  char* errmsg;

} uv_lib_t;

#define UV_LOOP_PRIVATE_FIELDS                                                \

    /* The loop's I/O completion port */                                      \

  HANDLE iocp;                                                                \

  /* The current time according to the event loop. in msecs. */               \

  uint64_t time;                                                              \

  /* Tail of a single-linked circular queue of pending reqs. If the queue */  \

  /* is empty, tail_ is NULL. If there is only one item, */                   \

  /* tail_->next_req == tail_ */                                              \

  uv_req_t* pending_reqs_tail;                                                \

  /* Head of a single-linked list of closed handles */                        \

  uv_handle_t* endgame_handles;                                               \

  /* TODO(bnoordhuis) Stop heap-allocating |timer_heap| in libuv v2.x. */     \

  void* timer_heap;                                                           \

    /* Lists of active loop (prepare / check / idle) watchers */              \

  uv_prepare_t* prepare_handles;                                              \

  uv_check_t* check_handles;                                                  \

  uv_idle_t* idle_handles;                                                    \

  /* This pointer will refer to the prepare/check/idle handle whose */        \

  /* callback is scheduled to be called next. This is needed to allow */      \

  /* safe removal from one of the lists above while that list being */        \

  /* iterated over. */                                                        \

  uv_prepare_t* next_prepare_handle;                                          \

  uv_check_t* next_check_handle;                                              \

  uv_idle_t* next_idle_handle;                                                \

  /* This handle holds the peer sockets for the fast variant of uv_poll_t */  \

  SOCKET poll_peer_sockets[UV_MSAFD_PROVIDER_COUNT];                          \

  /* Counter to keep track of active tcp streams */                           \

  unsigned int active_tcp_streams;                                            \

  /* Counter to keep track of active udp streams */                           \

  unsigned int active_udp_streams;                                            \

  /* Counter to started timer */                                              \

  uint64_t timer_counter;                                                     \

  /* Threadpool */                                                            \

  void* wq[2];                                                                \

  uv_mutex_t wq_mutex;                                                        \

  uv_async_t wq_async;

#define UV_REQ_TYPE_PRIVATE                                                   \

  /* TODO: remove the req suffix */                                           \

  UV_ACCEPT,                                                                  \

  UV_FS_EVENT_REQ,                                                            \

  UV_POLL_REQ,                                                                \

  UV_PROCESS_EXIT,                                                            \

  UV_READ,                                                                    \

  UV_UDP_RECV,                                                                \

  UV_WAKEUP,                                                                  \

  UV_SIGNAL_REQ,

#define UV_REQ_PRIVATE_FIELDS                                                 \

  union {                                                                     \

    /* Used by I/O operations */                                              \

    struct {                                                                  \

      OVERLAPPED overlapped;                                                  \

      size_t queued_bytes;                                                    \

    } io;                                                                     \

  } u;                                                                        \

  struct uv_req_s* next_req;

#define UV_WRITE_PRIVATE_FIELDS \

  int coalesced;                \

  uv_buf_t write_buffer;        \

  HANDLE event_handle;          \

  HANDLE wait_handle;

#define UV_CONNECT_PRIVATE_FIELDS                                             \

  /* empty */

#define UV_SHUTDOWN_PRIVATE_FIELDS                                            \

  /* empty */

#define UV_UDP_SEND_PRIVATE_FIELDS                                            \

  /* empty */

#define UV_PRIVATE_REQ_TYPES                                                  \

  typedef struct uv_pipe_accept_s {                                           \

    UV_REQ_FIELDS                                                             \

    HANDLE pipeHandle;                                                        \

    struct uv_pipe_accept_s* next_pending;                                    \

  } uv_pipe_accept_t;                                                         \

                                                                              \

  typedef struct uv_tcp_accept_s {                                            \

    UV_REQ_FIELDS                                                             \

    SOCKET accept_socket;                                                     \

    char accept_buffer[sizeof(struct sockaddr_storage) * 2 + 32];             \

    HANDLE event_handle;                                                      \

    HANDLE wait_handle;                                                       \

    struct uv_tcp_accept_s* next_pending;                                     \

  } uv_tcp_accept_t;                                                          \

                                                                              \

  typedef struct uv_read_s {                                                  \

    UV_REQ_FIELDS                                                             \

    HANDLE event_handle;                                                      \

    HANDLE wait_handle;                                                       \

  } uv_read_t;

#define uv_stream_connection_fields                                           \

  unsigned int write_reqs_pending;                                            \

  uv_shutdown_t* shutdown_req;

#define uv_stream_server_fields                                               \

  uv_connection_cb connection_cb;

#define UV_STREAM_PRIVATE_FIELDS                                              \

  unsigned int reqs_pending;                                                  \

  int activecnt;                                                              \

  uv_read_t read_req;                                                         \

  union {                                                                     \

    struct { uv_stream_connection_fields } conn;                              \

    struct { uv_stream_server_fields     } serv;                              \

  } stream;

#define uv_tcp_server_fields                                                  \

  uv_tcp_accept_t* accept_reqs;                                               \

  unsigned int processed_accepts;                                             \

  uv_tcp_accept_t* pending_accepts;                                           \

  LPFN_ACCEPTEX func_acceptex;

#define uv_tcp_connection_fields                                              \

  uv_buf_t read_buffer;                                                       \

  LPFN_CONNECTEX func_connectex;

#define UV_TCP_PRIVATE_FIELDS                                                 \

  SOCKET socket;                                                              \

  int delayed_error;                                                          \

  union {                                                                     \

    struct { uv_tcp_server_fields } serv;                                     \

    struct { uv_tcp_connection_fields } conn;                                 \

  } tcp;

#define UV_UDP_PRIVATE_FIELDS                                                 \

  SOCKET socket;                                                              \

  unsigned int reqs_pending;                                                  \

  int activecnt;                                                              \

  uv_req_t recv_req;                                                          \

  uv_buf_t recv_buffer;                                                       \

  struct sockaddr_storage recv_from;                                          \

  int recv_from_len;                                                          \

  uv_udp_recv_cb recv_cb;                                                     \

  uv_alloc_cb alloc_cb;                                                       \

  LPFN_WSARECV func_wsarecv;                                                  \

  LPFN_WSARECVFROM func_wsarecvfrom;

#define uv_pipe_server_fields                                                 \

  int pending_instances;                                                      \

  uv_pipe_accept_t* accept_reqs;                                              \

  uv_pipe_accept_t* pending_accepts;

#define uv_pipe_connection_fields                                             \

  uv_timer_t* eof_timer;                                                      \

  uv_write_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \

  DWORD ipc_remote_pid;                                                       \

  union {                                                                     \

    uint32_t payload_remaining;                                               \

    uint64_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \

  } ipc_data_frame;                                                           \

  void* ipc_xfer_queue[2];                                                    \

  int ipc_xfer_queue_length;                                                  \

  uv_write_t* non_overlapped_writes_tail;                                     \

  CRITICAL_SECTION readfile_thread_lock;                                      \

  volatile HANDLE readfile_thread_handle;

#define UV_PIPE_PRIVATE_FIELDS                                                \

  HANDLE handle;                                                              \

  WCHAR* name;                                                                \

  union {                                                                     \

    struct { uv_pipe_server_fields } serv;                                    \

    struct { uv_pipe_connection_fields } conn;                                \

  } pipe;

/* TODO: put the parser states in an union - TTY handles are always half-duplex

 * so read-state can safely overlap write-state. */

#define UV_TTY_PRIVATE_FIELDS                                                 \

  HANDLE handle;                                                              \

  union {                                                                     \

    struct {                                                                  \

      /* Used for readable TTY handles */                                     \

      /* TODO: remove me in v2.x. */                                          \

      HANDLE unused_;                                                         \

      uv_buf_t read_line_buffer;                                              \

      HANDLE read_raw_wait;                                                   \

      /* Fields used for translating win keystrokes into vt100 characters */  \

      char last_key[8];                                                       \

      unsigned char last_key_offset;                                          \

      unsigned char last_key_len;                                             \

      WCHAR last_utf16_high_surrogate;                                        \

      INPUT_RECORD last_input_record;                                         \

    } rd;                                                                     \

    struct {                                                                  \

      /* Used for writable TTY handles */                                     \

      /* utf8-to-utf16 conversion state */                                    \

      unsigned int utf8_codepoint;                                            \

      unsigned char utf8_bytes_left;                                          \

      /* eol conversion state */                                              \

      unsigned char previous_eol;                                             \

      /* ansi parser state */                                                 \

      unsigned short ansi_parser_state;                                       \

      unsigned char ansi_csi_argc;                                            \

      unsigned short ansi_csi_argv[4];                                        \

      COORD saved_position;                                                   \

      WORD saved_attributes;                                                  \

    } wr;                                                                     \

  } tty;

#define UV_POLL_PRIVATE_FIELDS                                                \

  SOCKET socket;                                                              \

  /* Used in fast mode */                                                     \

  SOCKET peer_socket;                                                         \

  AFD_POLL_INFO afd_poll_info_1;                                              \

  AFD_POLL_INFO afd_poll_info_2;                                              \

  /* Used in fast and slow mode. */                                           \

  uv_req_t poll_req_1;                                                        \

  uv_req_t poll_req_2;                                                        \

  unsigned char submitted_events_1;                                           \

  unsigned char submitted_events_2;                                           \

  unsigned char mask_events_1;                                                \

  unsigned char mask_events_2;                                                \

  unsigned char events;

#define UV_TIMER_PRIVATE_FIELDS                                               \

  void* heap_node[3];                                                         \

  int unused;                                                                 \

  uint64_t timeout;                                                           \

  uint64_t repeat;                                                            \

  uint64_t start_id;                                                          \

  uv_timer_cb timer_cb;

#define UV_ASYNC_PRIVATE_FIELDS                                               \

  struct uv_req_s async_req;                                                  \

  uv_async_cb async_cb;                                                       \

  /* char to avoid alignment issues */                                        \

  char volatile async_sent;

#define UV_PREPARE_PRIVATE_FIELDS                                             \

  uv_prepare_t* prepare_prev;                                                 \

  uv_prepare_t* prepare_next;                                                 \

  uv_prepare_cb prepare_cb;

#define UV_CHECK_PRIVATE_FIELDS                                               \

  uv_check_t* check_prev;                                                     \

  uv_check_t* check_next;                                                     \

  uv_check_cb check_cb;

#define UV_IDLE_PRIVATE_FIELDS                                                \

  uv_idle_t* idle_prev;                                                       \

  uv_idle_t* idle_next;                                                       \

  uv_idle_cb idle_cb;

#define UV_HANDLE_PRIVATE_FIELDS                                              \

  uv_handle_t* endgame_next;                                                  \

  unsigned int flags;

#define UV_GETADDRINFO_PRIVATE_FIELDS                                         \

  struct uv__work work_req;                                                   \

  uv_getaddrinfo_cb getaddrinfo_cb;                                           \

  void* alloc;                                                                \

  WCHAR* node;                                                                \

  WCHAR* service;                                                             \

  /* The addrinfoW field is used to store a pointer to the hints, and    */   \

  /* later on to store the result of GetAddrInfoW. The final result will */   \

  /* be converted to struct addrinfo* and stored in the addrinfo field.  */   \

  struct addrinfoW* addrinfow;                                                \

  struct addrinfo* addrinfo;                                                  \

  int retcode;

#define UV_GETNAMEINFO_PRIVATE_FIELDS                                         \

  struct uv__work work_req;                                                   \

  uv_getnameinfo_cb getnameinfo_cb;                                           \

  struct sockaddr_storage storage;                                            \

  int flags;                                                                  \

  char host[NI_MAXHOST];                                                      \

  char service[NI_MAXSERV];                                                   \

  int retcode;

#define UV_PROCESS_PRIVATE_FIELDS                                             \

  struct uv_process_exit_s {                                                  \

    UV_REQ_FIELDS                                                             \

  } exit_req;                                                                 \

  BYTE* child_stdio_buffer;                                                   \

  int exit_signal;                                                            \

  HANDLE wait_handle;                                                         \

  HANDLE process_handle;                                                      \

  volatile char exit_cb_pending;

#define UV_FS_PRIVATE_FIELDS                                                  \

  struct uv__work work_req;                                                   \

  int flags;                                                                  \

  DWORD sys_errno_;                                                           \

  union {                                                                     \

    /* TODO: remove me in 0.9. */                                             \

    WCHAR* pathw;                                                             \

    int fd;                                                                   \

  } file;                                                                     \

  union {                                                                     \

    struct {                                                                  \

      int mode;                                                               \

      WCHAR* new_pathw;                                                       \

      int file_flags;                                                         \

      int fd_out;                                                             \

      unsigned int nbufs;                                                     \

      uv_buf_t* bufs;                                                         \

      int64_t offset;                                                         \

      uv_buf_t bufsml[4];                                                     \

    } info;                                                                   \

    struct {                                                                  \

      double atime;                                                           \

      double mtime;                                                           \

    } time;                                                                   \

  } fs;

#define UV_WORK_PRIVATE_FIELDS                                                \

  struct uv__work work_req;

#define UV_FS_EVENT_PRIVATE_FIELDS                                            \

  struct uv_fs_event_req_s {                                                  \

    UV_REQ_FIELDS                                                             \

  } req;                                                                      \

  HANDLE dir_handle;                                                          \

  int req_pending;                                                            \

  uv_fs_event_cb cb;                                                          \

  WCHAR* filew;                                                               \

  WCHAR* short_filew;                                                         \

  WCHAR* dirw;                                                                \

  char* buffer;

#define UV_SIGNAL_PRIVATE_FIELDS                                              \

  RB_ENTRY(uv_signal_s) tree_entry;                                           \

  struct uv_req_s signal_req;                                                 \

  unsigned long pending_signum;

#ifndef F_OK

#define F_OK 0

#endif

#ifndef R_OK

#define R_OK 4

#endif

#ifndef W_OK

#define W_OK 2

#endif

#ifndef X_OK

#define X_OK 1

#endif

/* fs open() flags supported on this platform: */

#define UV_FS_O_APPEND       _O_APPEND

#define UV_FS_O_CREAT        _O_CREAT

#define UV_FS_O_EXCL         _O_EXCL

#define UV_FS_O_FILEMAP      0x20000000

#define UV_FS_O_RANDOM       _O_RANDOM

#define UV_FS_O_RDONLY       _O_RDONLY

#define UV_FS_O_RDWR         _O_RDWR

#define UV_FS_O_SEQUENTIAL   _O_SEQUENTIAL

#define UV_FS_O_SHORT_LIVED  _O_SHORT_LIVED

#define UV_FS_O_TEMPORARY    _O_TEMPORARY

#define UV_FS_O_TRUNC        _O_TRUNC

#define UV_FS_O_WRONLY       _O_WRONLY

/* fs open() flags supported on other platforms (or mapped on this platform): */

#define UV_FS_O_DIRECT       0x02000000 /* FILE_FLAG_NO_BUFFERING */

#define UV_FS_O_DIRECTORY    0

#define UV_FS_O_DSYNC        0x04000000 /* FILE_FLAG_WRITE_THROUGH */

#define UV_FS_O_EXLOCK       0x10000000 /* EXCLUSIVE SHARING MODE */

#define UV_FS_O_NOATIME      0

#define UV_FS_O_NOCTTY       0

#define UV_FS_O_NOFOLLOW     0

#define UV_FS_O_NONBLOCK     0

#define UV_FS_O_SYMLINK      0

#define UV_FS_O_SYNC         0x08000000 /* FILE_FLAG_WRITE_THROUGH */