|
160
|
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 #include <assert.h>
|
|
|
23 #include <stdlib.h>
|
|
|
24
|
|
|
25 #include "uv.h"
|
|
|
26 #include "internal.h"
|
|
|
27
|
|
|
28
|
|
|
29 /* Whether there are any non-IFS LSPs stacked on TCP */
|
|
|
30 int uv_tcp_non_ifs_lsp_ipv4;
|
|
|
31 int uv_tcp_non_ifs_lsp_ipv6;
|
|
|
32
|
|
|
33 /* Ip address used to bind to any port at any interface */
|
|
|
34 struct sockaddr_in uv_addr_ip4_any_;
|
|
|
35 struct sockaddr_in6 uv_addr_ip6_any_;
|
|
|
36
|
|
|
37
|
|
|
38 /*
|
|
|
39 * Retrieves the pointer to a winsock extension function.
|
|
|
40 */
|
|
|
41 static BOOL uv__get_extension_function(SOCKET socket, GUID guid,
|
|
|
42 void **target) {
|
|
|
43 int result;
|
|
|
44 DWORD bytes;
|
|
|
45
|
|
|
46 result = WSAIoctl(socket,
|
|
|
47 SIO_GET_EXTENSION_FUNCTION_POINTER,
|
|
|
48 &guid,
|
|
|
49 sizeof(guid),
|
|
|
50 (void*)target,
|
|
|
51 sizeof(*target),
|
|
|
52 &bytes,
|
|
|
53 NULL,
|
|
|
54 NULL);
|
|
|
55
|
|
|
56 if (result == SOCKET_ERROR) {
|
|
|
57 *target = NULL;
|
|
|
58 return FALSE;
|
|
|
59 } else {
|
|
|
60 return TRUE;
|
|
|
61 }
|
|
|
62 }
|
|
|
63
|
|
|
64
|
|
|
65 BOOL uv__get_acceptex_function(SOCKET socket, LPFN_ACCEPTEX* target) {
|
|
|
66 const GUID wsaid_acceptex = WSAID_ACCEPTEX;
|
|
|
67 return uv__get_extension_function(socket, wsaid_acceptex, (void**)target);
|
|
|
68 }
|
|
|
69
|
|
|
70
|
|
|
71 BOOL uv__get_connectex_function(SOCKET socket, LPFN_CONNECTEX* target) {
|
|
|
72 const GUID wsaid_connectex = WSAID_CONNECTEX;
|
|
|
73 return uv__get_extension_function(socket, wsaid_connectex, (void**)target);
|
|
|
74 }
|
|
|
75
|
|
|
76
|
|
|
77
|
|
|
78 void uv__winsock_init(void) {
|
|
|
79 WSADATA wsa_data;
|
|
|
80 int errorno;
|
|
|
81 SOCKET dummy;
|
|
|
82 WSAPROTOCOL_INFOW protocol_info;
|
|
|
83 int opt_len;
|
|
|
84
|
|
|
85 /* Set implicit binding address used by connectEx */
|
|
|
86 if (uv_ip4_addr("0.0.0.0", 0, &uv_addr_ip4_any_)) {
|
|
|
87 abort();
|
|
|
88 }
|
|
|
89
|
|
|
90 if (uv_ip6_addr("::", 0, &uv_addr_ip6_any_)) {
|
|
|
91 abort();
|
|
|
92 }
|
|
|
93
|
|
|
94 /* Skip initialization in safe mode without network support */
|
|
|
95 if (1 == GetSystemMetrics(SM_CLEANBOOT)) return;
|
|
|
96
|
|
|
97 /* Initialize winsock */
|
|
|
98 errorno = WSAStartup(MAKEWORD(2, 2), &wsa_data);
|
|
|
99 if (errorno != 0) {
|
|
|
100 uv_fatal_error(errorno, "WSAStartup");
|
|
|
101 }
|
|
|
102
|
|
|
103 /* Try to detect non-IFS LSPs */
|
|
|
104 uv_tcp_non_ifs_lsp_ipv4 = 1;
|
|
|
105 dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
|
|
|
106 if (dummy != INVALID_SOCKET) {
|
|
|
107 opt_len = (int) sizeof protocol_info;
|
|
|
108 if (getsockopt(dummy,
|
|
|
109 SOL_SOCKET,
|
|
|
110 SO_PROTOCOL_INFOW,
|
|
|
111 (char*) &protocol_info,
|
|
|
112 &opt_len) == 0) {
|
|
|
113 if (protocol_info.dwServiceFlags1 & XP1_IFS_HANDLES)
|
|
|
114 uv_tcp_non_ifs_lsp_ipv4 = 0;
|
|
|
115 }
|
|
|
116 closesocket(dummy);
|
|
|
117 }
|
|
|
118
|
|
|
119 /* Try to detect IPV6 support and non-IFS LSPs */
|
|
|
120 uv_tcp_non_ifs_lsp_ipv6 = 1;
|
|
|
121 dummy = socket(AF_INET6, SOCK_STREAM, IPPROTO_IP);
|
|
|
122 if (dummy != INVALID_SOCKET) {
|
|
|
123 opt_len = (int) sizeof protocol_info;
|
|
|
124 if (getsockopt(dummy,
|
|
|
125 SOL_SOCKET,
|
|
|
126 SO_PROTOCOL_INFOW,
|
|
|
127 (char*) &protocol_info,
|
|
|
128 &opt_len) == 0) {
|
|
|
129 if (protocol_info.dwServiceFlags1 & XP1_IFS_HANDLES)
|
|
|
130 uv_tcp_non_ifs_lsp_ipv6 = 0;
|
|
|
131 }
|
|
|
132 closesocket(dummy);
|
|
|
133 }
|
|
|
134 }
|
|
|
135
|
|
|
136
|
|
|
137 int uv__ntstatus_to_winsock_error(NTSTATUS status) {
|
|
|
138 switch (status) {
|
|
|
139 case STATUS_SUCCESS:
|
|
|
140 return ERROR_SUCCESS;
|
|
|
141
|
|
|
142 case STATUS_PENDING:
|
|
|
143 return ERROR_IO_PENDING;
|
|
|
144
|
|
|
145 case STATUS_INVALID_HANDLE:
|
|
|
146 case STATUS_OBJECT_TYPE_MISMATCH:
|
|
|
147 return WSAENOTSOCK;
|
|
|
148
|
|
|
149 case STATUS_INSUFFICIENT_RESOURCES:
|
|
|
150 case STATUS_PAGEFILE_QUOTA:
|
|
|
151 case STATUS_COMMITMENT_LIMIT:
|
|
|
152 case STATUS_WORKING_SET_QUOTA:
|
|
|
153 case STATUS_NO_MEMORY:
|
|
|
154 case STATUS_QUOTA_EXCEEDED:
|
|
|
155 case STATUS_TOO_MANY_PAGING_FILES:
|
|
|
156 case STATUS_REMOTE_RESOURCES:
|
|
|
157 return WSAENOBUFS;
|
|
|
158
|
|
|
159 case STATUS_TOO_MANY_ADDRESSES:
|
|
|
160 case STATUS_SHARING_VIOLATION:
|
|
|
161 case STATUS_ADDRESS_ALREADY_EXISTS:
|
|
|
162 return WSAEADDRINUSE;
|
|
|
163
|
|
|
164 case STATUS_LINK_TIMEOUT:
|
|
|
165 case STATUS_IO_TIMEOUT:
|
|
|
166 case STATUS_TIMEOUT:
|
|
|
167 return WSAETIMEDOUT;
|
|
|
168
|
|
|
169 case STATUS_GRACEFUL_DISCONNECT:
|
|
|
170 return WSAEDISCON;
|
|
|
171
|
|
|
172 case STATUS_REMOTE_DISCONNECT:
|
|
|
173 case STATUS_CONNECTION_RESET:
|
|
|
174 case STATUS_LINK_FAILED:
|
|
|
175 case STATUS_CONNECTION_DISCONNECTED:
|
|
|
176 case STATUS_PORT_UNREACHABLE:
|
|
|
177 case STATUS_HOPLIMIT_EXCEEDED:
|
|
|
178 return WSAECONNRESET;
|
|
|
179
|
|
|
180 case STATUS_LOCAL_DISCONNECT:
|
|
|
181 case STATUS_TRANSACTION_ABORTED:
|
|
|
182 case STATUS_CONNECTION_ABORTED:
|
|
|
183 return WSAECONNABORTED;
|
|
|
184
|
|
|
185 case STATUS_BAD_NETWORK_PATH:
|
|
|
186 case STATUS_NETWORK_UNREACHABLE:
|
|
|
187 case STATUS_PROTOCOL_UNREACHABLE:
|
|
|
188 return WSAENETUNREACH;
|
|
|
189
|
|
|
190 case STATUS_HOST_UNREACHABLE:
|
|
|
191 return WSAEHOSTUNREACH;
|
|
|
192
|
|
|
193 case STATUS_CANCELLED:
|
|
|
194 case STATUS_REQUEST_ABORTED:
|
|
|
195 return WSAEINTR;
|
|
|
196
|
|
|
197 case STATUS_BUFFER_OVERFLOW:
|
|
|
198 case STATUS_INVALID_BUFFER_SIZE:
|
|
|
199 return WSAEMSGSIZE;
|
|
|
200
|
|
|
201 case STATUS_BUFFER_TOO_SMALL:
|
|
|
202 case STATUS_ACCESS_VIOLATION:
|
|
|
203 return WSAEFAULT;
|
|
|
204
|
|
|
205 case STATUS_DEVICE_NOT_READY:
|
|
|
206 case STATUS_REQUEST_NOT_ACCEPTED:
|
|
|
207 return WSAEWOULDBLOCK;
|
|
|
208
|
|
|
209 case STATUS_INVALID_NETWORK_RESPONSE:
|
|
|
210 case STATUS_NETWORK_BUSY:
|
|
|
211 case STATUS_NO_SUCH_DEVICE:
|
|
|
212 case STATUS_NO_SUCH_FILE:
|
|
|
213 case STATUS_OBJECT_PATH_NOT_FOUND:
|
|
|
214 case STATUS_OBJECT_NAME_NOT_FOUND:
|
|
|
215 case STATUS_UNEXPECTED_NETWORK_ERROR:
|
|
|
216 return WSAENETDOWN;
|
|
|
217
|
|
|
218 case STATUS_INVALID_CONNECTION:
|
|
|
219 return WSAENOTCONN;
|
|
|
220
|
|
|
221 case STATUS_REMOTE_NOT_LISTENING:
|
|
|
222 case STATUS_CONNECTION_REFUSED:
|
|
|
223 return WSAECONNREFUSED;
|
|
|
224
|
|
|
225 case STATUS_PIPE_DISCONNECTED:
|
|
|
226 return WSAESHUTDOWN;
|
|
|
227
|
|
|
228 case STATUS_CONFLICTING_ADDRESSES:
|
|
|
229 case STATUS_INVALID_ADDRESS:
|
|
|
230 case STATUS_INVALID_ADDRESS_COMPONENT:
|
|
|
231 return WSAEADDRNOTAVAIL;
|
|
|
232
|
|
|
233 case STATUS_NOT_SUPPORTED:
|
|
|
234 case STATUS_NOT_IMPLEMENTED:
|
|
|
235 return WSAEOPNOTSUPP;
|
|
|
236
|
|
|
237 case STATUS_ACCESS_DENIED:
|
|
|
238 return WSAEACCES;
|
|
|
239
|
|
|
240 default:
|
|
|
241 if ((status & (FACILITY_NTWIN32 << 16)) == (FACILITY_NTWIN32 << 16) &&
|
|
|
242 (status & (ERROR_SEVERITY_ERROR | ERROR_SEVERITY_WARNING))) {
|
|
|
243 /* It's a windows error that has been previously mapped to an ntstatus
|
|
|
244 * code. */
|
|
|
245 return (DWORD) (status & 0xffff);
|
|
|
246 } else {
|
|
|
247 /* The default fallback for unmappable ntstatus codes. */
|
|
|
248 return WSAEINVAL;
|
|
|
249 }
|
|
|
250 }
|
|
|
251 }
|
|
|
252
|
|
|
253
|
|
|
254 /*
|
|
|
255 * This function provides a workaround for a bug in the winsock implementation
|
|
|
256 * of WSARecv. The problem is that when SetFileCompletionNotificationModes is
|
|
|
257 * used to avoid IOCP notifications of completed reads, WSARecv does not
|
|
|
258 * reliably indicate whether we can expect a completion package to be posted
|
|
|
259 * when the receive buffer is smaller than the received datagram.
|
|
|
260 *
|
|
|
261 * However it is desirable to use SetFileCompletionNotificationModes because
|
|
|
262 * it yields a massive performance increase.
|
|
|
263 *
|
|
|
264 * This function provides a workaround for that bug, but it only works for the
|
|
|
265 * specific case that we need it for. E.g. it assumes that the "avoid iocp"
|
|
|
266 * bit has been set, and supports only overlapped operation. It also requires
|
|
|
267 * the user to use the default msafd driver, doesn't work when other LSPs are
|
|
|
268 * stacked on top of it.
|
|
|
269 */
|
|
|
270 int WSAAPI uv__wsarecv_workaround(SOCKET socket, WSABUF* buffers,
|
|
|
271 DWORD buffer_count, DWORD* bytes, DWORD* flags, WSAOVERLAPPED *overlapped,
|
|
|
272 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine) {
|
|
|
273 NTSTATUS status;
|
|
|
274 void* apc_context;
|
|
|
275 IO_STATUS_BLOCK* iosb = (IO_STATUS_BLOCK*) &overlapped->Internal;
|
|
|
276 AFD_RECV_INFO info;
|
|
|
277 DWORD error;
|
|
|
278
|
|
|
279 if (overlapped == NULL || completion_routine != NULL) {
|
|
|
280 WSASetLastError(WSAEINVAL);
|
|
|
281 return SOCKET_ERROR;
|
|
|
282 }
|
|
|
283
|
|
|
284 info.BufferArray = buffers;
|
|
|
285 info.BufferCount = buffer_count;
|
|
|
286 info.AfdFlags = AFD_OVERLAPPED;
|
|
|
287 info.TdiFlags = TDI_RECEIVE_NORMAL;
|
|
|
288
|
|
|
289 if (*flags & MSG_PEEK) {
|
|
|
290 info.TdiFlags |= TDI_RECEIVE_PEEK;
|
|
|
291 }
|
|
|
292
|
|
|
293 if (*flags & MSG_PARTIAL) {
|
|
|
294 info.TdiFlags |= TDI_RECEIVE_PARTIAL;
|
|
|
295 }
|
|
|
296
|
|
|
297 if (!((intptr_t) overlapped->hEvent & 1)) {
|
|
|
298 apc_context = (void*) overlapped;
|
|
|
299 } else {
|
|
|
300 apc_context = NULL;
|
|
|
301 }
|
|
|
302
|
|
|
303 iosb->Status = STATUS_PENDING;
|
|
|
304 iosb->Pointer = 0;
|
|
|
305
|
|
|
306 status = pNtDeviceIoControlFile((HANDLE) socket,
|
|
|
307 overlapped->hEvent,
|
|
|
308 NULL,
|
|
|
309 apc_context,
|
|
|
310 iosb,
|
|
|
311 IOCTL_AFD_RECEIVE,
|
|
|
312 &info,
|
|
|
313 sizeof(info),
|
|
|
314 NULL,
|
|
|
315 0);
|
|
|
316
|
|
|
317 *flags = 0;
|
|
|
318 *bytes = (DWORD) iosb->Information;
|
|
|
319
|
|
|
320 switch (status) {
|
|
|
321 case STATUS_SUCCESS:
|
|
|
322 error = ERROR_SUCCESS;
|
|
|
323 break;
|
|
|
324
|
|
|
325 case STATUS_PENDING:
|
|
|
326 error = WSA_IO_PENDING;
|
|
|
327 break;
|
|
|
328
|
|
|
329 case STATUS_BUFFER_OVERFLOW:
|
|
|
330 error = WSAEMSGSIZE;
|
|
|
331 break;
|
|
|
332
|
|
|
333 case STATUS_RECEIVE_EXPEDITED:
|
|
|
334 error = ERROR_SUCCESS;
|
|
|
335 *flags = MSG_OOB;
|
|
|
336 break;
|
|
|
337
|
|
|
338 case STATUS_RECEIVE_PARTIAL_EXPEDITED:
|
|
|
339 error = ERROR_SUCCESS;
|
|
|
340 *flags = MSG_PARTIAL | MSG_OOB;
|
|
|
341 break;
|
|
|
342
|
|
|
343 case STATUS_RECEIVE_PARTIAL:
|
|
|
344 error = ERROR_SUCCESS;
|
|
|
345 *flags = MSG_PARTIAL;
|
|
|
346 break;
|
|
|
347
|
|
|
348 default:
|
|
|
349 error = uv__ntstatus_to_winsock_error(status);
|
|
|
350 break;
|
|
|
351 }
|
|
|
352
|
|
|
353 WSASetLastError(error);
|
|
|
354
|
|
|
355 if (error == ERROR_SUCCESS) {
|
|
|
356 return 0;
|
|
|
357 } else {
|
|
|
358 return SOCKET_ERROR;
|
|
|
359 }
|
|
|
360 }
|
|
|
361
|
|
|
362
|
|
|
363 /* See description of uv__wsarecv_workaround. */
|
|
|
364 int WSAAPI uv__wsarecvfrom_workaround(SOCKET socket, WSABUF* buffers,
|
|
|
365 DWORD buffer_count, DWORD* bytes, DWORD* flags, struct sockaddr* addr,
|
|
|
366 int* addr_len, WSAOVERLAPPED *overlapped,
|
|
|
367 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine) {
|
|
|
368 NTSTATUS status;
|
|
|
369 void* apc_context;
|
|
|
370 IO_STATUS_BLOCK* iosb = (IO_STATUS_BLOCK*) &overlapped->Internal;
|
|
|
371 AFD_RECV_DATAGRAM_INFO info;
|
|
|
372 DWORD error;
|
|
|
373
|
|
|
374 if (overlapped == NULL || addr == NULL || addr_len == NULL ||
|
|
|
375 completion_routine != NULL) {
|
|
|
376 WSASetLastError(WSAEINVAL);
|
|
|
377 return SOCKET_ERROR;
|
|
|
378 }
|
|
|
379
|
|
|
380 info.BufferArray = buffers;
|
|
|
381 info.BufferCount = buffer_count;
|
|
|
382 info.AfdFlags = AFD_OVERLAPPED;
|
|
|
383 info.TdiFlags = TDI_RECEIVE_NORMAL;
|
|
|
384 info.Address = addr;
|
|
|
385 info.AddressLength = addr_len;
|
|
|
386
|
|
|
387 if (*flags & MSG_PEEK) {
|
|
|
388 info.TdiFlags |= TDI_RECEIVE_PEEK;
|
|
|
389 }
|
|
|
390
|
|
|
391 if (*flags & MSG_PARTIAL) {
|
|
|
392 info.TdiFlags |= TDI_RECEIVE_PARTIAL;
|
|
|
393 }
|
|
|
394
|
|
|
395 if (!((intptr_t) overlapped->hEvent & 1)) {
|
|
|
396 apc_context = (void*) overlapped;
|
|
|
397 } else {
|
|
|
398 apc_context = NULL;
|
|
|
399 }
|
|
|
400
|
|
|
401 iosb->Status = STATUS_PENDING;
|
|
|
402 iosb->Pointer = 0;
|
|
|
403
|
|
|
404 status = pNtDeviceIoControlFile((HANDLE) socket,
|
|
|
405 overlapped->hEvent,
|
|
|
406 NULL,
|
|
|
407 apc_context,
|
|
|
408 iosb,
|
|
|
409 IOCTL_AFD_RECEIVE_DATAGRAM,
|
|
|
410 &info,
|
|
|
411 sizeof(info),
|
|
|
412 NULL,
|
|
|
413 0);
|
|
|
414
|
|
|
415 *flags = 0;
|
|
|
416 *bytes = (DWORD) iosb->Information;
|
|
|
417
|
|
|
418 switch (status) {
|
|
|
419 case STATUS_SUCCESS:
|
|
|
420 error = ERROR_SUCCESS;
|
|
|
421 break;
|
|
|
422
|
|
|
423 case STATUS_PENDING:
|
|
|
424 error = WSA_IO_PENDING;
|
|
|
425 break;
|
|
|
426
|
|
|
427 case STATUS_BUFFER_OVERFLOW:
|
|
|
428 error = WSAEMSGSIZE;
|
|
|
429 break;
|
|
|
430
|
|
|
431 case STATUS_RECEIVE_EXPEDITED:
|
|
|
432 error = ERROR_SUCCESS;
|
|
|
433 *flags = MSG_OOB;
|
|
|
434 break;
|
|
|
435
|
|
|
436 case STATUS_RECEIVE_PARTIAL_EXPEDITED:
|
|
|
437 error = ERROR_SUCCESS;
|
|
|
438 *flags = MSG_PARTIAL | MSG_OOB;
|
|
|
439 break;
|
|
|
440
|
|
|
441 case STATUS_RECEIVE_PARTIAL:
|
|
|
442 error = ERROR_SUCCESS;
|
|
|
443 *flags = MSG_PARTIAL;
|
|
|
444 break;
|
|
|
445
|
|
|
446 default:
|
|
|
447 error = uv__ntstatus_to_winsock_error(status);
|
|
|
448 break;
|
|
|
449 }
|
|
|
450
|
|
|
451 WSASetLastError(error);
|
|
|
452
|
|
|
453 if (error == ERROR_SUCCESS) {
|
|
|
454 return 0;
|
|
|
455 } else {
|
|
|
456 return SOCKET_ERROR;
|
|
|
457 }
|
|
|
458 }
|
|
|
459
|
|
|
460
|
|
|
461 int WSAAPI uv__msafd_poll(SOCKET socket, AFD_POLL_INFO* info_in,
|
|
|
462 AFD_POLL_INFO* info_out, OVERLAPPED* overlapped) {
|
|
|
463 IO_STATUS_BLOCK iosb;
|
|
|
464 IO_STATUS_BLOCK* iosb_ptr;
|
|
|
465 HANDLE event = NULL;
|
|
|
466 void* apc_context;
|
|
|
467 NTSTATUS status;
|
|
|
468 DWORD error;
|
|
|
469
|
|
|
470 if (overlapped != NULL) {
|
|
|
471 /* Overlapped operation. */
|
|
|
472 iosb_ptr = (IO_STATUS_BLOCK*) &overlapped->Internal;
|
|
|
473 event = overlapped->hEvent;
|
|
|
474
|
|
|
475 /* Do not report iocp completion if hEvent is tagged. */
|
|
|
476 if ((uintptr_t) event & 1) {
|
|
|
477 event = (HANDLE)((uintptr_t) event & ~(uintptr_t) 1);
|
|
|
478 apc_context = NULL;
|
|
|
479 } else {
|
|
|
480 apc_context = overlapped;
|
|
|
481 }
|
|
|
482
|
|
|
483 } else {
|
|
|
484 /* Blocking operation. */
|
|
|
485 iosb_ptr = &iosb;
|
|
|
486 event = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
|
487 if (event == NULL) {
|
|
|
488 return SOCKET_ERROR;
|
|
|
489 }
|
|
|
490 apc_context = NULL;
|
|
|
491 }
|
|
|
492
|
|
|
493 iosb_ptr->Status = STATUS_PENDING;
|
|
|
494 status = pNtDeviceIoControlFile((HANDLE) socket,
|
|
|
495 event,
|
|
|
496 NULL,
|
|
|
497 apc_context,
|
|
|
498 iosb_ptr,
|
|
|
499 IOCTL_AFD_POLL,
|
|
|
500 info_in,
|
|
|
501 sizeof *info_in,
|
|
|
502 info_out,
|
|
|
503 sizeof *info_out);
|
|
|
504
|
|
|
505 if (overlapped == NULL) {
|
|
|
506 /* If this is a blocking operation, wait for the event to become signaled,
|
|
|
507 * and then grab the real status from the io status block. */
|
|
|
508 if (status == STATUS_PENDING) {
|
|
|
509 DWORD r = WaitForSingleObject(event, INFINITE);
|
|
|
510
|
|
|
511 if (r == WAIT_FAILED) {
|
|
|
512 DWORD saved_error = GetLastError();
|
|
|
513 CloseHandle(event);
|
|
|
514 WSASetLastError(saved_error);
|
|
|
515 return SOCKET_ERROR;
|
|
|
516 }
|
|
|
517
|
|
|
518 status = iosb.Status;
|
|
|
519 }
|
|
|
520
|
|
|
521 CloseHandle(event);
|
|
|
522 }
|
|
|
523
|
|
|
524 switch (status) {
|
|
|
525 case STATUS_SUCCESS:
|
|
|
526 error = ERROR_SUCCESS;
|
|
|
527 break;
|
|
|
528
|
|
|
529 case STATUS_PENDING:
|
|
|
530 error = WSA_IO_PENDING;
|
|
|
531 break;
|
|
|
532
|
|
|
533 default:
|
|
|
534 error = uv__ntstatus_to_winsock_error(status);
|
|
|
535 break;
|
|
|
536 }
|
|
|
537
|
|
|
538 WSASetLastError(error);
|
|
|
539
|
|
|
540 if (error == ERROR_SUCCESS) {
|
|
|
541 return 0;
|
|
|
542 } else {
|
|
|
543 return SOCKET_ERROR;
|
|
|
544 }
|
|
|
545 }
|
|
|
546
|
|
|
547 int uv__convert_to_localhost_if_unspecified(const struct sockaddr* addr,
|
|
|
548 struct sockaddr_storage* storage) {
|
|
|
549 struct sockaddr_in* dest4;
|
|
|
550 struct sockaddr_in6* dest6;
|
|
|
551
|
|
|
552 if (addr == NULL)
|
|
|
553 return UV_EINVAL;
|
|
|
554
|
|
|
555 switch (addr->sa_family) {
|
|
|
556 case AF_INET:
|
|
|
557 dest4 = (struct sockaddr_in*) storage;
|
|
|
558 memcpy(dest4, addr, sizeof(*dest4));
|
|
|
559 if (dest4->sin_addr.s_addr == 0)
|
|
|
560 dest4->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
|
|
|
561 return 0;
|
|
|
562 case AF_INET6:
|
|
|
563 dest6 = (struct sockaddr_in6*) storage;
|
|
|
564 memcpy(dest6, addr, sizeof(*dest6));
|
|
|
565 if (memcmp(&dest6->sin6_addr,
|
|
|
566 &uv_addr_ip6_any_.sin6_addr,
|
|
|
567 sizeof(uv_addr_ip6_any_.sin6_addr)) == 0) {
|
|
|
568 struct in6_addr init_sin6_addr = IN6ADDR_LOOPBACK_INIT;
|
|
|
569 dest6->sin6_addr = init_sin6_addr;
|
|
|
570 }
|
|
|
571 return 0;
|
|
|
572 default:
|
|
|
573 return UV_EINVAL;
|
|
|
574 }
|
|
|
575 }
|
