Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-09-13 09:14:34 

0001 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
0002  *
0003  * Permission is hereby granted, free of charge, to any person obtaining a copy
0004  * of this software and associated documentation files (the "Software"), to
0005  * deal in the Software without restriction, including without limitation the
0006  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
0007  * sell copies of the Software, and to permit persons to whom the Software is
0008  * furnished to do so, subject to the following conditions:
0009  *
0010  * The above copyright notice and this permission notice shall be included in
0011  * all copies or substantial portions of the Software.
0012  *
0013  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0014  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0015  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
0016  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
0017  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
0018  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
0019  * IN THE SOFTWARE.
0020  */
0021 
0022 #ifndef _WIN32_WINNT
0023 # define _WIN32_WINNT   0x0A00
0024 #endif
0025 
0026 #if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED)
0027 typedef intptr_t ssize_t;
0028 # define SSIZE_MAX INTPTR_MAX
0029 # define _SSIZE_T_
0030 # define _SSIZE_T_DEFINED
0031 #endif
0032 
0033 #include <winsock2.h>
0034 
0035 #ifndef LOCALE_INVARIANT
0036 # define LOCALE_INVARIANT 0x007f
0037 #endif
0038 
0039 #include <mswsock.h>
0040 /* Disable the typedef in mstcpip.h of MinGW. */
0041 #define _TCP_INITIAL_RTO_PARAMETERS _TCP_INITIAL_RTO_PARAMETERS__AVOID
0042 #define TCP_INITIAL_RTO_PARAMETERS TCP_INITIAL_RTO_PARAMETERS__AVOID
0043 #define PTCP_INITIAL_RTO_PARAMETERS PTCP_INITIAL_RTO_PARAMETERS__AVOID
0044 #include <ws2tcpip.h>
0045 #undef _TCP_INITIAL_RTO_PARAMETERS
0046 #undef TCP_INITIAL_RTO_PARAMETERS
0047 #undef PTCP_INITIAL_RTO_PARAMETERS
0048 #include <windows.h>
0049 
0050 #include <process.h>
0051 #include <signal.h>
0052 #include <fcntl.h>
0053 #include <sys/stat.h>
0054 #include <stdint.h>
0055 
0056 #include "uv/tree.h"
0057 #include "uv/threadpool.h"
0058 
0059 #define MAX_PIPENAME_LEN 256
0060 
0061 #ifndef S_IFLNK
0062 # define S_IFLNK 0xA000
0063 #endif
0064 
0065 /* Define missing in Windows Kit Include\{VERSION}\ucrt\sys\stat.h */
0066 #if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES && !defined(S_IFIFO)
0067 # define S_IFIFO _S_IFIFO
0068 #endif
0069 
0070 /* Additional signals supported by uv_signal and or uv_kill. The CRT defines
0071  * the following signals already:
0072  *
0073  *   #define SIGINT           2
0074  *   #define SIGILL           4
0075  *   #define SIGABRT_COMPAT   6
0076  *   #define SIGFPE           8
0077  *   #define SIGSEGV         11
0078  *   #define SIGTERM         15
0079  *   #define SIGBREAK        21
0080  *   #define SIGABRT         22
0081  *
0082  * The additional signals have values that are common on other Unix
0083  * variants (Linux and Darwin)
0084  */
0085 #define SIGHUP                1
0086 #define SIGQUIT               3
0087 #define SIGKILL               9
0088 #define SIGWINCH             28
0089 
0090 /* Redefine NSIG to take SIGWINCH into consideration */
0091 #if defined(NSIG) && NSIG <= SIGWINCH
0092 # undef NSIG
0093 #endif
0094 #ifndef NSIG
0095 # define NSIG SIGWINCH + 1
0096 #endif
0097 
0098 /* The CRT defines SIGABRT_COMPAT as 6, which equals SIGABRT on many unix-like
0099  * platforms. However MinGW doesn't define it, so we do. */
0100 #ifndef SIGABRT_COMPAT
0101 # define SIGABRT_COMPAT       6
0102 #endif
0103 
0104 /*
0105  * Guids and typedefs for winsock extension functions
0106  * Mingw32 doesn't have these :-(
0107  */
0108 #ifndef WSAID_ACCEPTEX
0109 # define WSAID_ACCEPTEX                                                       \
0110          {0xb5367df1, 0xcbac, 0x11cf,                                         \
0111          {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
0112 
0113 # define WSAID_CONNECTEX                                                      \
0114          {0x25a207b9, 0xddf3, 0x4660,                                         \
0115          {0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e}}
0116 
0117 # define WSAID_GETACCEPTEXSOCKADDRS                                           \
0118          {0xb5367df2, 0xcbac, 0x11cf,                                         \
0119          {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
0120 
0121 # define WSAID_DISCONNECTEX                                                   \
0122          {0x7fda2e11, 0x8630, 0x436f,                                         \
0123          {0xa0, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57}}
0124 
0125 # define WSAID_TRANSMITFILE                                                   \
0126          {0xb5367df0, 0xcbac, 0x11cf,                                         \
0127          {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
0128 
0129   typedef BOOL (PASCAL *LPFN_ACCEPTEX)
0130                       (SOCKET sListenSocket,
0131                        SOCKET sAcceptSocket,
0132                        PVOID lpOutputBuffer,
0133                        DWORD dwReceiveDataLength,
0134                        DWORD dwLocalAddressLength,
0135                        DWORD dwRemoteAddressLength,
0136                        LPDWORD lpdwBytesReceived,
0137                        LPOVERLAPPED lpOverlapped);
0138 
0139   typedef BOOL (PASCAL *LPFN_CONNECTEX)
0140                       (SOCKET s,
0141                        const struct sockaddr* name,
0142                        int namelen,
0143                        PVOID lpSendBuffer,
0144                        DWORD dwSendDataLength,
0145                        LPDWORD lpdwBytesSent,
0146                        LPOVERLAPPED lpOverlapped);
0147 
0148   typedef void (PASCAL *LPFN_GETACCEPTEXSOCKADDRS)
0149                       (PVOID lpOutputBuffer,
0150                        DWORD dwReceiveDataLength,
0151                        DWORD dwLocalAddressLength,
0152                        DWORD dwRemoteAddressLength,
0153                        LPSOCKADDR* LocalSockaddr,
0154                        LPINT LocalSockaddrLength,
0155                        LPSOCKADDR* RemoteSockaddr,
0156                        LPINT RemoteSockaddrLength);
0157 
0158   typedef BOOL (PASCAL *LPFN_DISCONNECTEX)
0159                       (SOCKET hSocket,
0160                        LPOVERLAPPED lpOverlapped,
0161                        DWORD dwFlags,
0162                        DWORD reserved);
0163 
0164   typedef BOOL (PASCAL *LPFN_TRANSMITFILE)
0165                       (SOCKET hSocket,
0166                        HANDLE hFile,
0167                        DWORD nNumberOfBytesToWrite,
0168                        DWORD nNumberOfBytesPerSend,
0169                        LPOVERLAPPED lpOverlapped,
0170                        LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
0171                        DWORD dwFlags);
0172 
0173   typedef PVOID RTL_SRWLOCK;
0174   typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK;
0175 #endif
0176 
0177 typedef int (WSAAPI* LPFN_WSARECV)
0178             (SOCKET socket,
0179              LPWSABUF buffers,
0180              DWORD buffer_count,
0181              LPDWORD bytes,
0182              LPDWORD flags,
0183              LPWSAOVERLAPPED overlapped,
0184              LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
0185 
0186 typedef int (WSAAPI* LPFN_WSARECVFROM)
0187             (SOCKET socket,
0188              LPWSABUF buffers,
0189              DWORD buffer_count,
0190              LPDWORD bytes,
0191              LPDWORD flags,
0192              struct sockaddr* addr,
0193              LPINT addr_len,
0194              LPWSAOVERLAPPED overlapped,
0195              LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
0196 
0197 #ifndef _NTDEF_
0198   typedef LONG NTSTATUS;
0199   typedef NTSTATUS *PNTSTATUS;
0200 #endif
0201 
0202 #ifndef RTL_CONDITION_VARIABLE_INIT
0203   typedef PVOID CONDITION_VARIABLE, *PCONDITION_VARIABLE;
0204 #endif
0205 
0206 typedef struct _AFD_POLL_HANDLE_INFO {
0207   HANDLE Handle;
0208   ULONG Events;
0209   NTSTATUS Status;
0210 } AFD_POLL_HANDLE_INFO, *PAFD_POLL_HANDLE_INFO;
0211 
0212 typedef struct _AFD_POLL_INFO {
0213   LARGE_INTEGER Timeout;
0214   ULONG NumberOfHandles;
0215   ULONG Exclusive;
0216   AFD_POLL_HANDLE_INFO Handles[1];
0217 } AFD_POLL_INFO, *PAFD_POLL_INFO;
0218 
0219 #define UV_MSAFD_PROVIDER_COUNT 4
0220 
0221 
0222 /**
0223  * It should be possible to cast uv_buf_t[] to WSABUF[]
0224  * see http://msdn.microsoft.com/en-us/library/ms741542(v=vs.85).aspx
0225  */
0226 typedef struct uv_buf_t {
0227   ULONG len;
0228   char* base;
0229 } uv_buf_t;
0230 
0231 typedef int uv_file;
0232 typedef SOCKET uv_os_sock_t;
0233 typedef HANDLE uv_os_fd_t;
0234 typedef int uv_pid_t;
0235 
0236 typedef HANDLE uv_thread_t;
0237 
0238 typedef HANDLE uv_sem_t;
0239 
0240 typedef CRITICAL_SECTION uv_mutex_t;
0241 
0242 /* This condition variable implementation is based on the SetEvent solution
0243  * (section 3.2) at http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
0244  * We could not use the SignalObjectAndWait solution (section 3.4) because
0245  * it want the 2nd argument (type uv_mutex_t) of uv_cond_wait() and
0246  * uv_cond_timedwait() to be HANDLEs, but we use CRITICAL_SECTIONs.
0247  */
0248 
0249 typedef union {
0250   CONDITION_VARIABLE cond_var;
0251   struct {
0252     unsigned int waiters_count;
0253     CRITICAL_SECTION waiters_count_lock;
0254     HANDLE signal_event;
0255     HANDLE broadcast_event;
0256   } unused_; /* TODO: retained for ABI compatibility; remove me in v2.x. */
0257 } uv_cond_t;
0258 
0259 typedef struct {
0260   SRWLOCK read_write_lock_;
0261   /* TODO: retained for ABI compatibility; remove me in v2.x */
0262 #ifdef _WIN64
0263   unsigned char padding_[72];
0264 #else
0265   unsigned char padding_[44];
0266 #endif
0267 } uv_rwlock_t;
0268 
0269 typedef struct {
0270   unsigned threshold;
0271   unsigned in;
0272   uv_mutex_t mutex;
0273   /* TODO: in v2 make this a uv_cond_t, without unused_ */
0274   CONDITION_VARIABLE cond;
0275   unsigned out;
0276 } uv_barrier_t;
0277 
0278 typedef struct {
0279   DWORD tls_index;
0280 } uv_key_t;
0281 
0282 #define UV_ONCE_INIT { 0, { NULL } }
0283 
0284 typedef struct uv_once_s {
0285   unsigned char unused;
0286   INIT_ONCE init_once;
0287 } uv_once_t;
0288 
0289 /* Platform-specific definitions for uv_spawn support. */
0290 typedef unsigned char uv_uid_t;
0291 typedef unsigned char uv_gid_t;
0292 
0293 typedef struct uv__dirent_s {
0294   int d_type;
0295   char d_name[1];
0296 } uv__dirent_t;
0297 
0298 #define UV_DIR_PRIVATE_FIELDS \
0299   HANDLE dir_handle;          \
0300   WIN32_FIND_DATAW find_data; \
0301   BOOL need_find_call;
0302 
0303 #define HAVE_DIRENT_TYPES
0304 #define UV__DT_DIR     UV_DIRENT_DIR
0305 #define UV__DT_FILE    UV_DIRENT_FILE
0306 #define UV__DT_LINK    UV_DIRENT_LINK
0307 #define UV__DT_FIFO    UV_DIRENT_FIFO
0308 #define UV__DT_SOCKET  UV_DIRENT_SOCKET
0309 #define UV__DT_CHAR    UV_DIRENT_CHAR
0310 #define UV__DT_BLOCK   UV_DIRENT_BLOCK
0311 
0312 /* Platform-specific definitions for uv_dlopen support. */
0313 #define UV_DYNAMIC FAR WINAPI
0314 typedef struct {
0315   HMODULE handle;
0316   char* errmsg;
0317 } uv_lib_t;
0318 
0319 #define UV_LOOP_PRIVATE_FIELDS                                                \
0320     /* The loop's I/O completion port */                                      \
0321   HANDLE iocp;                                                                \
0322   /* The current time according to the event loop. in msecs. */               \
0323   uint64_t time;                                                              \
0324   /* Tail of a single-linked circular queue of pending reqs. If the queue */  \
0325   /* is empty, tail_ is NULL. If there is only one item, */                   \
0326   /* tail_->next_req == tail_ */                                              \
0327   uv_req_t* pending_reqs_tail;                                                \
0328   /* Head of a single-linked list of closed handles */                        \
0329   uv_handle_t* endgame_handles;                                               \
0330   /* TODO(bnoordhuis) Stop heap-allocating |timer_heap| in libuv v2.x. */     \
0331   void* timer_heap;                                                           \
0332     /* Lists of active loop (prepare / check / idle) watchers */              \
0333   uv_prepare_t* prepare_handles;                                              \
0334   uv_check_t* check_handles;                                                  \
0335   uv_idle_t* idle_handles;                                                    \
0336   /* This pointer will refer to the prepare/check/idle handle whose */        \
0337   /* callback is scheduled to be called next. This is needed to allow */      \
0338   /* safe removal from one of the lists above while that list being */        \
0339   /* iterated over. */                                                        \
0340   uv_prepare_t* next_prepare_handle;                                          \
0341   uv_check_t* next_check_handle;                                              \
0342   uv_idle_t* next_idle_handle;                                                \
0343   /* This handle holds the peer sockets for the fast variant of uv_poll_t */  \
0344   SOCKET poll_peer_sockets[UV_MSAFD_PROVIDER_COUNT];                          \
0345   /* No longer used. */                                                       \
0346   unsigned int active_tcp_streams;                                            \
0347   /* No longer used. */                                                       \
0348   unsigned int active_udp_streams;                                            \
0349   /* Counter to started timer */                                              \
0350   uint64_t timer_counter;                                                     \
0351   /* Threadpool */                                                            \
0352   struct uv__queue wq;                                                        \
0353   uv_mutex_t wq_mutex;                                                        \
0354   uv_async_t wq_async;
0355 
0356 #define UV_REQ_TYPE_PRIVATE                                                   \
0357   /* TODO: remove the req suffix */                                           \
0358   UV_ACCEPT,                                                                  \
0359   UV_FS_EVENT_REQ,                                                            \
0360   UV_POLL_REQ,                                                                \
0361   UV_PROCESS_EXIT,                                                            \
0362   UV_READ,                                                                    \
0363   UV_UDP_RECV,                                                                \
0364   UV_WAKEUP,                                                                  \
0365   UV_SIGNAL_REQ,
0366 
0367 #define UV_REQ_PRIVATE_FIELDS                                                 \
0368   union {                                                                     \
0369     /* Used by I/O operations */                                              \
0370     struct {                                                                  \
0371       OVERLAPPED overlapped;                                                  \
0372       size_t queued_bytes;                                                    \
0373     } io;                                                                     \
0374     /* in v2, we can move these to the UV_CONNECT_PRIVATE_FIELDS */           \
0375     struct {                                                                  \
0376       ULONG_PTR result; /* overlapped.Internal is reused to hold the result */\
0377       HANDLE pipeHandle;                                                      \
0378       DWORD duplex_flags;                                                     \
0379       WCHAR* name;                                                             \
0380     } connect;                                                                \
0381   } u;                                                                        \
0382   struct uv_req_s* next_req;
0383 
0384 #define UV_WRITE_PRIVATE_FIELDS \
0385   int coalesced;                \
0386   uv_buf_t write_buffer;        \
0387   HANDLE event_handle;          \
0388   HANDLE wait_handle;
0389 
0390 #define UV_CONNECT_PRIVATE_FIELDS                                             \
0391   /* empty */
0392 
0393 #define UV_SHUTDOWN_PRIVATE_FIELDS                                            \
0394   /* empty */
0395 
0396 #define UV_UDP_SEND_PRIVATE_FIELDS                                            \
0397   /* empty */
0398 
0399 #define UV_PRIVATE_REQ_TYPES                                                  \
0400   typedef struct uv_pipe_accept_s {                                           \
0401     UV_REQ_FIELDS                                                             \
0402     HANDLE pipeHandle;                                                        \
0403     struct uv_pipe_accept_s* next_pending;                                    \
0404   } uv_pipe_accept_t;                                                         \
0405                                                                               \
0406   typedef struct uv_tcp_accept_s {                                            \
0407     UV_REQ_FIELDS                                                             \
0408     SOCKET accept_socket;                                                     \
0409     char accept_buffer[sizeof(struct sockaddr_storage) * 2 + 32];             \
0410     HANDLE event_handle;                                                      \
0411     HANDLE wait_handle;                                                       \
0412     struct uv_tcp_accept_s* next_pending;                                     \
0413   } uv_tcp_accept_t;                                                          \
0414                                                                               \
0415   typedef struct uv_read_s {                                                  \
0416     UV_REQ_FIELDS                                                             \
0417     HANDLE event_handle;                                                      \
0418     HANDLE wait_handle;                                                       \
0419   } uv_read_t;
0420 
0421 #define uv_stream_connection_fields                                           \
0422   unsigned int write_reqs_pending;                                            \
0423   uv_shutdown_t* shutdown_req;
0424 
0425 #define uv_stream_server_fields                                               \
0426   uv_connection_cb connection_cb;
0427 
0428 #define UV_STREAM_PRIVATE_FIELDS                                              \
0429   unsigned int reqs_pending;                                                  \
0430   int activecnt;                                                              \
0431   uv_read_t read_req;                                                         \
0432   union {                                                                     \
0433     struct { uv_stream_connection_fields } conn;                              \
0434     struct { uv_stream_server_fields     } serv;                              \
0435   } stream;
0436 
0437 #define uv_tcp_server_fields                                                  \
0438   uv_tcp_accept_t* accept_reqs;                                               \
0439   unsigned int processed_accepts;                                             \
0440   uv_tcp_accept_t* pending_accepts;                                           \
0441   LPFN_ACCEPTEX func_acceptex;
0442 
0443 #define uv_tcp_connection_fields                                              \
0444   uv_buf_t read_buffer;                                                       \
0445   LPFN_CONNECTEX func_connectex;
0446 
0447 #define UV_TCP_PRIVATE_FIELDS                                                 \
0448   SOCKET socket;                                                              \
0449   int delayed_error;                                                          \
0450   union {                                                                     \
0451     struct { uv_tcp_server_fields } serv;                                     \
0452     struct { uv_tcp_connection_fields } conn;                                 \
0453   } tcp;
0454 
0455 #define UV_UDP_PRIVATE_FIELDS                                                 \
0456   SOCKET socket;                                                              \
0457   unsigned int reqs_pending;                                                  \
0458   int activecnt;                                                              \
0459   uv_req_t recv_req;                                                          \
0460   uv_buf_t recv_buffer;                                                       \
0461   struct sockaddr_storage recv_from;                                          \
0462   int recv_from_len;                                                          \
0463   uv_udp_recv_cb recv_cb;                                                     \
0464   uv_alloc_cb alloc_cb;                                                       \
0465   LPFN_WSARECV func_wsarecv;                                                  \
0466   LPFN_WSARECVFROM func_wsarecvfrom;
0467 
0468 #define uv_pipe_server_fields                                                 \
0469   int pending_instances;                                                      \
0470   uv_pipe_accept_t* accept_reqs;                                              \
0471   uv_pipe_accept_t* pending_accepts;
0472 
0473 #define uv_pipe_connection_fields                                             \
0474   uv_timer_t* eof_timer;                                                      \
0475   uv_write_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \
0476   DWORD ipc_remote_pid;                                                       \
0477   union {                                                                     \
0478     uint32_t payload_remaining;                                               \
0479     uint64_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \
0480   } ipc_data_frame;                                                           \
0481   struct uv__queue ipc_xfer_queue;                                            \
0482   int ipc_xfer_queue_length;                                                  \
0483   uv_write_t* non_overlapped_writes_tail;                                     \
0484   CRITICAL_SECTION readfile_thread_lock;                                      \
0485   volatile HANDLE readfile_thread_handle;
0486 
0487 #define UV_PIPE_PRIVATE_FIELDS                                                \
0488   HANDLE handle;                                                              \
0489   WCHAR* name;                                                                \
0490   union {                                                                     \
0491     struct { uv_pipe_server_fields } serv;                                    \
0492     struct { uv_pipe_connection_fields } conn;                                \
0493   } pipe;
0494 
0495 /* TODO: put the parser states in a union - TTY handles are always half-duplex
0496  * so read-state can safely overlap write-state. */
0497 #define UV_TTY_PRIVATE_FIELDS                                                 \
0498   HANDLE handle;                                                              \
0499   union {                                                                     \
0500     struct {                                                                  \
0501       /* Used for readable TTY handles */                                     \
0502       union {                                                                 \
0503         /* TODO: remove me in v2.x. */                                        \
0504         HANDLE unused_;                                                       \
0505         int mode;                                                             \
0506       } mode;                                                                 \
0507       uv_buf_t read_line_buffer;                                              \
0508       HANDLE read_raw_wait;                                                   \
0509       /* Fields used for translating win keystrokes into vt100 characters */  \
0510       char last_key[8];                                                       \
0511       unsigned char last_key_offset;                                          \
0512       unsigned char last_key_len;                                             \
0513       WCHAR last_utf16_high_surrogate;                                        \
0514       INPUT_RECORD last_input_record;                                         \
0515     } rd;                                                                     \
0516     struct {                                                                  \
0517       /* Used for writable TTY handles */                                     \
0518       /* utf8-to-utf16 conversion state */                                    \
0519       unsigned int utf8_codepoint;                                            \
0520       unsigned char utf8_bytes_left;                                          \
0521       /* eol conversion state */                                              \
0522       unsigned char previous_eol;                                             \
0523       /* ansi parser state */                                                 \
0524       unsigned short ansi_parser_state;                                       \
0525       unsigned char ansi_csi_argc;                                            \
0526       unsigned short ansi_csi_argv[4];                                        \
0527       COORD saved_position;                                                   \
0528       WORD saved_attributes;                                                  \
0529     } wr;                                                                     \
0530   } tty;
0531 
0532 #define UV_POLL_PRIVATE_FIELDS                                                \
0533   SOCKET socket;                                                              \
0534   /* Used in fast mode */                                                     \
0535   SOCKET peer_socket;                                                         \
0536   AFD_POLL_INFO afd_poll_info_1;                                              \
0537   AFD_POLL_INFO afd_poll_info_2;                                              \
0538   /* Used in fast and slow mode. */                                           \
0539   uv_req_t poll_req_1;                                                        \
0540   uv_req_t poll_req_2;                                                        \
0541   unsigned char submitted_events_1;                                           \
0542   unsigned char submitted_events_2;                                           \
0543   unsigned char mask_events_1;                                                \
0544   unsigned char mask_events_2;                                                \
0545   unsigned char events;
0546 
0547 #define UV_TIMER_PRIVATE_FIELDS                                               \
0548   union {                                                                     \
0549     void* heap[3];                                                            \
0550     struct uv__queue queue;                                                   \
0551   } node;                                                                     \
0552   int unused;                                                                 \
0553   uint64_t timeout;                                                           \
0554   uint64_t repeat;                                                            \
0555   uint64_t start_id;                                                          \
0556   uv_timer_cb timer_cb;
0557 
0558 #define UV_ASYNC_PRIVATE_FIELDS                                               \
0559   struct uv_req_s async_req;                                                  \
0560   uv_async_cb async_cb;                                                       \
0561   /* char to avoid alignment issues */                                        \
0562   char volatile async_sent;
0563 
0564 #define UV_PREPARE_PRIVATE_FIELDS                                             \
0565   uv_prepare_t* prepare_prev;                                                 \
0566   uv_prepare_t* prepare_next;                                                 \
0567   uv_prepare_cb prepare_cb;
0568 
0569 #define UV_CHECK_PRIVATE_FIELDS                                               \
0570   uv_check_t* check_prev;                                                     \
0571   uv_check_t* check_next;                                                     \
0572   uv_check_cb check_cb;
0573 
0574 #define UV_IDLE_PRIVATE_FIELDS                                                \
0575   uv_idle_t* idle_prev;                                                       \
0576   uv_idle_t* idle_next;                                                       \
0577   uv_idle_cb idle_cb;
0578 
0579 #define UV_HANDLE_PRIVATE_FIELDS                                              \
0580   uv_handle_t* endgame_next;                                                  \
0581   unsigned int flags;
0582 
0583 #define UV_GETADDRINFO_PRIVATE_FIELDS                                         \
0584   struct uv__work work_req;                                                   \
0585   uv_getaddrinfo_cb getaddrinfo_cb;                                           \
0586   void* alloc;                                                                \
0587   WCHAR* node;                                                                \
0588   WCHAR* service;                                                             \
0589   /* The addrinfoW field is used to store a pointer to the hints, and    */   \
0590   /* later on to store the result of GetAddrInfoW. The final result will */   \
0591   /* be converted to struct addrinfo* and stored in the addrinfo field.  */   \
0592   struct addrinfoW* addrinfow;                                                \
0593   struct addrinfo* addrinfo;                                                  \
0594   int retcode;
0595 
0596 #define UV_GETNAMEINFO_PRIVATE_FIELDS                                         \
0597   struct uv__work work_req;                                                   \
0598   uv_getnameinfo_cb getnameinfo_cb;                                           \
0599   struct sockaddr_storage storage;                                            \
0600   int flags;                                                                  \
0601   char host[NI_MAXHOST];                                                      \
0602   char service[NI_MAXSERV];                                                   \
0603   int retcode;
0604 
0605 #define UV_PROCESS_PRIVATE_FIELDS                                             \
0606   struct uv_process_exit_s {                                                  \
0607     UV_REQ_FIELDS                                                             \
0608   } exit_req;                                                                 \
0609   void* unused; /* TODO: retained for ABI compat; remove this in v2.x. */     \
0610   int exit_signal;                                                            \
0611   HANDLE wait_handle;                                                         \
0612   HANDLE process_handle;                                                      \
0613   volatile char exit_cb_pending;
0614 
0615 #define UV_FS_PRIVATE_FIELDS                                                  \
0616   struct uv__work work_req;                                                   \
0617   int flags;                                                                  \
0618   DWORD sys_errno_;                                                           \
0619   union {                                                                     \
0620     /* TODO: remove me in 0.9. */                                             \
0621     WCHAR* pathw;                                                             \
0622     int fd;                                                                   \
0623   } file;                                                                     \
0624   union {                                                                     \
0625     struct {                                                                  \
0626       int mode;                                                               \
0627       WCHAR* new_pathw;                                                       \
0628       int file_flags;                                                         \
0629       int fd_out;                                                             \
0630       unsigned int nbufs;                                                     \
0631       uv_buf_t* bufs;                                                         \
0632       int64_t offset;                                                         \
0633       uv_buf_t bufsml[4];                                                     \
0634     } info;                                                                   \
0635     struct {                                                                  \
0636       double atime;                                                           \
0637       double mtime;                                                           \
0638     } time;                                                                   \
0639   } fs;
0640 
0641 #define UV_WORK_PRIVATE_FIELDS                                                \
0642   struct uv__work work_req;
0643 
0644 #define UV_FS_EVENT_PRIVATE_FIELDS                                            \
0645   struct uv_fs_event_req_s {                                                  \
0646     UV_REQ_FIELDS                                                             \
0647   } req;                                                                      \
0648   HANDLE dir_handle;                                                          \
0649   int req_pending;                                                            \
0650   uv_fs_event_cb cb;                                                          \
0651   WCHAR* filew;                                                               \
0652   WCHAR* short_filew;                                                         \
0653   WCHAR* dirw;                                                                \
0654   char* buffer;
0655 
0656 #define UV_SIGNAL_PRIVATE_FIELDS                                              \
0657   RB_ENTRY(uv_signal_s) tree_entry;                                           \
0658   struct uv_req_s signal_req;                                                 \
0659   unsigned long pending_signum;
0660 
0661 #ifndef F_OK
0662 #define F_OK 0
0663 #endif
0664 #ifndef R_OK
0665 #define R_OK 4
0666 #endif
0667 #ifndef W_OK
0668 #define W_OK 2
0669 #endif
0670 #ifndef X_OK
0671 #define X_OK 1
0672 #endif
0673 
0674 /* fs open() flags supported on this platform: */
0675 #define UV_FS_O_APPEND       _O_APPEND
0676 #define UV_FS_O_CREAT        _O_CREAT
0677 #define UV_FS_O_EXCL         _O_EXCL
0678 #define UV_FS_O_FILEMAP      0x20000000
0679 #define UV_FS_O_RANDOM       _O_RANDOM
0680 #define UV_FS_O_RDONLY       _O_RDONLY
0681 #define UV_FS_O_RDWR         _O_RDWR
0682 #define UV_FS_O_SEQUENTIAL   _O_SEQUENTIAL
0683 #define UV_FS_O_SHORT_LIVED  _O_SHORT_LIVED
0684 #define UV_FS_O_TEMPORARY    _O_TEMPORARY
0685 #define UV_FS_O_TRUNC        _O_TRUNC
0686 #define UV_FS_O_WRONLY       _O_WRONLY
0687 
0688 /* fs open() flags supported on other platforms (or mapped on this platform): */
0689 #define UV_FS_O_DIRECT       0x02000000 /* FILE_FLAG_NO_BUFFERING */
0690 #define UV_FS_O_DIRECTORY    0
0691 #define UV_FS_O_DSYNC        0x04000000 /* FILE_FLAG_WRITE_THROUGH */
0692 #define UV_FS_O_EXLOCK       0x10000000 /* EXCLUSIVE SHARING MODE */
0693 #define UV_FS_O_NOATIME      0
0694 #define UV_FS_O_NOCTTY       0
0695 #define UV_FS_O_NOFOLLOW     0
0696 #define UV_FS_O_NONBLOCK     0
0697 #define UV_FS_O_SYMLINK      0
0698 #define UV_FS_O_SYNC         0x08000000 /* FILE_FLAG_WRITE_THROUGH */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!