1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2  *
3  * Permission is hereby granted, free of charge, to any person obtaining a copy
4  * of this software and associated documentation files (the "Software"), to
5  * deal in the Software without restriction, including without limitation the
6  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7  * sell copies of the Software, and to permit persons to whom the Software is
8  * furnished to do so, subject to the following conditions:
9  *
10  * The above copyright notice and this permission notice shall be included in
11  * all copies or substantial portions of the Software.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19  * IN THE SOFTWARE.
20  */
21 
22 #ifndef UV_WIN_INTERNAL_H_
23 #define UV_WIN_INTERNAL_H_
24 
25 #include "uv.h"
26 #include "../uv-common.h"
27 
28 #include "uv/tree.h"
29 #include "winapi.h"
30 #include "winsock.h"
31 
32 #ifdef _MSC_VER
33 # define INLINE __inline
34 # define UV_THREAD_LOCAL __declspec( thread )
35 #else
36 # define INLINE inline
37 # define UV_THREAD_LOCAL __thread
38 #endif
39 
40 
41 #ifdef _DEBUG
42 
43 extern UV_THREAD_LOCAL int uv__crt_assert_enabled;
44 
45 #define UV_BEGIN_DISABLE_CRT_ASSERT()                           \
46   {                                                             \
47     int uv__saved_crt_assert_enabled = uv__crt_assert_enabled;  \
48     uv__crt_assert_enabled = FALSE;
49 
50 
51 #define UV_END_DISABLE_CRT_ASSERT()                             \
52     uv__crt_assert_enabled = uv__saved_crt_assert_enabled;      \
53   }
54 
55 #else
56 #define UV_BEGIN_DISABLE_CRT_ASSERT()
57 #define UV_END_DISABLE_CRT_ASSERT()
58 #endif
59 
60 /*
61  * TCP
62  */
63 
64 typedef enum {
65   UV__IPC_SOCKET_XFER_NONE = 0,
66   UV__IPC_SOCKET_XFER_TCP_CONNECTION,
67   UV__IPC_SOCKET_XFER_TCP_SERVER
68 } uv__ipc_socket_xfer_type_t;
69 
70 typedef struct {
71   WSAPROTOCOL_INFOW socket_info;
72   uint32_t delayed_error;
73 } uv__ipc_socket_xfer_info_t;
74 
75 int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb);
76 int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client);
77 int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
78     uv_read_cb read_cb);
79 int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
80     const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb);
81 int uv__tcp_try_write(uv_tcp_t* handle, const uv_buf_t bufs[],
82     unsigned int nbufs);
83 
84 void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, uv_req_t* req);
85 void uv_process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle,
86     uv_write_t* req);
87 void uv_process_tcp_accept_req(uv_loop_t* loop, uv_tcp_t* handle,
88     uv_req_t* req);
89 void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,
90     uv_connect_t* req);
91 
92 void uv_tcp_close(uv_loop_t* loop, uv_tcp_t* tcp);
93 void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle);
94 
95 int uv__tcp_xfer_export(uv_tcp_t* handle,
96                         int pid,
97                         uv__ipc_socket_xfer_type_t* xfer_type,
98                         uv__ipc_socket_xfer_info_t* xfer_info);
99 int uv__tcp_xfer_import(uv_tcp_t* tcp,
100                         uv__ipc_socket_xfer_type_t xfer_type,
101                         uv__ipc_socket_xfer_info_t* xfer_info);
102 
103 
104 /*
105  * UDP
106  */
107 void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, uv_req_t* req);
108 void uv_process_udp_send_req(uv_loop_t* loop, uv_udp_t* handle,
109     uv_udp_send_t* req);
110 
111 void uv_udp_close(uv_loop_t* loop, uv_udp_t* handle);
112 void uv_udp_endgame(uv_loop_t* loop, uv_udp_t* handle);
113 
114 
115 /*
116  * Pipes
117  */
118 int uv_stdio_pipe_server(uv_loop_t* loop, uv_pipe_t* handle, DWORD access,
119     char* name, size_t nameSize);
120 
121 int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb);
122 int uv_pipe_accept(uv_pipe_t* server, uv_stream_t* client);
123 int uv_pipe_read_start(uv_pipe_t* handle, uv_alloc_cb alloc_cb,
124     uv_read_cb read_cb);
125 void uv__pipe_read_stop(uv_pipe_t* handle);
126 int uv__pipe_write(uv_loop_t* loop,
127                    uv_write_t* req,
128                    uv_pipe_t* handle,
129                    const uv_buf_t bufs[],
130                    size_t nbufs,
131                    uv_stream_t* send_handle,
132                    uv_write_cb cb);
133 
134 void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle,
135     uv_req_t* req);
136 void uv_process_pipe_write_req(uv_loop_t* loop, uv_pipe_t* handle,
137     uv_write_t* req);
138 void uv_process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle,
139     uv_req_t* raw_req);
140 void uv_process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle,
141     uv_connect_t* req);
142 void uv_process_pipe_shutdown_req(uv_loop_t* loop, uv_pipe_t* handle,
143     uv_shutdown_t* req);
144 
145 void uv_pipe_close(uv_loop_t* loop, uv_pipe_t* handle);
146 void uv_pipe_cleanup(uv_loop_t* loop, uv_pipe_t* handle);
147 void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle);
148 
149 
150 /*
151  * TTY
152  */
153 void uv_console_init(void);
154 
155 int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
156     uv_read_cb read_cb);
157 int uv_tty_read_stop(uv_tty_t* handle);
158 int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle,
159     const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb);
160 int uv__tty_try_write(uv_tty_t* handle, const uv_buf_t bufs[],
161     unsigned int nbufs);
162 void uv_tty_close(uv_tty_t* handle);
163 
164 void uv_process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle,
165     uv_req_t* req);
166 void uv_process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle,
167     uv_write_t* req);
168 /*
169  * uv_process_tty_accept_req() is a stub to keep DELEGATE_STREAM_REQ working
170  * TODO: find a way to remove it
171  */
172 void uv_process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle,
173     uv_req_t* raw_req);
174 /*
175  * uv_process_tty_connect_req() is a stub to keep DELEGATE_STREAM_REQ working
176  * TODO: find a way to remove it
177  */
178 void uv_process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle,
179     uv_connect_t* req);
180 
181 void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle);
182 
183 
184 /*
185  * Poll watchers
186  */
187 void uv_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
188     uv_req_t* req);
189 
190 int uv_poll_close(uv_loop_t* loop, uv_poll_t* handle);
191 void uv_poll_endgame(uv_loop_t* loop, uv_poll_t* handle);
192 
193 
194 /*
195  * Loop watchers
196  */
197 void uv_loop_watcher_endgame(uv_loop_t* loop, uv_handle_t* handle);
198 
199 void uv_prepare_invoke(uv_loop_t* loop);
200 void uv_check_invoke(uv_loop_t* loop);
201 void uv_idle_invoke(uv_loop_t* loop);
202 
203 void uv__once_init(void);
204 
205 
206 /*
207  * Async watcher
208  */
209 void uv_async_close(uv_loop_t* loop, uv_async_t* handle);
210 void uv_async_endgame(uv_loop_t* loop, uv_async_t* handle);
211 
212 void uv_process_async_wakeup_req(uv_loop_t* loop, uv_async_t* handle,
213     uv_req_t* req);
214 
215 
216 /*
217  * Signal watcher
218  */
219 void uv_signals_init(void);
220 int uv__signal_dispatch(int signum);
221 
222 void uv_signal_close(uv_loop_t* loop, uv_signal_t* handle);
223 void uv_signal_endgame(uv_loop_t* loop, uv_signal_t* handle);
224 
225 void uv_process_signal_req(uv_loop_t* loop, uv_signal_t* handle,
226     uv_req_t* req);
227 
228 
229 /*
230  * Spawn
231  */
232 void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle);
233 void uv_process_close(uv_loop_t* loop, uv_process_t* handle);
234 void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle);
235 
236 
237 /*
238  * Error
239  */
240 int uv_translate_sys_error(int sys_errno);
241 
242 
243 /*
244  * FS
245  */
246 void uv_fs_init(void);
247 
248 
249 /*
250  * FS Event
251  */
252 void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
253     uv_fs_event_t* handle);
254 void uv_fs_event_close(uv_loop_t* loop, uv_fs_event_t* handle);
255 void uv_fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle);
256 
257 
258 /*
259  * Stat poller.
260  */
261 void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle);
262 
263 
264 /*
265  * Utilities.
266  */
267 void uv__util_init(void);
268 
269 uint64_t uv__hrtime(double scale);
270 __declspec(noreturn) void uv_fatal_error(const int errorno, const char* syscall);
271 int uv__getpwuid_r(uv_passwd_t* pwd);
272 int uv__convert_utf16_to_utf8(const WCHAR* utf16, int utf16len, char** utf8);
273 int uv__convert_utf8_to_utf16(const char* utf8, int utf8len, WCHAR** utf16);
274 
275 typedef int (WINAPI *uv__peersockfunc)(SOCKET, struct sockaddr*, int*);
276 
277 int uv__getsockpeername(const uv_handle_t* handle,
278                         uv__peersockfunc func,
279                         struct sockaddr* name,
280                         int* namelen,
281                         int delayed_error);
282 
283 int uv__random_rtlgenrandom(void* buf, size_t buflen);
284 
285 
286 /*
287  * Process stdio handles.
288  */
289 int uv__stdio_create(uv_loop_t* loop,
290                      const uv_process_options_t* options,
291                      BYTE** buffer_ptr);
292 void uv__stdio_destroy(BYTE* buffer);
293 void uv__stdio_noinherit(BYTE* buffer);
294 int uv__stdio_verify(BYTE* buffer, WORD size);
295 WORD uv__stdio_size(BYTE* buffer);
296 HANDLE uv__stdio_handle(BYTE* buffer, int fd);
297 
298 
299 /*
300  * Winapi and ntapi utility functions
301  */
302 void uv_winapi_init(void);
303 
304 
305 /*
306  * Winsock utility functions
307  */
308 void uv_winsock_init(void);
309 
310 int uv_ntstatus_to_winsock_error(NTSTATUS status);
311 
312 BOOL uv_get_acceptex_function(SOCKET socket, LPFN_ACCEPTEX* target);
313 BOOL uv_get_connectex_function(SOCKET socket, LPFN_CONNECTEX* target);
314 
315 int WSAAPI uv_wsarecv_workaround(SOCKET socket, WSABUF* buffers,
316     DWORD buffer_count, DWORD* bytes, DWORD* flags, WSAOVERLAPPED *overlapped,
317     LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
318 int WSAAPI uv_wsarecvfrom_workaround(SOCKET socket, WSABUF* buffers,
319     DWORD buffer_count, DWORD* bytes, DWORD* flags, struct sockaddr* addr,
320     int* addr_len, WSAOVERLAPPED *overlapped,
321     LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
322 
323 int WSAAPI uv_msafd_poll(SOCKET socket, AFD_POLL_INFO* info_in,
324     AFD_POLL_INFO* info_out, OVERLAPPED* overlapped);
325 
326 /* Whether there are any non-IFS LSPs stacked on TCP */
327 extern int uv_tcp_non_ifs_lsp_ipv4;
328 extern int uv_tcp_non_ifs_lsp_ipv6;
329 
330 /* Ip address used to bind to any port at any interface */
331 extern struct sockaddr_in uv_addr_ip4_any_;
332 extern struct sockaddr_in6 uv_addr_ip6_any_;
333 
334 /*
335  * Wake all loops with fake message
336  */
337 void uv__wake_all_loops(void);
338 
339 /*
340  * Init system wake-up detection
341  */
342 void uv__init_detect_system_wakeup(void);
343 
344 #endif /* UV_WIN_INTERNAL_H_ */
345