?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32: Make wait in WS2_recv_base() alertable.
[wine.git] / dlls / ws2_32 / socket.c
blob9cc75aacf2016407d908d609edf01b5fd2badf7f
1 /*
2 * based on Windows Sockets 1.1 specs
3 *
4 * Copyright (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
5 * Copyright (C) 2001 Stefan Leichter
6 * Copyright (C) 2004 Hans Leidekker
7 * Copyright (C) 2005 Marcus Meissner
8 * Copyright (C) 2006-2008 Kai Blin
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 *
24 * NOTE: If you make any changes to fix a particular app, make sure
25 * they don't break something else like Netscape or telnet and ftp
26 * clients and servers (www.winsite.com got a lot of those).
27 */
28
29 #include "ws2_32_private.h"
30
31 #define FILE_USE_FILE_POINTER_POSITION ((LONGLONG)-2)
32
33 WINE_DEFAULT_DEBUG_CHANNEL(winsock);
34 WINE_DECLARE_DEBUG_CHANNEL(winediag);
35
36 #define TIMEOUT_INFINITE _I64_MAX
37
38 #define u64_from_user_ptr(ptr) ((ULONGLONG)(uintptr_t)(ptr))
39
40 static const WSAPROTOCOL_INFOW supported_protocols[] =
41 {
42 {
43 .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_EXPEDITED_DATA | XP1_GRACEFUL_CLOSE
44 | XP1_GUARANTEED_ORDER | XP1_GUARANTEED_DELIVERY,
45 .dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO,
46 .ProviderId = {0xe70f1aa0, 0xab8b, 0x11cf, {0x8c, 0xa3, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}},
47 .dwCatalogEntryId = 1001,
48 .ProtocolChain.ChainLen = 1,
49 .iVersion = 2,
50 .iAddressFamily = AF_INET,
51 .iMaxSockAddr = sizeof(struct sockaddr_in),
52 .iMinSockAddr = sizeof(struct sockaddr_in),
53 .iSocketType = SOCK_STREAM,
54 .iProtocol = IPPROTO_TCP,
55 .szProtocol = L"TCP/IP",
56 },
57 {
58 .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST
59 | XP1_SUPPORT_MULTIPOINT | XP1_MESSAGE_ORIENTED | XP1_CONNECTIONLESS,
60 .dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO,
61 .ProviderId = {0xe70f1aa0, 0xab8b, 0x11cf, {0x8c, 0xa3, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}},
62 .dwCatalogEntryId = 1002,
63 .ProtocolChain.ChainLen = 1,
64 .iVersion = 2,
65 .iAddressFamily = AF_INET,
66 .iMaxSockAddr = sizeof(struct sockaddr_in),
67 .iMinSockAddr = sizeof(struct sockaddr_in),
68 .iSocketType = SOCK_DGRAM,
69 .iProtocol = IPPROTO_UDP,
70 .dwMessageSize = 0xffbb,
71 .szProtocol = L"UDP/IP",
72 },
73 {
74 .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_EXPEDITED_DATA | XP1_GRACEFUL_CLOSE
75 | XP1_GUARANTEED_ORDER | XP1_GUARANTEED_DELIVERY,
76 .dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO,
77 .ProviderId = {0xf9eab0c0, 0x26d4, 0x11d0, {0xbb, 0xbf, 0x00, 0xaa, 0x00, 0x6c, 0x34, 0xe4}},
78 .dwCatalogEntryId = 1004,
79 .ProtocolChain.ChainLen = 1,
80 .iVersion = 2,
81 .iAddressFamily = AF_INET6,
82 .iMaxSockAddr = sizeof(struct sockaddr_in6),
83 .iMinSockAddr = sizeof(struct sockaddr_in6),
84 .iSocketType = SOCK_STREAM,
85 .iProtocol = IPPROTO_TCP,
86 .szProtocol = L"TCP/IPv6",
87 },
88 {
89 .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST
90 | XP1_SUPPORT_MULTIPOINT | XP1_MESSAGE_ORIENTED | XP1_CONNECTIONLESS,
91 .dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO,
92 .ProviderId = {0xf9eab0c0, 0x26d4, 0x11d0, {0xbb, 0xbf, 0x00, 0xaa, 0x00, 0x6c, 0x34, 0xe4}},
93 .dwCatalogEntryId = 1005,
94 .ProtocolChain.ChainLen = 1,
95 .iVersion = 2,
96 .iAddressFamily = AF_INET6,
97 .iMaxSockAddr = sizeof(struct sockaddr_in6),
98 .iMinSockAddr = sizeof(struct sockaddr_in6),
99 .iSocketType = SOCK_DGRAM,
100 .iProtocol = IPPROTO_UDP,
101 .dwMessageSize = 0xffbb,
102 .szProtocol = L"UDP/IPv6",
103 },
104 {
105 .dwServiceFlags1 = XP1_PARTIAL_MESSAGE | XP1_SUPPORT_BROADCAST
106 | XP1_SUPPORT_MULTIPOINT | XP1_MESSAGE_ORIENTED | XP1_CONNECTIONLESS,
107 .dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO,
108 .ProviderId = {0x11058240, 0xbe47, 0x11cf, {0x95, 0xc8, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}},
109 .dwCatalogEntryId = 1030,
110 .ProtocolChain.ChainLen = 1,
111 .iVersion = 2,
112 .iAddressFamily = AF_IPX,
113 .iMaxSockAddr = sizeof(struct sockaddr),
114 .iMinSockAddr = sizeof(struct sockaddr_ipx),
115 .iSocketType = SOCK_DGRAM,
116 .iProtocol = NSPROTO_IPX,
117 .iProtocolMaxOffset = 255,
118 .dwMessageSize = 0x240,
119 .szProtocol = L"IPX",
120 },
121 {
122 .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_PSEUDO_STREAM | XP1_MESSAGE_ORIENTED
123 | XP1_GUARANTEED_ORDER | XP1_GUARANTEED_DELIVERY,
124 .dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO,
125 .ProviderId = {0x11058241, 0xbe47, 0x11cf, {0x95, 0xc8, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}},
126 .dwCatalogEntryId = 1031,
127 .ProtocolChain.ChainLen = 1,
128 .iVersion = 2,
129 .iAddressFamily = AF_IPX,
130 .iMaxSockAddr = sizeof(struct sockaddr),
131 .iMinSockAddr = sizeof(struct sockaddr_ipx),
132 .iSocketType = SOCK_SEQPACKET,
133 .iProtocol = NSPROTO_SPX,
134 .dwMessageSize = UINT_MAX,
135 .szProtocol = L"SPX",
136 },
137 {
138 .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_GRACEFUL_CLOSE | XP1_PSEUDO_STREAM
139 | XP1_MESSAGE_ORIENTED | XP1_GUARANTEED_ORDER | XP1_GUARANTEED_DELIVERY,
140 .dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO,
141 .ProviderId = {0x11058241, 0xbe47, 0x11cf, {0x95, 0xc8, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}},
142 .dwCatalogEntryId = 1033,
143 .ProtocolChain.ChainLen = 1,
144 .iVersion = 2,
145 .iAddressFamily = AF_IPX,
146 .iMaxSockAddr = sizeof(struct sockaddr),
147 .iMinSockAddr = sizeof(struct sockaddr_ipx),
148 .iSocketType = SOCK_SEQPACKET,
149 .iProtocol = NSPROTO_SPXII,
150 .dwMessageSize = UINT_MAX,
151 .szProtocol = L"SPX II",
152 },
153 };
154
155 DECLARE_CRITICAL_SECTION(cs_socket_list);
156
157 static SOCKET *socket_list;
158 static unsigned int socket_list_size;
159
160 const char *debugstr_sockaddr( const struct sockaddr *a )
161 {
162 if (!a) return "(nil)";
163 switch (a->sa_family)
164 {
165 case AF_INET:
166 {
167 char buf[16];
168 const char *p;
169 struct sockaddr_in *sin = (struct sockaddr_in *)a;
170
171 p = inet_ntop( AF_INET, &sin->sin_addr, buf, sizeof(buf) );
172 if (!p)
173 p = "(unknown IPv4 address)";
174
175 return wine_dbg_sprintf("{ family AF_INET, address %s, port %d }",
176 p, ntohs(sin->sin_port));
177 }
178 case AF_INET6:
179 {
180 char buf[46];
181 const char *p;
182 struct sockaddr_in6 *sin = (struct sockaddr_in6 *)a;
183
184 p = inet_ntop( AF_INET6, &sin->sin6_addr, buf, sizeof(buf) );
185 if (!p)
186 p = "(unknown IPv6 address)";
187 return wine_dbg_sprintf("{ family AF_INET6, address %s, flow label %#lx, port %d, scope %lu }",
188 p, sin->sin6_flowinfo, ntohs(sin->sin6_port), sin->sin6_scope_id );
189 }
190 case AF_IPX:
191 {
192 int i;
193 char netnum[16], nodenum[16];
194 struct sockaddr_ipx *sin = (struct sockaddr_ipx *)a;
195
196 for (i = 0;i < 4; i++) sprintf(netnum + i * 2, "%02X", (unsigned char) sin->sa_netnum[i]);
197 for (i = 0;i < 6; i++) sprintf(nodenum + i * 2, "%02X", (unsigned char) sin->sa_nodenum[i]);
198
199 return wine_dbg_sprintf("{ family AF_IPX, address %s.%s, ipx socket %d }",
200 netnum, nodenum, sin->sa_socket);
201 }
202 case AF_IRDA:
203 {
204 DWORD addr;
205
206 memcpy( &addr, ((const SOCKADDR_IRDA *)a)->irdaDeviceID, sizeof(addr) );
207 addr = ntohl( addr );
208 return wine_dbg_sprintf("{ family AF_IRDA, addr %08lx, name %s }",
209 addr,
210 ((const SOCKADDR_IRDA *)a)->irdaServiceName);
211 }
212 default:
213 return wine_dbg_sprintf("{ family %d }", a->sa_family);
214 }
215 }
216
217 static inline const char *debugstr_sockopt(int level, int optname)
218 {
219 const char *stropt = NULL, *strlevel = NULL;
220
221 #define DEBUG_SOCKLEVEL(x) case (x): strlevel = #x
222 #define DEBUG_SOCKOPT(x) case (x): stropt = #x; break
223
224 switch(level)
225 {
226 DEBUG_SOCKLEVEL(SOL_SOCKET);
227 switch(optname)
228 {
229 DEBUG_SOCKOPT(SO_ACCEPTCONN);
230 DEBUG_SOCKOPT(SO_BROADCAST);
231 DEBUG_SOCKOPT(SO_BSP_STATE);
232 DEBUG_SOCKOPT(SO_CONDITIONAL_ACCEPT);
233 DEBUG_SOCKOPT(SO_CONNECT_TIME);
234 DEBUG_SOCKOPT(SO_DEBUG);
235 DEBUG_SOCKOPT(SO_DONTLINGER);
236 DEBUG_SOCKOPT(SO_DONTROUTE);
237 DEBUG_SOCKOPT(SO_ERROR);
238 DEBUG_SOCKOPT(SO_EXCLUSIVEADDRUSE);
239 DEBUG_SOCKOPT(SO_GROUP_ID);
240 DEBUG_SOCKOPT(SO_GROUP_PRIORITY);
241 DEBUG_SOCKOPT(SO_KEEPALIVE);
242 DEBUG_SOCKOPT(SO_LINGER);
243 DEBUG_SOCKOPT(SO_MAX_MSG_SIZE);
244 DEBUG_SOCKOPT(SO_OOBINLINE);
245 DEBUG_SOCKOPT(SO_OPENTYPE);
246 DEBUG_SOCKOPT(SO_PROTOCOL_INFOA);
247 DEBUG_SOCKOPT(SO_PROTOCOL_INFOW);
248 DEBUG_SOCKOPT(SO_RCVBUF);
249 DEBUG_SOCKOPT(SO_RCVTIMEO);
250 DEBUG_SOCKOPT(SO_REUSEADDR);
251 DEBUG_SOCKOPT(SO_SNDBUF);
252 DEBUG_SOCKOPT(SO_SNDTIMEO);
253 DEBUG_SOCKOPT(SO_TYPE);
254 DEBUG_SOCKOPT(SO_UPDATE_CONNECT_CONTEXT);
255 }
256 break;
257
258 DEBUG_SOCKLEVEL(NSPROTO_IPX);
259 switch(optname)
260 {
261 DEBUG_SOCKOPT(IPX_PTYPE);
262 DEBUG_SOCKOPT(IPX_FILTERPTYPE);
263 DEBUG_SOCKOPT(IPX_DSTYPE);
264 DEBUG_SOCKOPT(IPX_RECVHDR);
265 DEBUG_SOCKOPT(IPX_MAXSIZE);
266 DEBUG_SOCKOPT(IPX_ADDRESS);
267 DEBUG_SOCKOPT(IPX_MAX_ADAPTER_NUM);
268 }
269 break;
270
271 DEBUG_SOCKLEVEL(SOL_IRLMP);
272 switch(optname)
273 {
274 DEBUG_SOCKOPT(IRLMP_ENUMDEVICES);
275 }
276 break;
277
278 DEBUG_SOCKLEVEL(IPPROTO_TCP);
279 switch(optname)
280 {
281 DEBUG_SOCKOPT(TCP_BSDURGENT);
282 DEBUG_SOCKOPT(TCP_EXPEDITED_1122);
283 DEBUG_SOCKOPT(TCP_NODELAY);
284 }
285 break;
286
287 DEBUG_SOCKLEVEL(IPPROTO_IP);
288 switch(optname)
289 {
290 DEBUG_SOCKOPT(IP_ADD_MEMBERSHIP);
291 DEBUG_SOCKOPT(IP_DONTFRAGMENT);
292 DEBUG_SOCKOPT(IP_DROP_MEMBERSHIP);
293 DEBUG_SOCKOPT(IP_HDRINCL);
294 DEBUG_SOCKOPT(IP_MULTICAST_IF);
295 DEBUG_SOCKOPT(IP_MULTICAST_LOOP);
296 DEBUG_SOCKOPT(IP_MULTICAST_TTL);
297 DEBUG_SOCKOPT(IP_OPTIONS);
298 DEBUG_SOCKOPT(IP_PKTINFO);
299 DEBUG_SOCKOPT(IP_RECEIVE_BROADCAST);
300 DEBUG_SOCKOPT(IP_RECVTOS);
301 DEBUG_SOCKOPT(IP_RECVTTL);
302 DEBUG_SOCKOPT(IP_TOS);
303 DEBUG_SOCKOPT(IP_TTL);
304 DEBUG_SOCKOPT(IP_UNICAST_IF);
305 }
306 break;
307
308 DEBUG_SOCKLEVEL(IPPROTO_IPV6);
309 switch(optname)
310 {
311 DEBUG_SOCKOPT(IPV6_ADD_MEMBERSHIP);
312 DEBUG_SOCKOPT(IPV6_DROP_MEMBERSHIP);
313 DEBUG_SOCKOPT(IPV6_HOPLIMIT);
314 DEBUG_SOCKOPT(IPV6_MULTICAST_IF);
315 DEBUG_SOCKOPT(IPV6_MULTICAST_HOPS);
316 DEBUG_SOCKOPT(IPV6_MULTICAST_LOOP);
317 DEBUG_SOCKOPT(IPV6_PKTINFO);
318 DEBUG_SOCKOPT(IPV6_RECVTCLASS);
319 DEBUG_SOCKOPT(IPV6_UNICAST_HOPS);
320 DEBUG_SOCKOPT(IPV6_V6ONLY);
321 DEBUG_SOCKOPT(IPV6_UNICAST_IF);
322 DEBUG_SOCKOPT(IPV6_DONTFRAG);
323 }
324 break;
325 }
326 #undef DEBUG_SOCKLEVEL
327 #undef DEBUG_SOCKOPT
328
329 if (!strlevel)
330 strlevel = wine_dbg_sprintf("0x%x", level);
331 if (!stropt)
332 stropt = wine_dbg_sprintf("0x%x", optname);
333
334 return wine_dbg_sprintf("level %s, name %s", strlevel, stropt);
335 }
336
337 static inline const char *debugstr_optval(const char *optval, int optlenval)
338 {
339 if (optval && !IS_INTRESOURCE(optval) && optlenval >= 1 && optlenval <= sizeof(DWORD))
340 {
341 DWORD value = 0;
342 memcpy(&value, optval, optlenval);
343 return wine_dbg_sprintf("%p (%lu)", optval, value);
344 }
345 return wine_dbg_sprintf("%p", optval);
346 }
347
348 /* HANDLE<->SOCKET conversion (SOCKET is UINT_PTR). */
349 #define SOCKET2HANDLE(s) ((HANDLE)(s))
350 #define HANDLE2SOCKET(h) ((SOCKET)(h))
351
352 static BOOL socket_list_add(SOCKET socket)
353 {
354 unsigned int i, new_size;
355 SOCKET *new_array;
356
357 EnterCriticalSection(&cs_socket_list);
358 for (i = 0; i < socket_list_size; ++i)
359 {
360 if (!socket_list[i])
361 {
362 socket_list[i] = socket;
363 LeaveCriticalSection(&cs_socket_list);
364 return TRUE;
365 }
366 }
367 new_size = max(socket_list_size * 2, 8);
368 if (!(new_array = realloc( socket_list, new_size * sizeof(*socket_list) )))
369 {
370 LeaveCriticalSection(&cs_socket_list);
371 return FALSE;
372 }
373 socket_list = new_array;
374 memset(socket_list + socket_list_size, 0, (new_size - socket_list_size) * sizeof(*socket_list));
375 socket_list[socket_list_size] = socket;
376 socket_list_size = new_size;
377 LeaveCriticalSection(&cs_socket_list);
378 return TRUE;
379 }
380
381
382 static BOOL socket_list_find( SOCKET socket )
383 {
384 unsigned int i;
385
386 if (!socket) return FALSE;
387
388 EnterCriticalSection( &cs_socket_list );
389 for (i = 0; i < socket_list_size; ++i)
390 {
391 if (socket_list[i] == socket)
392 {
393 LeaveCriticalSection( &cs_socket_list );
394 return TRUE;
395 }
396 }
397 LeaveCriticalSection( &cs_socket_list );
398 return FALSE;
399 }
400
401
402 static BOOL socket_list_remove( SOCKET socket )
403 {
404 unsigned int i;
405
406 if (!socket) return FALSE;
407
408 EnterCriticalSection(&cs_socket_list);
409 for (i = 0; i < socket_list_size; ++i)
410 {
411 if (socket_list[i] == socket)
412 {
413 socket_list[i] = 0;
414 LeaveCriticalSection( &cs_socket_list );
415 return TRUE;
416 }
417 }
418 LeaveCriticalSection(&cs_socket_list);
419 return FALSE;
420 }
421
422 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x );
423
424 int num_startup;
425 static FARPROC blocking_hook = (FARPROC)WSA_DefaultBlockingHook;
426
427 /* function prototypes */
428 static int ws_protocol_info(SOCKET s, int unicode, WSAPROTOCOL_INFOW *buffer, int *size);
429
430 static DWORD NtStatusToWSAError( NTSTATUS status )
431 {
432 static const struct
433 {
434 NTSTATUS status;
435 DWORD error;
436 }
437 errors[] =
438 {
439 {STATUS_PENDING, ERROR_IO_PENDING},
440
441 {STATUS_BUFFER_OVERFLOW, WSAEMSGSIZE},
442
443 {STATUS_NOT_IMPLEMENTED, WSAEOPNOTSUPP},
444 {STATUS_ACCESS_VIOLATION, WSAEFAULT},
445 {STATUS_PAGEFILE_QUOTA, WSAENOBUFS},
446 {STATUS_INVALID_HANDLE, WSAENOTSOCK},
447 {STATUS_NO_SUCH_DEVICE, WSAENETDOWN},
448 {STATUS_NO_SUCH_FILE, WSAENETDOWN},
449 {STATUS_NO_MEMORY, WSAENOBUFS},
450 {STATUS_CONFLICTING_ADDRESSES, WSAENOBUFS},
451 {STATUS_ACCESS_DENIED, WSAEACCES},
452 {STATUS_BUFFER_TOO_SMALL, WSAEFAULT},
453 {STATUS_OBJECT_TYPE_MISMATCH, WSAENOTSOCK},
454 {STATUS_OBJECT_NAME_NOT_FOUND, WSAENETDOWN},
455 {STATUS_OBJECT_PATH_NOT_FOUND, WSAENETDOWN},
456 {STATUS_SHARING_VIOLATION, WSAEADDRINUSE},
457 {STATUS_QUOTA_EXCEEDED, WSAENOBUFS},
458 {STATUS_TOO_MANY_PAGING_FILES, WSAENOBUFS},
459 {STATUS_INSUFFICIENT_RESOURCES, WSAENOBUFS},
460 {STATUS_WORKING_SET_QUOTA, WSAENOBUFS},
461 {STATUS_DEVICE_NOT_READY, WSAEWOULDBLOCK},
462 {STATUS_PIPE_DISCONNECTED, WSAESHUTDOWN},
463 {STATUS_IO_TIMEOUT, WSAETIMEDOUT},
464 {STATUS_NOT_SUPPORTED, WSAEOPNOTSUPP},
465 {STATUS_REMOTE_NOT_LISTENING, WSAECONNREFUSED},
466 {STATUS_BAD_NETWORK_PATH, WSAENETUNREACH},
467 {STATUS_NETWORK_BUSY, WSAENETDOWN},
468 {STATUS_INVALID_NETWORK_RESPONSE, WSAENETDOWN},
469 {STATUS_UNEXPECTED_NETWORK_ERROR, WSAENETDOWN},
470 {STATUS_REQUEST_NOT_ACCEPTED, WSAEWOULDBLOCK},
471 {STATUS_CANCELLED, ERROR_OPERATION_ABORTED},
472 {STATUS_COMMITMENT_LIMIT, WSAENOBUFS},
473 {STATUS_LOCAL_DISCONNECT, WSAECONNABORTED},
474 {STATUS_REMOTE_DISCONNECT, WSAECONNRESET},
475 {STATUS_REMOTE_RESOURCES, WSAENOBUFS},
476 {STATUS_LINK_FAILED, WSAECONNRESET},
477 {STATUS_LINK_TIMEOUT, WSAETIMEDOUT},
478 {STATUS_INVALID_CONNECTION, WSAENOTCONN},
479 {STATUS_INVALID_ADDRESS, WSAEADDRNOTAVAIL},
480 {STATUS_INVALID_BUFFER_SIZE, WSAEMSGSIZE},
481 {STATUS_INVALID_ADDRESS_COMPONENT, WSAEADDRNOTAVAIL},
482 {STATUS_TOO_MANY_ADDRESSES, WSAENOBUFS},
483 {STATUS_ADDRESS_ALREADY_EXISTS, WSAEADDRINUSE},
484 {STATUS_CONNECTION_DISCONNECTED, WSAECONNRESET},
485 {STATUS_CONNECTION_RESET, WSAECONNRESET},
486 {STATUS_TRANSACTION_ABORTED, WSAECONNABORTED},
487 {STATUS_CONNECTION_REFUSED, WSAECONNREFUSED},
488 {STATUS_GRACEFUL_DISCONNECT, WSAEDISCON},
489 {STATUS_CONNECTION_ACTIVE, WSAEISCONN},
490 {STATUS_NETWORK_UNREACHABLE, WSAENETUNREACH},
491 {STATUS_HOST_UNREACHABLE, WSAEHOSTUNREACH},
492 {STATUS_PROTOCOL_UNREACHABLE, WSAENETUNREACH},
493 {STATUS_PORT_UNREACHABLE, WSAECONNRESET},
494 {STATUS_REQUEST_ABORTED, WSAEINTR},
495 {STATUS_CONNECTION_ABORTED, WSAECONNABORTED},
496 {STATUS_DATATYPE_MISALIGNMENT_ERROR,WSAEFAULT},
497 {STATUS_HOST_DOWN, WSAEHOSTDOWN},
498 {0x80070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
499 {0xc0010000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
500 {0xc0070000 | ERROR_IO_INCOMPLETE, ERROR_IO_INCOMPLETE},
501 };
502
503 unsigned int i;
504
505 for (i = 0; i < ARRAY_SIZE(errors); ++i)
506 {
507 if (errors[i].status == status)
508 return errors[i].error;
509 }
510
511 return NT_SUCCESS(status) ? RtlNtStatusToDosErrorNoTeb(status) : WSAEINVAL;
512 }
513
514
515 struct per_thread_data *get_per_thread_data(void)
516 {
517 struct per_thread_data *data = NtCurrentTeb()->WinSockData;
518
519 if (!data)
520 {
521 data = calloc( 1, sizeof(*data) );
522 NtCurrentTeb()->WinSockData = data;
523 }
524 return data;
525 }
526
527 static void free_per_thread_data(void)
528 {
529 struct per_thread_data *data = NtCurrentTeb()->WinSockData;
530
531 if (!data) return;
532
533 CloseHandle( data->sync_event );
534
535 /* delete scratch buffers */
536 free( data->he_buffer );
537 free( data->se_buffer );
538 free( data->pe_buffer );
539
540 free( data );
541 NtCurrentTeb()->WinSockData = NULL;
542 }
543
544 static HANDLE get_sync_event(void)
545 {
546 struct per_thread_data *data;
547
548 if (!(data = get_per_thread_data())) return NULL;
549 if (!data->sync_event)
550 data->sync_event = CreateEventW( NULL, TRUE, FALSE, NULL );
551 return data->sync_event;
552 }
553
554 static DWORD wait_event_alertable( HANDLE event )
555 {
556 DWORD ret;
557
558 while ((ret = WaitForSingleObjectEx( event, INFINITE, TRUE )) == WAIT_IO_COMPLETION)
559 ;
560 return ret;
561 }
562
563 BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, void *reserved )
564 {
565 switch (reason)
566 {
567 case DLL_PROCESS_ATTACH:
568 return !NtQueryVirtualMemory( GetCurrentProcess(), instance, MemoryWineUnixFuncs,
569 &ws_unix_handle, sizeof(ws_unix_handle), NULL );
570
571 case DLL_THREAD_DETACH:
572 free_per_thread_data();
573 }
574 return TRUE;
575 }
576
577
578 /***********************************************************************
579 * WSAStartup (WS2_32.115)
580 */
581 int WINAPI WSAStartup( WORD version, WSADATA *data )
582 {
583 TRACE( "version %#x\n", version );
584
585 if (data)
586 {
587 if (!LOBYTE(version) || LOBYTE(version) > 2
588 || (LOBYTE(version) == 2 && HIBYTE(version) > 2))
589 data->wVersion = MAKEWORD(2, 2);
590 else if (LOBYTE(version) == 1 && HIBYTE(version) > 1)
591 data->wVersion = MAKEWORD(1, 1);
592 else
593 data->wVersion = version;
594 data->wHighVersion = MAKEWORD(2, 2);
595 strcpy( data->szDescription, "WinSock 2.0" );
596 strcpy( data->szSystemStatus, "Running" );
597 data->iMaxSockets = (LOBYTE(version) == 1 ? 32767 : 0);
598 data->iMaxUdpDg = (LOBYTE(version) == 1 ? 65467 : 0);
599 /* don't fill lpVendorInfo */
600 }
601
602 if (!LOBYTE(version))
603 return WSAVERNOTSUPPORTED;
604
605 if (!data) return WSAEFAULT;
606
607 num_startup++;
608 TRACE( "increasing startup count to %d\n", num_startup );
609 return 0;
610 }
611
612
613 /***********************************************************************
614 * WSACleanup (WS2_32.116)
615 */
616 INT WINAPI WSACleanup(void)
617 {
618 TRACE("decreasing startup count from %d\n", num_startup);
619 if (num_startup)
620 {
621 if (!--num_startup)
622 {
623 unsigned int i;
624
625 for (i = 0; i < socket_list_size; ++i)
626 CloseHandle(SOCKET2HANDLE(socket_list[i]));
627 memset(socket_list, 0, socket_list_size * sizeof(*socket_list));
628 }
629 return 0;
630 }
631 SetLastError(WSANOTINITIALISED);
632 return SOCKET_ERROR;
633 }
634
635
636 /***********************************************************************
637 * WSAGetLastError (WS2_32.111)
638 */
639 INT WINAPI WSAGetLastError(void)
640 {
641 return GetLastError();
642 }
643
644 /***********************************************************************
645 * WSASetLastError (WS2_32.112)
646 */
647 void WINAPI WSASetLastError(INT iError) {
648 SetLastError(iError);
649 }
650
651 static INT WS_DuplicateSocket(BOOL unicode, SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo)
652 {
653 HANDLE hProcess;
654 int size;
655 WSAPROTOCOL_INFOW infow;
656
657 TRACE( "unicode %d, socket %#Ix, pid %#lx, info %p\n", unicode, s, dwProcessId, lpProtocolInfo );
658
659 if (!ws_protocol_info(s, unicode, &infow, &size))
660 return SOCKET_ERROR;
661
662 if (!(hProcess = OpenProcess(PROCESS_DUP_HANDLE, FALSE, dwProcessId)))
663 {
664 SetLastError(WSAEINVAL);
665 return SOCKET_ERROR;
666 }
667
668 if (!lpProtocolInfo)
669 {
670 CloseHandle(hProcess);
671 SetLastError(WSAEFAULT);
672 return SOCKET_ERROR;
673 }
674
675 /* I don't know what the real Windoze does next, this is a hack */
676 /* ...we could duplicate and then use ConvertToGlobalHandle on the duplicate, then let
677 * the target use the global duplicate, or we could copy a reference to us to the structure
678 * and let the target duplicate it from us, but let's do it as simple as possible */
679 memcpy(lpProtocolInfo, &infow, size);
680 DuplicateHandle(GetCurrentProcess(), SOCKET2HANDLE(s),
681 hProcess, (LPHANDLE)&lpProtocolInfo->dwServiceFlags3,
682 0, FALSE, DUPLICATE_SAME_ACCESS);
683 CloseHandle(hProcess);
684 lpProtocolInfo->dwServiceFlags4 = 0xff00ff00; /* magic */
685 return 0;
686 }
687
688 static BOOL ws_protocol_info(SOCKET s, int unicode, WSAPROTOCOL_INFOW *buffer, int *size)
689 {
690 struct afd_get_info_params params;
691 IO_STATUS_BLOCK io;
692 NTSTATUS status;
693 unsigned int i;
694
695 *size = unicode ? sizeof(WSAPROTOCOL_INFOW) : sizeof(WSAPROTOCOL_INFOA);
696 memset(buffer, 0, *size);
697
698 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io,
699 IOCTL_AFD_WINE_GET_INFO, NULL, 0, &params, sizeof(params) );
700 if (status)
701 {
702 SetLastError( NtStatusToWSAError( status ) );
703 return FALSE;
704 }
705
706 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
707 {
708 const WSAPROTOCOL_INFOW *info = &supported_protocols[i];
709 if (params.family == info->iAddressFamily &&
710 params.type == info->iSocketType &&
711 params.protocol >= info->iProtocol &&
712 params.protocol <= info->iProtocol + info->iProtocolMaxOffset)
713 {
714 if (unicode)
715 *buffer = *info;
716 else
717 {
718 WSAPROTOCOL_INFOA *bufferA = (WSAPROTOCOL_INFOA *)buffer;
719 memcpy( bufferA, info, offsetof( WSAPROTOCOL_INFOW, szProtocol ) );
720 WideCharToMultiByte( CP_ACP, 0, info->szProtocol, -1,
721 bufferA->szProtocol, sizeof(bufferA->szProtocol), NULL, NULL );
722 }
723 buffer->iProtocol = params.protocol;
724 return TRUE;
725 }
726 }
727 FIXME( "Could not fill protocol information for family %d, type %d, protocol %d.\n",
728 params.family, params.type, params.protocol );
729 return TRUE;
730 }
731
732
733
734 /***********************************************************************
735 * accept (WS2_32.1)
736 */
737 SOCKET WINAPI accept( SOCKET s, struct sockaddr *addr, int *len )
738 {
739 IO_STATUS_BLOCK io;
740 NTSTATUS status;
741 ULONG accept_handle;
742 HANDLE sync_event;
743 SOCKET ret;
744
745 TRACE( "socket %#Ix\n", s );
746
747 if (!(sync_event = get_sync_event())) return INVALID_SOCKET;
748 status = NtDeviceIoControlFile( (HANDLE)s, sync_event, NULL, NULL, &io, IOCTL_AFD_WINE_ACCEPT,
749 NULL, 0, &accept_handle, sizeof(accept_handle) );
750 if (status == STATUS_PENDING)
751 {
752 if (WaitForSingleObject( sync_event, INFINITE ) == WAIT_FAILED)
753 return SOCKET_ERROR;
754 status = io.u.Status;
755 }
756 if (status)
757 {
758 TRACE( "failed, status %#lx\n", status );
759 WSASetLastError( NtStatusToWSAError( status ) );
760 return INVALID_SOCKET;
761 }
762
763 ret = accept_handle;
764 if (!socket_list_add( ret ))
765 {
766 CloseHandle( SOCKET2HANDLE(ret) );
767 return INVALID_SOCKET;
768 }
769 if (addr && len && getpeername( ret, addr, len ))
770 {
771 closesocket( ret );
772 return INVALID_SOCKET;
773 }
774
775 TRACE( "returning %#Ix\n", ret );
776 return ret;
777 }
778
779 /***********************************************************************
780 * AcceptEx
781 */
782 static BOOL WINAPI WS2_AcceptEx( SOCKET listener, SOCKET acceptor, void *dest, DWORD recv_len,
783 DWORD local_len, DWORD remote_len, DWORD *ret_len, OVERLAPPED *overlapped)
784 {
785 struct afd_accept_into_params params =
786 {
787 .accept_handle = acceptor,
788 .recv_len = recv_len,
789 .local_len = local_len,
790 };
791 void *cvalue = NULL;
792 NTSTATUS status;
793
794 TRACE( "listener %#Ix, acceptor %#Ix, dest %p, recv_len %lu, local_len %lu, remote_len %lu, ret_len %p, "
795 "overlapped %p\n", listener, acceptor, dest, recv_len, local_len, remote_len, ret_len, overlapped );
796
797 if (!overlapped)
798 {
799 SetLastError(WSA_INVALID_PARAMETER);
800 return FALSE;
801 }
802
803 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
804 overlapped->Internal = STATUS_PENDING;
805 overlapped->InternalHigh = 0;
806
807 if (!dest)
808 {
809 SetLastError(WSAEINVAL);
810 return FALSE;
811 }
812
813 if (!remote_len)
814 {
815 SetLastError(WSAEFAULT);
816 return FALSE;
817 }
818
819 status = NtDeviceIoControlFile( SOCKET2HANDLE(listener), overlapped->hEvent, NULL, cvalue,
820 (IO_STATUS_BLOCK *)overlapped, IOCTL_AFD_WINE_ACCEPT_INTO, &params, sizeof(params),
821 dest, recv_len + local_len + remote_len );
822
823 if (ret_len) *ret_len = overlapped->InternalHigh;
824 WSASetLastError( NtStatusToWSAError(status) );
825 TRACE( "status %#lx.\n", status );
826 return !status;
827 }
828
829
830 static BOOL WINAPI WS2_TransmitFile( SOCKET s, HANDLE file, DWORD file_len, DWORD buffer_size,
831 OVERLAPPED *overlapped, TRANSMIT_FILE_BUFFERS *buffers, DWORD flags )
832 {
833 struct afd_transmit_params params = {{{0}}};
834 IO_STATUS_BLOCK iosb, *piosb = &iosb;
835 HANDLE event = NULL;
836 void *cvalue = NULL;
837 NTSTATUS status;
838
839 TRACE( "socket %#Ix, file %p, file_len %lu, buffer_size %lu, overlapped %p, buffers %p, flags %#lx\n",
840 s, file, file_len, buffer_size, overlapped, buffers, flags );
841
842 if (overlapped)
843 {
844 piosb = (IO_STATUS_BLOCK *)overlapped;
845 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
846 event = overlapped->hEvent;
847 overlapped->Internal = STATUS_PENDING;
848 overlapped->InternalHigh = 0;
849 params.offset.u.LowPart = overlapped->u.s.Offset;
850 params.offset.u.HighPart = overlapped->u.s.OffsetHigh;
851 }
852 else
853 {
854 if (!(event = get_sync_event())) return -1;
855 params.offset.QuadPart = FILE_USE_FILE_POINTER_POSITION;
856 }
857
858 params.file = HandleToULong( file );
859 params.file_len = file_len;
860 params.buffer_size = buffer_size;
861 if (buffers)
862 {
863 params.head_ptr = u64_from_user_ptr(buffers->Head);
864 params.head_len = buffers->HeadLength;
865 params.tail_ptr = u64_from_user_ptr(buffers->Tail);
866 params.tail_len = buffers->TailLength;
867 }
868 params.flags = flags;
869
870 status = NtDeviceIoControlFile( (HANDLE)s, event, NULL, cvalue, piosb,
871 IOCTL_AFD_WINE_TRANSMIT, &params, sizeof(params), NULL, 0 );
872 if (status == STATUS_PENDING && !overlapped)
873 {
874 if (WaitForSingleObject( event, INFINITE ) == WAIT_FAILED)
875 return FALSE;
876 status = piosb->u.Status;
877 }
878 SetLastError( NtStatusToWSAError( status ) );
879 TRACE( "status %#lx.\n", status );
880 return !status;
881 }
882
883
884 /***********************************************************************
885 * GetAcceptExSockaddrs
886 */
887 static void WINAPI WS2_GetAcceptExSockaddrs( void *buffer, DWORD data_size, DWORD local_size, DWORD remote_size,
888 struct sockaddr **local_addr, LPINT local_addr_len,
889 struct sockaddr **remote_addr, LPINT remote_addr_len )
890 {
891 char *cbuf = buffer;
892
893 TRACE( "buffer %p, data_size %lu, local_size %lu, remote_size %lu,"
894 " local_addr %p, local_addr_len %p, remote_addr %p, remote_addr_len %p\n",
895 buffer, data_size, local_size, remote_size,
896 local_addr, local_addr_len, remote_addr, remote_addr_len );
897
898 cbuf += data_size;
899
900 *local_addr_len = *(int *) cbuf;
901 *local_addr = (struct sockaddr *)(cbuf + sizeof(int));
902
903 cbuf += local_size;
904
905 *remote_addr_len = *(int *) cbuf;
906 *remote_addr = (struct sockaddr *)(cbuf + sizeof(int));
907 }
908
909
910 static void WINAPI socket_apc( void *apc_user, IO_STATUS_BLOCK *io, ULONG reserved )
911 {
912 LPWSAOVERLAPPED_COMPLETION_ROUTINE func = apc_user;
913 func( NtStatusToWSAError( io->u.Status ), io->Information, (OVERLAPPED *)io, 0 );
914 }
915
916 static int WS2_recv_base( SOCKET s, WSABUF *buffers, DWORD buffer_count, DWORD *ret_size, DWORD *flags,
917 struct sockaddr *addr, int *addr_len, OVERLAPPED *overlapped,
918 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion, WSABUF *control )
919 {
920 IO_STATUS_BLOCK iosb, *piosb = &iosb;
921 struct afd_recvmsg_params params;
922 PIO_APC_ROUTINE apc = NULL;
923 HANDLE event = NULL;
924 void *cvalue = NULL;
925 NTSTATUS status;
926
927 TRACE( "socket %#Ix, buffers %p, buffer_count %lu, flags %#lx, addr %p, "
928 "addr_len %d, overlapped %p, completion %p, control %p\n",
929 s, buffers, buffer_count, *flags, addr, addr_len ? *addr_len : -1, overlapped, completion, control );
930
931 if (overlapped)
932 {
933 piosb = (IO_STATUS_BLOCK *)overlapped;
934 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
935 event = overlapped->hEvent;
936 }
937 else
938 {
939 if (!(event = get_sync_event())) return -1;
940 }
941 piosb->u.Status = STATUS_PENDING;
942
943 if (completion)
944 {
945 event = NULL;
946 cvalue = completion;
947 apc = socket_apc;
948 }
949
950 params.control_ptr = u64_from_user_ptr(control);
951 params.addr_ptr = u64_from_user_ptr(addr);
952 params.addr_len_ptr = u64_from_user_ptr(addr_len);
953 params.ws_flags_ptr = u64_from_user_ptr(flags);
954 params.force_async = !!overlapped;
955 params.count = buffer_count;
956 params.buffers_ptr = u64_from_user_ptr(buffers);
957
958 status = NtDeviceIoControlFile( (HANDLE)s, event, apc, cvalue, piosb,
959 IOCTL_AFD_WINE_RECVMSG, &params, sizeof(params), NULL, 0 );
960 if (status == STATUS_PENDING && !overlapped)
961 {
962 if (wait_event_alertable( event ) == WAIT_FAILED)
963 return -1;
964 status = piosb->u.Status;
965 }
966 if (!status && ret_size) *ret_size = piosb->Information;
967 SetLastError( NtStatusToWSAError( status ) );
968 TRACE( "status %#lx.\n", status );
969 return status ? -1 : 0;
970 }
971
972 static int WS2_sendto( SOCKET s, WSABUF *buffers, DWORD buffer_count, DWORD *ret_size, DWORD flags,
973 const struct sockaddr *addr, int addr_len, OVERLAPPED *overlapped,
974 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
975 {
976 IO_STATUS_BLOCK iosb, *piosb = &iosb;
977 struct afd_sendmsg_params params;
978 PIO_APC_ROUTINE apc = NULL;
979 HANDLE event = NULL;
980 void *cvalue = NULL;
981 NTSTATUS status;
982
983 TRACE( "socket %#Ix, buffers %p, buffer_count %lu, flags %#lx, addr %p, "
984 "addr_len %d, overlapped %p, completion %p\n",
985 s, buffers, buffer_count, flags, addr, addr_len, overlapped, completion );
986
987 if (!socket_list_find( s ))
988 {
989 SetLastError( WSAENOTSOCK );
990 return -1;
991 }
992
993 if (!overlapped && !ret_size)
994 {
995 SetLastError( WSAEFAULT );
996 return -1;
997 }
998
999 if (overlapped)
1000 {
1001 piosb = (IO_STATUS_BLOCK *)overlapped;
1002 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
1003 event = overlapped->hEvent;
1004 }
1005 else
1006 {
1007 if (!(event = get_sync_event())) return -1;
1008 }
1009 piosb->u.Status = STATUS_PENDING;
1010
1011 if (completion)
1012 {
1013 event = NULL;
1014 cvalue = completion;
1015 apc = socket_apc;
1016 }
1017
1018 params.addr_ptr = u64_from_user_ptr( addr );
1019 params.addr_len = addr_len;
1020 params.ws_flags = flags;
1021 params.force_async = !!overlapped;
1022 params.count = buffer_count;
1023 params.buffers_ptr = u64_from_user_ptr( buffers );
1024
1025 status = NtDeviceIoControlFile( (HANDLE)s, event, apc, cvalue, piosb,
1026 IOCTL_AFD_WINE_SENDMSG, &params, sizeof(params), NULL, 0 );
1027 if (status == STATUS_PENDING && !overlapped)
1028 {
1029 if (WaitForSingleObject( event, INFINITE ) == WAIT_FAILED)
1030 return -1;
1031 status = piosb->u.Status;
1032 }
1033 if (!status && ret_size) *ret_size = piosb->Information;
1034 SetLastError( NtStatusToWSAError( status ) );
1035 TRACE( "status %#lx.\n", status );
1036 return status ? -1 : 0;
1037 }
1038
1039
1040 /***********************************************************************
1041 * WSASendMsg
1042 */
1043 int WINAPI WSASendMsg( SOCKET s, LPWSAMSG msg, DWORD dwFlags, LPDWORD lpNumberOfBytesSent,
1044 LPWSAOVERLAPPED lpOverlapped,
1045 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1046 {
1047 if (!msg)
1048 {
1049 SetLastError( WSAEFAULT );
1050 return SOCKET_ERROR;
1051 }
1052
1053 return WS2_sendto( s, msg->lpBuffers, msg->dwBufferCount, lpNumberOfBytesSent,
1054 dwFlags, msg->name, msg->namelen,
1055 lpOverlapped, lpCompletionRoutine );
1056 }
1057
1058 /***********************************************************************
1059 * WSARecvMsg
1060 *
1061 * Perform a receive operation that is capable of returning message
1062 * control headers. It is important to note that the WSAMSG parameter
1063 * must remain valid throughout the operation, even when an overlapped
1064 * receive is performed.
1065 */
1066 static int WINAPI WS2_WSARecvMsg( SOCKET s, LPWSAMSG msg, LPDWORD lpNumberOfBytesRecvd,
1067 LPWSAOVERLAPPED lpOverlapped,
1068 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
1069 {
1070 if (!msg)
1071 {
1072 SetLastError( WSAEFAULT );
1073 return SOCKET_ERROR;
1074 }
1075
1076 return WS2_recv_base( s, msg->lpBuffers, msg->dwBufferCount, lpNumberOfBytesRecvd,
1077 &msg->dwFlags, msg->name, &msg->namelen,
1078 lpOverlapped, lpCompletionRoutine, &msg->Control );
1079 }
1080
1081
1082 /***********************************************************************
1083 * bind (ws2_32.2)
1084 */
1085 int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
1086 {
1087 struct afd_bind_params *params;
1088 struct sockaddr *ret_addr;
1089 IO_STATUS_BLOCK io;
1090 HANDLE sync_event;
1091 NTSTATUS status;
1092
1093 TRACE( "socket %#Ix, addr %s\n", s, debugstr_sockaddr(addr) );
1094
1095 if (!addr)
1096 {
1097 SetLastError( WSAEFAULT );
1098 return -1;
1099 }
1100
1101 switch (addr->sa_family)
1102 {
1103 case AF_INET:
1104 if (len < sizeof(struct sockaddr_in))
1105 {
1106 SetLastError( WSAEFAULT );
1107 return -1;
1108 }
1109 break;
1110
1111 case AF_INET6:
1112 if (len < sizeof(struct sockaddr_in6))
1113 {
1114 SetLastError( WSAEFAULT );
1115 return -1;
1116 }
1117 break;
1118
1119 case AF_IPX:
1120 if (len < sizeof(struct sockaddr_ipx))
1121 {
1122 SetLastError( WSAEFAULT );
1123 return -1;
1124 }
1125 break;
1126
1127 case AF_IRDA:
1128 if (len < sizeof(SOCKADDR_IRDA))
1129 {
1130 SetLastError( WSAEFAULT );
1131 return -1;
1132 }
1133 break;
1134
1135 default:
1136 FIXME( "unknown protocol %u\n", addr->sa_family );
1137 SetLastError( WSAEAFNOSUPPORT );
1138 return -1;
1139 }
1140
1141 if (!(sync_event = get_sync_event())) return -1;
1142
1143 params = malloc( sizeof(int) + len );
1144 ret_addr = malloc( len );
1145 if (!params || !ret_addr)
1146 {
1147 free( params );
1148 free( ret_addr );
1149 SetLastError( WSAENOBUFS );
1150 return -1;
1151 }
1152 params->unknown = 0;
1153 memcpy( &params->addr, addr, len );
1154
1155 status = NtDeviceIoControlFile( (HANDLE)s, sync_event, NULL, NULL, &io, IOCTL_AFD_BIND,
1156 params, sizeof(int) + len, ret_addr, len );
1157 if (status == STATUS_PENDING)
1158 {
1159 if (WaitForSingleObject( sync_event, INFINITE ) == WAIT_FAILED)
1160 return -1;
1161 status = io.u.Status;
1162 }
1163
1164 if (status) TRACE( "failed, status %#lx.\n", status );
1165 else TRACE( "successfully bound to address %s\n", debugstr_sockaddr( ret_addr ));
1166
1167 free( params );
1168 free( ret_addr );
1169
1170 SetLastError( NtStatusToWSAError( status ) );
1171 return status ? -1 : 0;
1172 }
1173
1174
1175 /***********************************************************************
1176 * closesocket (ws2_32.3)
1177 */
1178 int WINAPI closesocket( SOCKET s )
1179 {
1180 TRACE( "%#Ix\n", s );
1181
1182 if (!num_startup)
1183 {
1184 SetLastError( WSANOTINITIALISED );
1185 return -1;
1186 }
1187
1188 if (!socket_list_remove( s ))
1189 {
1190 SetLastError( WSAENOTSOCK );
1191 return -1;
1192 }
1193
1194 CloseHandle( (HANDLE)s );
1195 return 0;
1196 }
1197
1198
1199 /***********************************************************************
1200 * connect (ws2_32.4)
1201 */
1202 int WINAPI connect( SOCKET s, const struct sockaddr *addr, int len )
1203 {
1204 struct afd_connect_params *params;
1205 IO_STATUS_BLOCK io;
1206 HANDLE sync_event;
1207 NTSTATUS status;
1208
1209 TRACE( "socket %#Ix, addr %s, len %d\n", s, debugstr_sockaddr(addr), len );
1210
1211 if (!(sync_event = get_sync_event())) return -1;
1212
1213 if (!(params = malloc( sizeof(*params) + len )))
1214 {
1215 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1216 return -1;
1217 }
1218 params->addr_len = len;
1219 params->synchronous = TRUE;
1220 memcpy( params + 1, addr, len );
1221
1222 status = NtDeviceIoControlFile( (HANDLE)s, sync_event, NULL, NULL, &io, IOCTL_AFD_WINE_CONNECT,
1223 params, sizeof(*params) + len, NULL, 0 );
1224 free( params );
1225 if (status == STATUS_PENDING)
1226 {
1227 if (WaitForSingleObject( sync_event, INFINITE ) == WAIT_FAILED) return -1;
1228 status = io.u.Status;
1229 }
1230 if (status)
1231 {
1232 /* NtStatusToWSAError() has no mapping for WSAEALREADY */
1233 SetLastError( status == STATUS_ADDRESS_ALREADY_ASSOCIATED ? WSAEALREADY : NtStatusToWSAError( status ) );
1234 TRACE( "failed, status %#lx.\n", status );
1235 return -1;
1236 }
1237 return 0;
1238 }
1239
1240
1241 /***********************************************************************
1242 * WSAConnect (WS2_32.30)
1243 */
1244 int WINAPI WSAConnect( SOCKET s, const struct sockaddr *name, int namelen,
1245 LPWSABUF lpCallerData, LPWSABUF lpCalleeData,
1246 LPQOS lpSQOS, LPQOS lpGQOS )
1247 {
1248 if ( lpCallerData || lpCalleeData || lpSQOS || lpGQOS )
1249 FIXME("unsupported parameters!\n");
1250 return connect( s, name, namelen );
1251 }
1252
1253
1254 static BOOL WINAPI WS2_ConnectEx( SOCKET s, const struct sockaddr *name, int namelen,
1255 void *send_buffer, DWORD send_len, DWORD *ret_len, OVERLAPPED *overlapped )
1256 {
1257 struct afd_connect_params *params;
1258 void *cvalue = NULL;
1259 NTSTATUS status;
1260
1261 TRACE( "socket %#Ix, ptr %p %s, length %d, send_buffer %p, send_len %lu, overlapped %p\n",
1262 s, name, debugstr_sockaddr(name), namelen, send_buffer, send_len, overlapped );
1263
1264 if (!overlapped)
1265 {
1266 SetLastError( WSA_INVALID_PARAMETER );
1267 return FALSE;
1268 }
1269
1270 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
1271 overlapped->Internal = STATUS_PENDING;
1272 overlapped->InternalHigh = 0;
1273
1274 if (!(params = malloc( sizeof(*params) + namelen + send_len )))
1275 {
1276 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1277 return SOCKET_ERROR;
1278 }
1279 params->addr_len = namelen;
1280 params->synchronous = FALSE;
1281 memcpy( params + 1, name, namelen );
1282 memcpy( (char *)(params + 1) + namelen, send_buffer, send_len );
1283
1284 status = NtDeviceIoControlFile( SOCKET2HANDLE(s), overlapped->hEvent, NULL, cvalue,
1285 (IO_STATUS_BLOCK *)overlapped, IOCTL_AFD_WINE_CONNECT,
1286 params, sizeof(*params) + namelen + send_len, NULL, 0 );
1287 free( params );
1288 if (ret_len) *ret_len = overlapped->InternalHigh;
1289 SetLastError( NtStatusToWSAError( status ) );
1290 TRACE( "status %#lx.\n", status );
1291 return !status;
1292 }
1293
1294
1295 /***********************************************************************
1296 * WSAConnectByNameA (WS2_32.@)
1297 */
1298 BOOL WINAPI WSAConnectByNameA(SOCKET s, const char *node_name, const char *service_name,
1299 DWORD *local_addr_len, struct sockaddr *local_addr,
1300 DWORD *remote_addr_len, struct sockaddr *remote_addr,
1301 const struct timeval *timeout, WSAOVERLAPPED *reserved)
1302 {
1303 WSAPROTOCOL_INFOA proto_info;
1304 WSAPOLLFD pollout;
1305 struct addrinfo *service, hints;
1306 int ret, proto_len, sockaddr_size, sockname_size, sock_err, int_len;
1307
1308 TRACE("socket %#Ix, node_name %s, service_name %s, local_addr_len %p, local_addr %p, \
1309 remote_addr_len %p, remote_addr %p, timeout %p, reserved %p\n",
1310 s, debugstr_a(node_name), debugstr_a(service_name), local_addr_len, local_addr,
1311 remote_addr_len, remote_addr, timeout, reserved );
1312
1313 if (!node_name || !service_name || reserved)
1314 {
1315 SetLastError(WSAEINVAL);
1316 return FALSE;
1317 }
1318
1319 if (!s)
1320 {
1321 SetLastError(WSAENOTSOCK);
1322 return FALSE;
1323 }
1324
1325 if (timeout)
1326 FIXME("WSAConnectByName timeout stub\n");
1327
1328 proto_len = sizeof(WSAPROTOCOL_INFOA);
1329 ret = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *)&proto_info, &proto_len);
1330 if (ret)
1331 return FALSE;
1332
1333 memset(&hints, 0, sizeof(struct addrinfo));
1334 hints.ai_socktype = proto_info.iSocketType;
1335 hints.ai_family = proto_info.iAddressFamily;
1336 hints.ai_protocol = proto_info.iProtocol;
1337 ret = getaddrinfo(node_name, service_name, &hints, &service);
1338 if (ret)
1339 return FALSE;
1340
1341 if (proto_info.iSocketType != SOCK_STREAM)
1342 {
1343 freeaddrinfo(service);
1344 SetLastError(WSAEFAULT);
1345 return FALSE;
1346 }
1347
1348 switch (proto_info.iAddressFamily)
1349 {
1350 case AF_INET:
1351 sockaddr_size = sizeof(SOCKADDR_IN);
1352 break;
1353 case AF_INET6:
1354 sockaddr_size = sizeof(SOCKADDR_IN6);
1355 break;
1356 default:
1357 freeaddrinfo(service);
1358 SetLastError(WSAENOTSOCK);
1359 return FALSE;
1360 }
1361
1362 ret = connect(s, service->ai_addr, sockaddr_size);
1363 if (ret)
1364 {
1365 freeaddrinfo(service);
1366 return FALSE;
1367 }
1368
1369 pollout.fd = s;
1370 pollout.events = POLLWRNORM;
1371 ret = WSAPoll(&pollout, 1, -1);
1372 if (ret == SOCKET_ERROR)
1373 {
1374 freeaddrinfo(service);
1375 return FALSE;
1376 }
1377 if (pollout.revents & (POLLERR | POLLHUP | POLLNVAL))
1378 {
1379 freeaddrinfo(service);
1380 int_len = sizeof(int);
1381 ret = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *)&sock_err, &int_len);
1382 if (ret == SOCKET_ERROR)
1383 return FALSE;
1384 SetLastError(sock_err);
1385 return FALSE;
1386 }
1387
1388 if (remote_addr_len && remote_addr)
1389 {
1390 if (*remote_addr_len >= sockaddr_size)
1391 {
1392 memcpy(remote_addr, service->ai_addr, sockaddr_size);
1393 *remote_addr_len = sockaddr_size;
1394 }
1395 else
1396 {
1397 freeaddrinfo(service);
1398 SetLastError(WSAEFAULT);
1399 return FALSE;
1400 }
1401 }
1402
1403 freeaddrinfo(service);
1404
1405 if (local_addr_len && local_addr)
1406 {
1407 if (*local_addr_len >= sockaddr_size)
1408 {
1409 sockname_size = sockaddr_size;
1410 ret = getsockname(s, local_addr, &sockname_size);
1411 if (ret)
1412 return FALSE;
1413 if (proto_info.iAddressFamily == AF_INET6)
1414 ((SOCKADDR_IN6 *)local_addr)->sin6_port = 0;
1415 else
1416 ((SOCKADDR_IN *)local_addr)->sin_port = 0;
1417 *local_addr_len = sockaddr_size;
1418 }
1419 else
1420 {
1421 SetLastError(WSAEFAULT);
1422 return FALSE;
1423 }
1424 }
1425
1426 return TRUE;
1427 }
1428
1429
1430 /***********************************************************************
1431 * WSAConnectByNameW (WS2_32.@)
1432 */
1433 BOOL WINAPI WSAConnectByNameW(SOCKET s, const WCHAR *node_name, const WCHAR *service_name,
1434 DWORD *local_addr_len, struct sockaddr *local_addr,
1435 DWORD *remote_addr_len, struct sockaddr *remote_addr,
1436 const struct timeval *timeout, WSAOVERLAPPED *reserved)
1437 {
1438 char *node_nameA, *service_nameA;
1439 BOOL ret;
1440
1441 if (!node_name || !service_name)
1442 {
1443 SetLastError(WSAEINVAL);
1444 return FALSE;
1445 }
1446
1447 node_nameA = strdupWtoA(node_name);
1448 service_nameA = strdupWtoA(service_name);
1449 if (!node_nameA || !service_nameA)
1450 {
1451 SetLastError(WSAENOBUFS);
1452 return FALSE;
1453 }
1454
1455 ret = WSAConnectByNameA(s, node_nameA, service_nameA, local_addr_len, local_addr,
1456 remote_addr_len, remote_addr, timeout, reserved);
1457 free(node_nameA);
1458 free(service_nameA);
1459 return ret;
1460 }
1461
1462
1463 static BOOL WINAPI WS2_DisconnectEx( SOCKET s, OVERLAPPED *overlapped, DWORD flags, DWORD reserved )
1464 {
1465 IO_STATUS_BLOCK iosb, *piosb = &iosb;
1466 void *cvalue = NULL;
1467 int how = SD_SEND;
1468 HANDLE event = 0;
1469 NTSTATUS status;
1470
1471 TRACE( "socket %#Ix, overlapped %p, flags %#lx, reserved %#lx\n", s, overlapped, flags, reserved );
1472
1473 if (flags & TF_REUSE_SOCKET)
1474 FIXME( "Reusing socket not supported yet\n" );
1475
1476 if (overlapped)
1477 {
1478 piosb = (IO_STATUS_BLOCK *)overlapped;
1479 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
1480 event = overlapped->hEvent;
1481 overlapped->Internal = STATUS_PENDING;
1482 overlapped->InternalHigh = 0;
1483 }
1484
1485 status = NtDeviceIoControlFile( (HANDLE)s, event, NULL, cvalue, piosb,
1486 IOCTL_AFD_WINE_SHUTDOWN, &how, sizeof(how), NULL, 0 );
1487 if (!status && overlapped) status = STATUS_PENDING;
1488 SetLastError( NtStatusToWSAError( status ) );
1489 TRACE( "status %#lx.\n", status );
1490 return !status;
1491 }
1492
1493
1494 /***********************************************************************
1495 * getpeername (ws2_32.5)
1496 */
1497 int WINAPI getpeername( SOCKET s, struct sockaddr *addr, int *len )
1498 {
1499 IO_STATUS_BLOCK io;
1500 NTSTATUS status;
1501
1502 TRACE( "socket %#Ix, addr %p, len %d\n", s, addr, len ? *len : 0 );
1503
1504 if (!socket_list_find( s ))
1505 {
1506 WSASetLastError( WSAENOTSOCK );
1507 return -1;
1508 }
1509
1510 if (!len)
1511 {
1512 SetLastError( WSAEFAULT );
1513 return -1;
1514 }
1515
1516 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io,
1517 IOCTL_AFD_WINE_GETPEERNAME, NULL, 0, addr, *len );
1518 if (!status)
1519 *len = io.Information;
1520 SetLastError( NtStatusToWSAError( status ) );
1521 TRACE( "status %#lx.\n", status );
1522 return status ? -1 : 0;
1523 }
1524
1525
1526 /***********************************************************************
1527 * getsockname (ws2_32.6)
1528 */
1529 int WINAPI getsockname( SOCKET s, struct sockaddr *addr, int *len )
1530 {
1531 IO_STATUS_BLOCK io;
1532 NTSTATUS status;
1533
1534 TRACE( "socket %#Ix, addr %p, len %d\n", s, addr, len ? *len : 0 );
1535
1536 if (!addr)
1537 {
1538 SetLastError( WSAEFAULT );
1539 return -1;
1540 }
1541
1542 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_GETSOCKNAME, NULL, 0, addr, *len );
1543 if (!status)
1544 *len = io.Information;
1545 WSASetLastError( NtStatusToWSAError( status ) );
1546 TRACE( "status %#lx.\n", status );
1547 return status ? -1 : 0;
1548 }
1549
1550
1551 static int server_getsockopt( SOCKET s, ULONG code, char *optval, int *optlen )
1552 {
1553 IO_STATUS_BLOCK io;
1554 NTSTATUS status;
1555
1556 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, code, NULL, 0, optval, *optlen );
1557 if (!status) *optlen = io.Information;
1558 SetLastError( NtStatusToWSAError( status ) );
1559 TRACE( "status %#lx.\n", status );
1560 return status ? -1 : 0;
1561 }
1562
1563
1564 /***********************************************************************
1565 * getsockopt (WS2_32.7)
1566 */
1567 int WINAPI getsockopt( SOCKET s, int level, int optname, char *optval, int *optlen )
1568 {
1569 INT ret = 0;
1570
1571 TRACE( "socket %#Ix, %s, optval %p, optlen %p (%d)\n",
1572 s, debugstr_sockopt(level, optname), optval, optlen, optlen ? *optlen : 0 );
1573
1574 if ((level != SOL_SOCKET || optname != SO_OPENTYPE))
1575 {
1576 if (!socket_list_find( s ))
1577 {
1578 SetLastError( WSAENOTSOCK );
1579 return SOCKET_ERROR;
1580 }
1581 if (!optlen || *optlen <= 0)
1582 {
1583 SetLastError( WSAEFAULT );
1584 return -1;
1585 }
1586 }
1587
1588 switch(level)
1589 {
1590 case SOL_SOCKET:
1591 {
1592 switch(optname)
1593 {
1594 case SO_ACCEPTCONN:
1595 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_ACCEPTCONN, optval, optlen );
1596
1597 case SO_BROADCAST:
1598 ret = server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_BROADCAST, optval, optlen );
1599 if (!ret && *optlen < sizeof(DWORD)) *optlen = 1;
1600 return ret;
1601
1602 case SO_BSP_STATE:
1603 {
1604 CSADDR_INFO *csinfo = (CSADDR_INFO *)optval;
1605 WSAPROTOCOL_INFOW infow;
1606 int addr_size;
1607
1608 if (!ws_protocol_info( s, TRUE, &infow, &addr_size ))
1609 return -1;
1610
1611 if (infow.iAddressFamily == AF_INET)
1612 addr_size = sizeof(struct sockaddr_in);
1613 else if (infow.iAddressFamily == AF_INET6)
1614 addr_size = sizeof(struct sockaddr_in6);
1615 else
1616 {
1617 FIXME( "family %d is unsupported for SO_BSP_STATE\n", infow.iAddressFamily );
1618 SetLastError( WSAEAFNOSUPPORT );
1619 return -1;
1620 }
1621
1622 if (*optlen < sizeof(CSADDR_INFO) + addr_size * 2)
1623 {
1624 ret = 0;
1625 SetLastError( WSAEFAULT );
1626 return -1;
1627 }
1628
1629 csinfo->LocalAddr.lpSockaddr = (struct sockaddr *)(csinfo + 1);
1630 csinfo->RemoteAddr.lpSockaddr = (struct sockaddr *)((char *)(csinfo + 1) + addr_size);
1631
1632 csinfo->LocalAddr.iSockaddrLength = addr_size;
1633 if (getsockname( s, csinfo->LocalAddr.lpSockaddr, &csinfo->LocalAddr.iSockaddrLength ) < 0)
1634 {
1635 csinfo->LocalAddr.lpSockaddr = NULL;
1636 csinfo->LocalAddr.iSockaddrLength = 0;
1637 }
1638
1639 csinfo->RemoteAddr.iSockaddrLength = addr_size;
1640 if (getpeername( s, csinfo->RemoteAddr.lpSockaddr, &csinfo->RemoteAddr.iSockaddrLength ) < 0)
1641 {
1642 csinfo->RemoteAddr.lpSockaddr = NULL;
1643 csinfo->RemoteAddr.iSockaddrLength = 0;
1644 }
1645
1646 csinfo->iSocketType = infow.iSocketType;
1647 csinfo->iProtocol = infow.iProtocol;
1648 return 0;
1649 }
1650
1651 case SO_CONNECT_TIME:
1652 if (!optval)
1653 {
1654 SetLastError( WSAEFAULT );
1655 return -1;
1656 }
1657 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_CONNECT_TIME, optval, optlen );
1658
1659 case SO_DEBUG:
1660 WARN( "returning 0 for SO_DEBUG\n" );
1661 *(DWORD *)optval = 0;
1662 SetLastError( 0 );
1663 return 0;
1664
1665 case SO_DONTLINGER:
1666 {
1667 LINGER linger;
1668 int len = sizeof(linger);
1669 BOOL value;
1670 int ret;
1671
1672 if (*optlen < 1 || !optval)
1673 {
1674 SetLastError(WSAEFAULT);
1675 return SOCKET_ERROR;
1676 }
1677
1678 if (!(ret = getsockopt( s, SOL_SOCKET, SO_LINGER, (char *)&linger, &len )))
1679 {
1680 value = !linger.l_onoff;
1681 memcpy( optval, &value, min( sizeof(BOOL), *optlen ));
1682 *optlen = *optlen >= sizeof(BOOL) ? sizeof(BOOL) : 1;
1683 }
1684 return ret;
1685 }
1686
1687 /* As mentioned in setsockopt, Windows ignores this, so we
1688 * always return true here */
1689 case SO_DONTROUTE:
1690 if (*optlen < 1 || !optval)
1691 {
1692 SetLastError( WSAEFAULT );
1693 return SOCKET_ERROR;
1694 }
1695 *optval = TRUE;
1696 *optlen = 1;
1697 SetLastError( ERROR_SUCCESS );
1698 return 0;
1699
1700 case SO_ERROR:
1701 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_ERROR, optval, optlen );
1702
1703 case SO_KEEPALIVE:
1704 if (*optlen < 1 || !optval)
1705 {
1706 SetLastError( WSAEFAULT );
1707 return SOCKET_ERROR;
1708 }
1709 *optlen = 1;
1710 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_KEEPALIVE, optval, optlen );
1711
1712 case SO_LINGER:
1713 {
1714 WSAPROTOCOL_INFOW info;
1715 int size;
1716
1717 /* struct linger and LINGER have different sizes */
1718 if (*optlen < sizeof(LINGER) || !optval)
1719 {
1720 if (optval) memset( optval, 0, *optlen );
1721 SetLastError( WSAEFAULT );
1722 return SOCKET_ERROR;
1723 }
1724
1725 if (!ws_protocol_info( s, TRUE, &info, &size ))
1726 return -1;
1727
1728 if (info.iSocketType == SOCK_DGRAM)
1729 {
1730 SetLastError( WSAENOPROTOOPT );
1731 return -1;
1732 }
1733
1734 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_LINGER, optval, optlen );
1735 }
1736
1737 case SO_MAX_MSG_SIZE:
1738 if (*optlen < sizeof(int) || !optval)
1739 {
1740 SetLastError(WSAEFAULT);
1741 return SOCKET_ERROR;
1742 }
1743 TRACE("getting global SO_MAX_MSG_SIZE = 65507\n");
1744 *(int *)optval = 65507;
1745 *optlen = sizeof(int);
1746 return 0;
1747
1748 case SO_OOBINLINE:
1749 ret = server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_OOBINLINE, optval, optlen );
1750 if (!ret && *optlen < sizeof(DWORD)) *optlen = 1;
1751 return ret;
1752
1753 /* SO_OPENTYPE does not require a valid socket handle. */
1754 case SO_OPENTYPE:
1755 if (!optlen || *optlen < sizeof(int) || !optval)
1756 {
1757 SetLastError( WSAEFAULT );
1758 return SOCKET_ERROR;
1759 }
1760 *(int *)optval = get_per_thread_data()->opentype;
1761 *optlen = sizeof(int);
1762 TRACE("getting global SO_OPENTYPE = 0x%x\n", *((int*)optval) );
1763 SetLastError( ERROR_SUCCESS );
1764 return 0;
1765
1766 case SO_PROTOCOL_INFOA:
1767 case SO_PROTOCOL_INFOW:
1768 {
1769 int size;
1770 WSAPROTOCOL_INFOW infow;
1771
1772 ret = ws_protocol_info(s, optname == SO_PROTOCOL_INFOW, &infow, &size);
1773 if (ret)
1774 {
1775 if (!optval || *optlen < size)
1776 {
1777 *optlen = size;
1778 ret = 0;
1779 SetLastError(WSAEFAULT);
1780 }
1781 else
1782 memcpy(optval, &infow, size);
1783 }
1784 return ret ? 0 : SOCKET_ERROR;
1785 }
1786
1787 case SO_RCVBUF:
1788 if (*optlen < sizeof(DWORD) || !optval)
1789 {
1790 if (optval) memset( optval, 0, *optlen );
1791 SetLastError( WSAEFAULT );
1792 return SOCKET_ERROR;
1793 }
1794 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_RCVBUF, optval, optlen );
1795
1796 case SO_RCVTIMEO:
1797 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_RCVTIMEO, optval, optlen );
1798
1799 case SO_REUSEADDR:
1800 ret = server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_REUSEADDR, optval, optlen );
1801 if (!ret && *optlen < sizeof(DWORD)) *optlen = 1;
1802 return ret;
1803
1804 case SO_SNDBUF:
1805 if (*optlen < sizeof(DWORD) || !optval)
1806 {
1807 if (optval) memset( optval, 0, *optlen );
1808 SetLastError( WSAEFAULT );
1809 return SOCKET_ERROR;
1810 }
1811 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_SNDBUF, optval, optlen );
1812
1813 case SO_SNDTIMEO:
1814 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_SNDTIMEO, optval, optlen );
1815
1816 case SO_TYPE:
1817 {
1818 WSAPROTOCOL_INFOW info;
1819 int size;
1820
1821 if (*optlen < sizeof(int) || !optval)
1822 {
1823 SetLastError(WSAEFAULT);
1824 return SOCKET_ERROR;
1825 }
1826
1827 if (!ws_protocol_info( s, TRUE, &info, &size ))
1828 return -1;
1829
1830 *(int *)optval = info.iSocketType;
1831 return 0;
1832 }
1833
1834 default:
1835 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
1836 SetLastError(WSAENOPROTOOPT);
1837 return SOCKET_ERROR;
1838 } /* end switch(optname) */
1839 }/* end case SOL_SOCKET */
1840
1841 case NSPROTO_IPX:
1842 {
1843 struct sockaddr_ipx addr;
1844 IPX_ADDRESS_DATA *data;
1845 int namelen;
1846 switch(optname)
1847 {
1848 case IPX_ADDRESS:
1849 /*
1850 * On a Win2000 system with one network card there are usually
1851 * three ipx devices one with a speed of 28.8kbps, 10Mbps and 100Mbps.
1852 * Using this call you can then retrieve info about this all.
1853 * In case of Linux it is a bit different. Usually you have
1854 * only "one" device active and further it is not possible to
1855 * query things like the linkspeed.
1856 */
1857 FIXME("IPX_ADDRESS\n");
1858 namelen = sizeof(struct sockaddr_ipx);
1859 memset( &addr, 0, sizeof(struct sockaddr_ipx) );
1860 getsockname( s, (struct sockaddr *)&addr, &namelen );
1861
1862 data = (IPX_ADDRESS_DATA*)optval;
1863 memcpy(data->nodenum,addr.sa_nodenum,sizeof(data->nodenum));
1864 memcpy(data->netnum,addr.sa_netnum,sizeof(data->netnum));
1865 data->adapternum = 0;
1866 data->wan = FALSE; /* We are not on a wan for now .. */
1867 data->status = FALSE; /* Since we are not on a wan, the wan link isn't up */
1868 data->maxpkt = 1467; /* This value is the default one, at least on Win2k/WinXP */
1869 data->linkspeed = 100000; /* Set the line speed in 100bit/s to 10 Mbit;
1870 * note 1MB = 1000kB in this case */
1871 return 0;
1872
1873 case IPX_MAX_ADAPTER_NUM:
1874 FIXME("IPX_MAX_ADAPTER_NUM\n");
1875 *(int*)optval = 1; /* As noted under IPX_ADDRESS we have just one card. */
1876 return 0;
1877
1878 case IPX_PTYPE:
1879 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPX_PTYPE, optval, optlen );
1880
1881 default:
1882 FIXME("IPX optname:%x\n", optname);
1883 return SOCKET_ERROR;
1884 }/* end switch(optname) */
1885 } /* end case NSPROTO_IPX */
1886
1887 case SOL_IRLMP:
1888 switch(optname)
1889 {
1890 case IRLMP_ENUMDEVICES:
1891 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IRLMP_ENUMDEVICES, optval, optlen );
1892
1893 default:
1894 FIXME("IrDA optname:0x%x\n", optname);
1895 return SOCKET_ERROR;
1896 }
1897 break; /* case SOL_IRLMP */
1898
1899 /* Levels IPPROTO_TCP and IPPROTO_IP convert directly */
1900 case IPPROTO_TCP:
1901 switch(optname)
1902 {
1903 case TCP_NODELAY:
1904 if (*optlen < 1 || !optval)
1905 {
1906 SetLastError( WSAEFAULT );
1907 return SOCKET_ERROR;
1908 }
1909 *optlen = 1;
1910 return server_getsockopt( s, IOCTL_AFD_WINE_GET_TCP_NODELAY, optval, optlen );
1911
1912 default:
1913 FIXME( "unrecognized TCP option %#x\n", optname );
1914 SetLastError( WSAENOPROTOOPT );
1915 return -1;
1916 }
1917
1918 case IPPROTO_IP:
1919 switch(optname)
1920 {
1921 case IP_DONTFRAGMENT:
1922 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_DONTFRAGMENT, optval, optlen );
1923
1924 case IP_HDRINCL:
1925 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_HDRINCL, optval, optlen );
1926
1927 case IP_MULTICAST_IF:
1928 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_MULTICAST_IF, optval, optlen );
1929
1930 case IP_MULTICAST_LOOP:
1931 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_MULTICAST_LOOP, optval, optlen );
1932
1933 case IP_MULTICAST_TTL:
1934 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_MULTICAST_TTL, optval, optlen );
1935
1936 case IP_OPTIONS:
1937 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_OPTIONS, optval, optlen );
1938
1939 case IP_PKTINFO:
1940 if (*optlen < sizeof(DWORD) || !optval)
1941 {
1942 *optlen = 0;
1943 SetLastError( WSAEFAULT );
1944 return SOCKET_ERROR;
1945 }
1946 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_PKTINFO, optval, optlen );
1947
1948 case IP_RECVTOS:
1949 if (*optlen < sizeof(DWORD) || !optval)
1950 {
1951 *optlen = 0;
1952 SetLastError( WSAEFAULT );
1953 return SOCKET_ERROR;
1954 }
1955 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_RECVTOS, optval, optlen );
1956
1957 case IP_RECVTTL:
1958 if (*optlen < sizeof(DWORD) || !optval)
1959 {
1960 *optlen = 0;
1961 SetLastError( WSAEFAULT );
1962 return SOCKET_ERROR;
1963 }
1964 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_RECVTTL, optval, optlen );
1965
1966 case IP_TOS:
1967 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_TOS, optval, optlen );
1968
1969 case IP_TTL:
1970 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_TTL, optval, optlen );
1971
1972 case IP_UNICAST_IF:
1973 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_UNICAST_IF, optval, optlen );
1974
1975 default:
1976 FIXME( "unrecognized IP option %u\n", optname );
1977 /* fall through */
1978
1979 case IP_ADD_MEMBERSHIP:
1980 case IP_DROP_MEMBERSHIP:
1981 SetLastError( WSAENOPROTOOPT );
1982 return -1;
1983 }
1984
1985 case IPPROTO_IPV6:
1986 switch(optname)
1987 {
1988 case IPV6_DONTFRAG:
1989 if (*optlen < 1 || !optval)
1990 {
1991 SetLastError( WSAEFAULT );
1992 return SOCKET_ERROR;
1993 }
1994 if (*optlen < sizeof(DWORD)) *optlen = 1;
1995 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_DONTFRAG, optval, optlen );
1996
1997 case IPV6_HOPLIMIT:
1998 if (*optlen < sizeof(DWORD) || !optval)
1999 {
2000 *optlen = 0;
2001 SetLastError( WSAEFAULT );
2002 return SOCKET_ERROR;
2003 }
2004 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_RECVHOPLIMIT, optval, optlen );
2005
2006 case IPV6_MULTICAST_HOPS:
2007 if (*optlen < 1 || !optval)
2008 {
2009 SetLastError( WSAEFAULT );
2010 return SOCKET_ERROR;
2011 }
2012 if (*optlen < sizeof(DWORD)) *optlen = 1;
2013 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_MULTICAST_HOPS, optval, optlen );
2014
2015 case IPV6_MULTICAST_IF:
2016 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_MULTICAST_IF, optval, optlen );
2017
2018 case IPV6_MULTICAST_LOOP:
2019 if (*optlen < 1 || !optval)
2020 {
2021 SetLastError( WSAEFAULT );
2022 return SOCKET_ERROR;
2023 }
2024 if (*optlen < sizeof(DWORD)) *optlen = 1;
2025 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_MULTICAST_LOOP, optval, optlen );
2026
2027 case IPV6_PROTECTION_LEVEL:
2028 if (*optlen < sizeof(UINT) || !optval)
2029 {
2030 SetLastError( WSAEFAULT );
2031 return -1;
2032 }
2033 *optlen = sizeof(UINT);
2034 *optval = PROTECTION_LEVEL_UNRESTRICTED;
2035 FIXME("IPV6_PROTECTION_LEVEL is ignored!\n");
2036 return 0;
2037
2038 case IPV6_PKTINFO:
2039 if (*optlen < sizeof(DWORD) || !optval)
2040 {
2041 *optlen = 0;
2042 SetLastError( WSAEFAULT );
2043 return SOCKET_ERROR;
2044 }
2045 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_RECVPKTINFO, optval, optlen );
2046
2047 case IPV6_RECVTCLASS:
2048 if (*optlen < sizeof(DWORD) || !optval)
2049 {
2050 if (optlen) *optlen = 0;
2051 SetLastError( WSAEFAULT );
2052 return SOCKET_ERROR;
2053 }
2054 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_RECVTCLASS, optval, optlen );
2055
2056 case IPV6_UNICAST_HOPS:
2057 if (*optlen < 1 || !optval)
2058 {
2059 SetLastError( WSAEFAULT );
2060 return SOCKET_ERROR;
2061 }
2062 if (*optlen < sizeof(DWORD)) *optlen = 1;
2063 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_UNICAST_HOPS, optval, optlen );
2064
2065 case IPV6_UNICAST_IF:
2066 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_UNICAST_IF, optval, optlen );
2067
2068 case IPV6_V6ONLY:
2069 if (*optlen < 1 || !optval)
2070 {
2071 SetLastError( WSAEFAULT );
2072 return SOCKET_ERROR;
2073 }
2074 *optlen = 1;
2075 return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_V6ONLY, optval, optlen );
2076
2077 default:
2078 FIXME( "unrecognized IPv6 option %u\n", optname );
2079 /* fall through */
2080
2081 case IPV6_ADD_MEMBERSHIP:
2082 case IPV6_DROP_MEMBERSHIP:
2083 SetLastError( WSAENOPROTOOPT );
2084 return -1;
2085 }
2086
2087 default:
2088 WARN("Unknown level: 0x%08x\n", level);
2089 SetLastError(WSAEINVAL);
2090 return SOCKET_ERROR;
2091 } /* end switch(level) */
2092 }
2093
2094
2095 static const char *debugstr_wsaioctl(DWORD code)
2096 {
2097 const char *buf_type, *family;
2098
2099 #define IOCTL_NAME(x) case x: return #x
2100 switch (code)
2101 {
2102 IOCTL_NAME(FIONBIO);
2103 IOCTL_NAME(FIONREAD);
2104 IOCTL_NAME(SIOCATMARK);
2105 /* IOCTL_NAME(SIO_ACQUIRE_PORT_RESERVATION); */
2106 IOCTL_NAME(SIO_ADDRESS_LIST_CHANGE);
2107 IOCTL_NAME(SIO_ADDRESS_LIST_QUERY);
2108 IOCTL_NAME(SIO_ASSOCIATE_HANDLE);
2109 /* IOCTL_NAME(SIO_ASSOCIATE_PORT_RESERVATION);
2110 IOCTL_NAME(SIO_BASE_HANDLE);
2111 IOCTL_NAME(SIO_BSP_HANDLE);
2112 IOCTL_NAME(SIO_BSP_HANDLE_SELECT);
2113 IOCTL_NAME(SIO_BSP_HANDLE_POLL);
2114 IOCTL_NAME(SIO_CHK_QOS); */
2115 IOCTL_NAME(SIO_ENABLE_CIRCULAR_QUEUEING);
2116 IOCTL_NAME(SIO_FIND_ROUTE);
2117 IOCTL_NAME(SIO_FLUSH);
2118 IOCTL_NAME(SIO_GET_BROADCAST_ADDRESS);
2119 IOCTL_NAME(SIO_GET_EXTENSION_FUNCTION_POINTER);
2120 IOCTL_NAME(SIO_GET_GROUP_QOS);
2121 IOCTL_NAME(SIO_GET_INTERFACE_LIST);
2122 /* IOCTL_NAME(SIO_GET_INTERFACE_LIST_EX); */
2123 IOCTL_NAME(SIO_GET_QOS);
2124 IOCTL_NAME(SIO_IDEAL_SEND_BACKLOG_CHANGE);
2125 IOCTL_NAME(SIO_IDEAL_SEND_BACKLOG_QUERY);
2126 IOCTL_NAME(SIO_KEEPALIVE_VALS);
2127 IOCTL_NAME(SIO_MULTIPOINT_LOOPBACK);
2128 IOCTL_NAME(SIO_MULTICAST_SCOPE);
2129 /* IOCTL_NAME(SIO_QUERY_RSS_SCALABILITY_INFO);
2130 IOCTL_NAME(SIO_QUERY_WFP_ALE_ENDPOINT_HANDLE); */
2131 IOCTL_NAME(SIO_RCVALL);
2132 IOCTL_NAME(SIO_RCVALL_IGMPMCAST);
2133 IOCTL_NAME(SIO_RCVALL_MCAST);
2134 /* IOCTL_NAME(SIO_RELEASE_PORT_RESERVATION); */
2135 IOCTL_NAME(SIO_ROUTING_INTERFACE_CHANGE);
2136 IOCTL_NAME(SIO_ROUTING_INTERFACE_QUERY);
2137 IOCTL_NAME(SIO_SET_COMPATIBILITY_MODE);
2138 IOCTL_NAME(SIO_SET_GROUP_QOS);
2139 IOCTL_NAME(SIO_SET_QOS);
2140 IOCTL_NAME(SIO_TRANSLATE_HANDLE);
2141 IOCTL_NAME(SIO_UDP_CONNRESET);
2142 }
2143 #undef IOCTL_NAME
2144
2145 /* If this is not a known code split its bits */
2146 switch(code & 0x18000000)
2147 {
2148 case IOC_WS2:
2149 family = "IOC_WS2";
2150 break;
2151 case IOC_PROTOCOL:
2152 family = "IOC_PROTOCOL";
2153 break;
2154 case IOC_VENDOR:
2155 family = "IOC_VENDOR";
2156 break;
2157 default: /* IOC_UNIX */
2158 {
2159 BYTE size = (code >> 16) & IOCPARM_MASK;
2160 char x = (code & 0xff00) >> 8;
2161 BYTE y = code & 0xff;
2162 char args[14];
2163
2164 switch (code & (IOC_VOID | IOC_INOUT))
2165 {
2166 case IOC_VOID:
2167 buf_type = "_IO";
2168 sprintf(args, "%d, %d", x, y);
2169 break;
2170 case IOC_IN:
2171 buf_type = "_IOW";
2172 sprintf(args, "'%c', %d, %d", x, y, size);
2173 break;
2174 case IOC_OUT:
2175 buf_type = "_IOR";
2176 sprintf(args, "'%c', %d, %d", x, y, size);
2177 break;
2178 default:
2179 buf_type = "?";
2180 sprintf(args, "'%c', %d, %d", x, y, size);
2181 break;
2182 }
2183 return wine_dbg_sprintf("%s(%s)", buf_type, args);
2184 }
2185 }
2186
2187 /* We are different from IOC_UNIX. */
2188 switch (code & (IOC_VOID | IOC_INOUT))
2189 {
2190 case IOC_VOID:
2191 buf_type = "_WSAIO";
2192 break;
2193 case IOC_INOUT:
2194 buf_type = "_WSAIORW";
2195 break;
2196 case IOC_IN:
2197 buf_type = "_WSAIOW";
2198 break;
2199 case IOC_OUT:
2200 buf_type = "_WSAIOR";
2201 break;
2202 default:
2203 buf_type = "?";
2204 break;
2205 }
2206
2207 return wine_dbg_sprintf("%s(%s, %d)", buf_type, family,
2208 (USHORT)(code & 0xffff));
2209 }
2210
2211 /* do an ioctl call through the server */
2212 static DWORD server_ioctl_sock( SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size,
2213 LPVOID out_buff, DWORD out_size, LPDWORD ret_size,
2214 LPWSAOVERLAPPED overlapped,
2215 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
2216 {
2217 IO_STATUS_BLOCK iosb, *piosb = &iosb;
2218 HANDLE handle = SOCKET2HANDLE( s );
2219 PIO_APC_ROUTINE apc = NULL;
2220 HANDLE event = NULL;
2221 void *cvalue = NULL;
2222 NTSTATUS status;
2223
2224 if (overlapped)
2225 {
2226 piosb = (IO_STATUS_BLOCK *)overlapped;
2227 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
2228 event = overlapped->hEvent;
2229 }
2230 else
2231 {
2232 if (!(event = get_sync_event())) return GetLastError();
2233 }
2234
2235 if (completion)
2236 {
2237 event = NULL;
2238 cvalue = completion;
2239 apc = socket_apc;
2240 }
2241
2242 status = NtDeviceIoControlFile( handle, event, apc, cvalue, piosb, code,
2243 in_buff, in_size, out_buff, out_size );
2244 if (status == STATUS_PENDING && !overlapped)
2245 {
2246 if (WaitForSingleObject( event, INFINITE ) == WAIT_FAILED)
2247 return -1;
2248 status = piosb->u.Status;
2249 }
2250 if (status == STATUS_NOT_SUPPORTED)
2251 {
2252 FIXME("Unsupported ioctl %#lx (device=%#lx access=%#lx func=%#lx method=%#lx)\n",
2253 code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
2254 }
2255 else if (status == STATUS_SUCCESS)
2256 *ret_size = piosb->Information;
2257
2258 TRACE( "status %#lx.\n", status );
2259 return NtStatusToWSAError( status );
2260 }
2261
2262
2263 /**********************************************************************
2264 * WSAIoctl (WS2_32.50)
2265 *
2266 */
2267 INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID out_buff,
2268 DWORD out_size, LPDWORD ret_size, LPWSAOVERLAPPED overlapped,
2269 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
2270 {
2271 TRACE( "socket %#Ix, %s, in_buff %p, in_size %#lx, out_buff %p,"
2272 " out_size %#lx, ret_size %p, overlapped %p, completion %p\n",
2273 s, debugstr_wsaioctl(code), in_buff, in_size, out_buff,
2274 out_size, ret_size, overlapped, completion );
2275
2276 if (!ret_size)
2277 {
2278 SetLastError( WSAEFAULT );
2279 return -1;
2280 }
2281
2282 switch (code)
2283 {
2284 case FIONBIO:
2285 {
2286 DWORD ret;
2287
2288 if (IS_INTRESOURCE( in_buff ))
2289 {
2290 SetLastError( WSAEFAULT );
2291 return -1;
2292 }
2293
2294 /* Explicitly ignore the output buffer; WeChat tries to pass an address
2295 * without write access. */
2296 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_FIONBIO, in_buff, in_size,
2297 NULL, 0, ret_size, overlapped, completion );
2298 SetLastError( ret );
2299 return ret ? -1 : 0;
2300 }
2301
2302 case FIONREAD:
2303 {
2304 DWORD ret;
2305
2306 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_FIONREAD, in_buff, in_size,
2307 out_buff, out_size, ret_size, overlapped, completion );
2308 SetLastError( ret );
2309 if (!ret) *ret_size = sizeof(u_long);
2310 return ret ? -1 : 0;
2311 }
2312
2313 case SIOCATMARK:
2314 {
2315 DWORD ret;
2316
2317 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_SIOCATMARK, in_buff, in_size,
2318 out_buff, out_size, ret_size, overlapped, completion );
2319 SetLastError( ret );
2320 if (!ret) *ret_size = sizeof(u_long);
2321 return ret ? -1 : 0;
2322 }
2323
2324 case SIO_GET_INTERFACE_LIST:
2325 {
2326 DWORD ret;
2327
2328 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_GET_INTERFACE_LIST, in_buff, in_size,
2329 out_buff, out_size, ret_size, overlapped, completion );
2330 SetLastError( ret );
2331 if (ret && ret != ERROR_IO_PENDING) *ret_size = 0;
2332 return ret ? -1 : 0;
2333 }
2334
2335 case SIO_ADDRESS_LIST_QUERY:
2336 {
2337 DWORD size, total;
2338
2339 TRACE("-> SIO_ADDRESS_LIST_QUERY request\n");
2340
2341 if (out_size && out_size < FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]))
2342 {
2343 *ret_size = 0;
2344 SetLastError(WSAEINVAL);
2345 return SOCKET_ERROR;
2346 }
2347
2348 if (GetAdaptersInfo(NULL, &size) == ERROR_BUFFER_OVERFLOW)
2349 {
2350 IP_ADAPTER_INFO *p, *table = malloc( size );
2351 NTSTATUS status = STATUS_SUCCESS;
2352 SOCKET_ADDRESS_LIST *sa_list;
2353 SOCKADDR_IN *sockaddr;
2354 SOCKET_ADDRESS *sa;
2355 unsigned int i;
2356 DWORD ret = 0;
2357 DWORD num;
2358
2359 if (!table || GetAdaptersInfo(table, &size))
2360 {
2361 free( table );
2362 SetLastError( WSAEINVAL );
2363 return -1;
2364 }
2365
2366 for (p = table, num = 0; p; p = p->Next)
2367 if (p->IpAddressList.IpAddress.String[0]) num++;
2368
2369 total = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[num]) + num * sizeof(*sockaddr);
2370 if (total > out_size || !out_buff)
2371 {
2372 *ret_size = total;
2373 free( table );
2374 SetLastError( WSAEFAULT );
2375 return -1;
2376 }
2377
2378 sa_list = out_buff;
2379 sa = sa_list->Address;
2380 sockaddr = (SOCKADDR_IN *)&sa[num];
2381 sa_list->iAddressCount = num;
2382
2383 for (p = table, i = 0; p; p = p->Next)
2384 {
2385 if (!p->IpAddressList.IpAddress.String[0]) continue;
2386
2387 sa[i].lpSockaddr = (SOCKADDR *)&sockaddr[i];
2388 sa[i].iSockaddrLength = sizeof(SOCKADDR);
2389
2390 sockaddr[i].sin_family = AF_INET;
2391 sockaddr[i].sin_port = 0;
2392 sockaddr[i].sin_addr.s_addr = inet_addr( p->IpAddressList.IpAddress.String );
2393 i++;
2394 }
2395
2396 free( table );
2397
2398 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2399 NULL, 0, ret_size, overlapped, completion );
2400 *ret_size = total;
2401 SetLastError( ret );
2402 return ret ? -1 : 0;
2403 }
2404 else
2405 {
2406 WARN("unable to get IP address list\n");
2407 SetLastError( WSAEINVAL );
2408 return -1;
2409 }
2410 }
2411
2412 case SIO_GET_EXTENSION_FUNCTION_POINTER:
2413 {
2414 #define EXTENSION_FUNCTION(x, y) { x, y, #y },
2415 static const struct
2416 {
2417 GUID guid;
2418 void *func_ptr;
2419 const char *name;
2420 } guid_funcs[] = {
2421 EXTENSION_FUNCTION(WSAID_CONNECTEX, WS2_ConnectEx)
2422 EXTENSION_FUNCTION(WSAID_DISCONNECTEX, WS2_DisconnectEx)
2423 EXTENSION_FUNCTION(WSAID_ACCEPTEX, WS2_AcceptEx)
2424 EXTENSION_FUNCTION(WSAID_GETACCEPTEXSOCKADDRS, WS2_GetAcceptExSockaddrs)
2425 EXTENSION_FUNCTION(WSAID_TRANSMITFILE, WS2_TransmitFile)
2426 /* EXTENSION_FUNCTION(WSAID_TRANSMITPACKETS, WS2_TransmitPackets) */
2427 EXTENSION_FUNCTION(WSAID_WSARECVMSG, WS2_WSARecvMsg)
2428 EXTENSION_FUNCTION(WSAID_WSASENDMSG, WSASendMsg)
2429 };
2430 #undef EXTENSION_FUNCTION
2431 unsigned int i;
2432
2433 for (i = 0; i < ARRAY_SIZE(guid_funcs); i++)
2434 {
2435 if (IsEqualGUID(&guid_funcs[i].guid, in_buff))
2436 {
2437 NTSTATUS status = STATUS_SUCCESS;
2438 DWORD ret = 0;
2439
2440 TRACE( "returning %s\n", guid_funcs[i].name );
2441 *(void **)out_buff = guid_funcs[i].func_ptr;
2442
2443 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2444 NULL, 0, ret_size, overlapped, completion );
2445 *ret_size = sizeof(void *);
2446 SetLastError( ret );
2447 return ret ? -1 : 0;
2448 }
2449 }
2450
2451 FIXME("SIO_GET_EXTENSION_FUNCTION_POINTER %s: stub\n", debugstr_guid(in_buff));
2452 SetLastError( WSAEINVAL );
2453 return -1;
2454 }
2455
2456 case SIO_KEEPALIVE_VALS:
2457 {
2458 DWORD ret;
2459
2460 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_KEEPALIVE_VALS, in_buff, in_size,
2461 out_buff, out_size, ret_size, overlapped, completion );
2462 if (!overlapped || completion) *ret_size = 0;
2463 SetLastError( ret );
2464 return ret ? -1 : 0;
2465 }
2466
2467 case SIO_ROUTING_INTERFACE_QUERY:
2468 {
2469 struct sockaddr *daddr = (struct sockaddr *)in_buff;
2470 struct sockaddr_in *daddr_in = (struct sockaddr_in *)daddr;
2471 struct sockaddr_in *saddr_in = out_buff;
2472 MIB_IPFORWARDROW row;
2473 PMIB_IPADDRTABLE ipAddrTable = NULL;
2474 DWORD size, i, found_index, ret = 0;
2475 NTSTATUS status = STATUS_SUCCESS;
2476
2477 if (!in_buff || in_size < sizeof(struct sockaddr) ||
2478 !out_buff || out_size < sizeof(struct sockaddr_in))
2479 {
2480 SetLastError( WSAEFAULT );
2481 return -1;
2482 }
2483 if (daddr->sa_family != AF_INET)
2484 {
2485 FIXME("unsupported address family %d\n", daddr->sa_family);
2486 SetLastError( WSAEAFNOSUPPORT );
2487 return -1;
2488 }
2489 if (GetBestRoute( daddr_in->sin_addr.S_un.S_addr, 0, &row ) != NOERROR ||
2490 GetIpAddrTable( NULL, &size, FALSE ) != ERROR_INSUFFICIENT_BUFFER)
2491 {
2492 SetLastError( WSAEFAULT );
2493 return -1;
2494 }
2495 ipAddrTable = malloc( size );
2496 if (GetIpAddrTable( ipAddrTable, &size, FALSE ))
2497 {
2498 free( ipAddrTable );
2499 SetLastError( WSAEFAULT );
2500 return -1;
2501 }
2502 for (i = 0, found_index = ipAddrTable->dwNumEntries;
2503 i < ipAddrTable->dwNumEntries; i++)
2504 {
2505 if (ipAddrTable->table[i].dwIndex == row.dwForwardIfIndex)
2506 found_index = i;
2507 }
2508 if (found_index == ipAddrTable->dwNumEntries)
2509 {
2510 ERR( "no matching IP address for interface %lu\n", row.dwForwardIfIndex );
2511 free( ipAddrTable );
2512 SetLastError( WSAEFAULT );
2513 return -1;
2514 }
2515 saddr_in->sin_family = AF_INET;
2516 saddr_in->sin_addr.S_un.S_addr = ipAddrTable->table[found_index].dwAddr;
2517 saddr_in->sin_port = 0;
2518 free( ipAddrTable );
2519
2520 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2521 NULL, 0, ret_size, overlapped, completion );
2522 if (!ret) *ret_size = sizeof(struct sockaddr_in);
2523 SetLastError( ret );
2524 return ret ? -1 : 0;
2525 }
2526
2527 case SIO_ADDRESS_LIST_CHANGE:
2528 {
2529 int force_async = !!overlapped;
2530 DWORD ret;
2531
2532 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_ADDRESS_LIST_CHANGE, &force_async, sizeof(force_async),
2533 out_buff, out_size, ret_size, overlapped, completion );
2534 SetLastError( ret );
2535 return ret ? -1 : 0;
2536 }
2537
2538 case SIO_UDP_CONNRESET:
2539 {
2540 NTSTATUS status = STATUS_SUCCESS;
2541 DWORD ret;
2542
2543 FIXME( "SIO_UDP_CONNRESET stub\n" );
2544 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2545 NULL, 0, ret_size, overlapped, completion );
2546 SetLastError( ret );
2547 return ret ? -1 : 0;
2548 }
2549
2550 case SIO_ENABLE_CIRCULAR_QUEUEING:
2551 {
2552 NTSTATUS status = STATUS_SUCCESS;
2553 DWORD ret;
2554
2555 FIXME( "SIO_ENABLE_CIRCULAR_QUEUEING stub\n" );
2556 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2557 NULL, 0, ret_size, overlapped, completion );
2558 SetLastError( ret );
2559 return ret ? -1 : 0;
2560 }
2561
2562 case SIO_BASE_HANDLE:
2563 {
2564 NTSTATUS status;
2565 DWORD ret;
2566
2567 if (overlapped)
2568 {
2569 status = STATUS_NOT_SUPPORTED;
2570 }
2571 else
2572 {
2573 status = STATUS_SUCCESS;
2574 *(SOCKET *)out_buff = s;
2575 }
2576 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2577 NULL, 0, ret_size, overlapped, completion );
2578 if (overlapped) ret = ERROR_IO_PENDING;
2579 if (!ret) *ret_size = sizeof(SOCKET);
2580 SetLastError( ret );
2581 return ret ? -1 : 0;
2582 }
2583
2584 default:
2585 FIXME( "unimplemented ioctl %s\n", debugstr_wsaioctl( code ) );
2586 /* fall through */
2587 case LOWORD(FIONBIO): /* Netscape tries to use this */
2588 case SIO_SET_COMPATIBILITY_MODE:
2589 {
2590 NTSTATUS status = STATUS_NOT_SUPPORTED;
2591
2592 server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2593 NULL, 0, ret_size, overlapped, completion );
2594 if (overlapped)
2595 {
2596 SetLastError( ERROR_IO_PENDING );
2597 }
2598 else
2599 {
2600 *ret_size = 0;
2601 SetLastError( WSAEOPNOTSUPP );
2602 }
2603 return -1;
2604 }
2605 }
2606 }
2607
2608
2609 /***********************************************************************
2610 * ioctlsocket (WS2_32.10)
2611 */
2612 int WINAPI ioctlsocket( SOCKET s, LONG cmd, u_long *argp )
2613 {
2614 DWORD ret_size;
2615 return WSAIoctl( s, cmd, argp, sizeof(u_long), argp, sizeof(u_long), &ret_size, NULL, NULL );
2616 }
2617
2618
2619 /***********************************************************************
2620 * listen (ws2_32.13)
2621 */
2622 int WINAPI listen( SOCKET s, int backlog )
2623 {
2624 struct afd_listen_params params = {.backlog = backlog};
2625 IO_STATUS_BLOCK io;
2626 NTSTATUS status;
2627
2628 TRACE( "socket %#Ix, backlog %d\n", s, backlog );
2629
2630 status = NtDeviceIoControlFile( SOCKET2HANDLE(s), NULL, NULL, NULL, &io,
2631 IOCTL_AFD_LISTEN, &params, sizeof(params), NULL, 0 );
2632 SetLastError( NtStatusToWSAError( status ) );
2633 TRACE( "status %#lx.\n", status );
2634 return status ? -1 : 0;
2635 }
2636
2637
2638 /***********************************************************************
2639 * recv (WS2_32.16)
2640 */
2641 int WINAPI recv( SOCKET s, char *buf, int len, int flags )
2642 {
2643 DWORD n, dwFlags = flags;
2644 WSABUF wsabuf;
2645
2646 wsabuf.len = len;
2647 wsabuf.buf = buf;
2648
2649 if ( WS2_recv_base(s, &wsabuf, 1, &n, &dwFlags, NULL, NULL, NULL, NULL, NULL) == SOCKET_ERROR )
2650 return SOCKET_ERROR;
2651 else
2652 return n;
2653 }
2654
2655 /***********************************************************************
2656 * recvfrom (WS2_32.17)
2657 */
2658 int WINAPI recvfrom( SOCKET s, char *buf, int len, int flags, struct sockaddr *from, int *fromlen )
2659 {
2660 DWORD n, dwFlags = flags;
2661 WSABUF wsabuf;
2662
2663 wsabuf.len = len;
2664 wsabuf.buf = buf;
2665
2666 if ( WS2_recv_base(s, &wsabuf, 1, &n, &dwFlags, from, fromlen, NULL, NULL, NULL) == SOCKET_ERROR )
2667 return SOCKET_ERROR;
2668 else
2669 return n;
2670 }
2671
2672
2673 /* as FD_SET(), but returns 1 if the fd was added, 0 otherwise */
2674 static int add_fd_to_set( SOCKET fd, struct fd_set *set )
2675 {
2676 unsigned int i;
2677
2678 for (i = 0; i < set->fd_count; ++i)
2679 {
2680 if (set->fd_array[i] == fd)
2681 return 0;
2682 }
2683
2684 set->fd_array[set->fd_count++] = fd;
2685 return 1;
2686 }
2687
2688
2689 /***********************************************************************
2690 * select (ws2_32.18)
2691 */
2692 int WINAPI select( int count, fd_set *read_ptr, fd_set *write_ptr,
2693 fd_set *except_ptr, const struct timeval *timeout)
2694 {
2695 struct fd_set *read_input = NULL;
2696 struct afd_poll_params *params;
2697 unsigned int poll_count = 0;
2698 ULONG params_size, i, j;
2699 SOCKET poll_socket = 0;
2700 IO_STATUS_BLOCK io;
2701 HANDLE sync_event;
2702 int ret_count = 0;
2703 NTSTATUS status;
2704
2705 TRACE( "read %p, write %p, except %p, timeout %p\n", read_ptr, write_ptr, except_ptr, timeout );
2706
2707 if (!(sync_event = get_sync_event())) return -1;
2708
2709 if (read_ptr) poll_count += read_ptr->fd_count;
2710 if (write_ptr) poll_count += write_ptr->fd_count;
2711 if (except_ptr) poll_count += except_ptr->fd_count;
2712
2713 if (!poll_count)
2714 {
2715 SetLastError( WSAEINVAL );
2716 return -1;
2717 }
2718
2719 params_size = offsetof( struct afd_poll_params, sockets[poll_count] );
2720 if (!(params = calloc( params_size, 1 )))
2721 {
2722 SetLastError( WSAENOBUFS );
2723 return -1;
2724 }
2725
2726 if (timeout)
2727 params->timeout = (LONGLONG)timeout->tv_sec * -10000000 + (LONGLONG)timeout->tv_usec * -10;
2728 else
2729 params->timeout = TIMEOUT_INFINITE;
2730
2731 if (read_ptr)
2732 {
2733 unsigned int read_size = offsetof( struct fd_set, fd_array[read_ptr->fd_count] );
2734
2735 if (!(read_input = malloc( read_size )))
2736 {
2737 free( params );
2738 SetLastError( WSAENOBUFS );
2739 return -1;
2740 }
2741 memcpy( read_input, read_ptr, read_size );
2742
2743 for (i = 0; i < read_ptr->fd_count; ++i)
2744 {
2745 params->sockets[params->count].socket = read_ptr->fd_array[i];
2746 params->sockets[params->count].flags = AFD_POLL_READ | AFD_POLL_ACCEPT | AFD_POLL_HUP;
2747 ++params->count;
2748 poll_socket = read_ptr->fd_array[i];
2749 }
2750 }
2751
2752 if (write_ptr)
2753 {
2754 for (i = 0; i < write_ptr->fd_count; ++i)
2755 {
2756 params->sockets[params->count].socket = write_ptr->fd_array[i];
2757 params->sockets[params->count].flags = AFD_POLL_WRITE;
2758 ++params->count;
2759 poll_socket = write_ptr->fd_array[i];
2760 }
2761 }
2762
2763 if (except_ptr)
2764 {
2765 for (i = 0; i < except_ptr->fd_count; ++i)
2766 {
2767 params->sockets[params->count].socket = except_ptr->fd_array[i];
2768 params->sockets[params->count].flags = AFD_POLL_OOB | AFD_POLL_CONNECT_ERR;
2769 ++params->count;
2770 poll_socket = except_ptr->fd_array[i];
2771 }
2772 }
2773
2774 assert( params->count == poll_count );
2775
2776 status = NtDeviceIoControlFile( (HANDLE)poll_socket, sync_event, NULL, NULL, &io,
2777 IOCTL_AFD_POLL, params, params_size, params, params_size );
2778 if (status == STATUS_PENDING)
2779 {
2780 if (wait_event_alertable( sync_event ) == WAIT_FAILED)
2781 {
2782 free( read_input );
2783 free( params );
2784 return -1;
2785 }
2786 status = io.u.Status;
2787 }
2788 if (status == STATUS_TIMEOUT) status = STATUS_SUCCESS;
2789 if (!status)
2790 {
2791 /* pointers may alias, so clear them all first */
2792 if (read_ptr) read_ptr->fd_count = 0;
2793 if (write_ptr) write_ptr->fd_count = 0;
2794 if (except_ptr) except_ptr->fd_count = 0;
2795
2796 for (i = 0; i < params->count; ++i)
2797 {
2798 unsigned int flags = params->sockets[i].flags;
2799 SOCKET s = params->sockets[i].socket;
2800
2801 if (read_input)
2802 {
2803 for (j = 0; j < read_input->fd_count; ++j)
2804 {
2805 if (read_input->fd_array[j] == s
2806 && (flags & (AFD_POLL_READ | AFD_POLL_ACCEPT | AFD_POLL_HUP | AFD_POLL_CLOSE)))
2807 {
2808 ret_count += add_fd_to_set( s, read_ptr );
2809 flags &= ~AFD_POLL_CLOSE;
2810 }
2811 }
2812 }
2813
2814 if (flags & AFD_POLL_CLOSE)
2815 status = STATUS_INVALID_HANDLE;
2816
2817 if (flags & AFD_POLL_WRITE)
2818 ret_count += add_fd_to_set( s, write_ptr );
2819
2820 if (flags & (AFD_POLL_OOB | AFD_POLL_CONNECT_ERR))
2821 ret_count += add_fd_to_set( s, except_ptr );
2822 }
2823 }
2824
2825 free( read_input );
2826 free( params );
2827
2828 SetLastError( NtStatusToWSAError( status ) );
2829 TRACE( "status %#lx.\n", status );
2830 return status ? -1 : ret_count;
2831 }
2832
2833
2834 static unsigned int afd_poll_flag_to_win32( unsigned int flags )
2835 {
2836 static const unsigned int map[] =
2837 {
2838 FD_READ, /* READ */
2839 FD_OOB, /* OOB */
2840 FD_WRITE, /* WRITE */
2841 FD_CLOSE, /* HUP */
2842 FD_CLOSE, /* RESET */
2843 0, /* CLOSE */
2844 FD_CONNECT, /* CONNECT */
2845 FD_ACCEPT, /* ACCEPT */
2846 FD_CONNECT, /* CONNECT_ERR */
2847 };
2848
2849 unsigned int i, ret = 0;
2850
2851 for (i = 0; i < ARRAY_SIZE(map); ++i)
2852 {
2853 if (flags & (1 << i)) ret |= map[i];
2854 }
2855
2856 return ret;
2857 }
2858
2859
2860 /***********************************************************************
2861 * WSAPoll (ws2_32.@)
2862 */
2863 int WINAPI WSAPoll( WSAPOLLFD *fds, ULONG count, int timeout )
2864 {
2865 struct afd_poll_params *params;
2866 ULONG params_size, i, j;
2867 SOCKET poll_socket = 0;
2868 IO_STATUS_BLOCK io;
2869 HANDLE sync_event;
2870 int ret_count = 0;
2871 NTSTATUS status;
2872
2873 if (!count)
2874 {
2875 SetLastError(WSAEINVAL);
2876 return SOCKET_ERROR;
2877 }
2878 if (!fds)
2879 {
2880 SetLastError(WSAEFAULT);
2881 return SOCKET_ERROR;
2882 }
2883
2884 if (!(sync_event = get_sync_event())) return -1;
2885
2886 params_size = offsetof( struct afd_poll_params, sockets[count] );
2887 if (!(params = calloc( params_size, 1 )))
2888 {
2889 SetLastError(WSAENOBUFS);
2890 return SOCKET_ERROR;
2891 }
2892
2893 params->timeout = (timeout >= 0 ? (LONGLONG)timeout * -10000 : TIMEOUT_INFINITE);
2894
2895 for (i = 0; i < count; ++i)
2896 {
2897 unsigned int flags = AFD_POLL_HUP | AFD_POLL_RESET | AFD_POLL_CONNECT_ERR;
2898
2899 if ((INT_PTR)fds[i].fd < 0 || !socket_list_find( fds[i].fd ))
2900 {
2901 fds[i].revents = POLLNVAL;
2902 continue;
2903 }
2904
2905 poll_socket = fds[i].fd;
2906 params->sockets[params->count].socket = fds[i].fd;
2907
2908 if (fds[i].events & POLLRDNORM)
2909 flags |= AFD_POLL_ACCEPT | AFD_POLL_READ;
2910 if (fds[i].events & POLLRDBAND)
2911 flags |= AFD_POLL_OOB;
2912 if (fds[i].events & POLLWRNORM)
2913 flags |= AFD_POLL_WRITE;
2914 params->sockets[params->count].flags = flags;
2915 ++params->count;
2916
2917 fds[i].revents = 0;
2918 }
2919
2920 if (!poll_socket)
2921 {
2922 SetLastError( WSAENOTSOCK );
2923 free( params );
2924 return -1;
2925 }
2926
2927 status = NtDeviceIoControlFile( (HANDLE)poll_socket, sync_event, NULL, NULL, &io, IOCTL_AFD_POLL,
2928 params, params_size, params, params_size );
2929 if (status == STATUS_PENDING)
2930 {
2931 if (WaitForSingleObject( sync_event, INFINITE ) == WAIT_FAILED)
2932 {
2933 free( params );
2934 return -1;
2935 }
2936 status = io.u.Status;
2937 }
2938 if (!status)
2939 {
2940 for (i = 0; i < count; ++i)
2941 {
2942 for (j = 0; j < params->count; ++j)
2943 {
2944 if (fds[i].fd == params->sockets[j].socket)
2945 {
2946 unsigned int revents = 0;
2947
2948 if (params->sockets[j].flags & (AFD_POLL_ACCEPT | AFD_POLL_READ))
2949 revents |= POLLRDNORM;
2950 if (params->sockets[j].flags & AFD_POLL_OOB)
2951 revents |= POLLRDBAND;
2952 if (params->sockets[j].flags & AFD_POLL_WRITE)
2953 revents |= POLLWRNORM;
2954 if (params->sockets[j].flags & AFD_POLL_HUP)
2955 revents |= POLLHUP;
2956 if (params->sockets[j].flags & (AFD_POLL_RESET | AFD_POLL_CONNECT_ERR))
2957 revents |= POLLERR;
2958 if (params->sockets[j].flags & AFD_POLL_CLOSE)
2959 revents |= POLLNVAL;
2960
2961 fds[i].revents = revents & (fds[i].events | POLLHUP | POLLERR | POLLNVAL);
2962
2963 if (fds[i].revents)
2964 ++ret_count;
2965 }
2966 }
2967 }
2968 }
2969 if (status == STATUS_TIMEOUT) status = STATUS_SUCCESS;
2970
2971 free( params );
2972
2973 SetLastError( NtStatusToWSAError( status ) );
2974 TRACE( "status %#lx.\n", status );
2975 return status ? -1 : ret_count;
2976 }
2977
2978
2979 /***********************************************************************
2980 * send (WS2_32.19)
2981 */
2982 int WINAPI send( SOCKET s, const char *buf, int len, int flags )
2983 {
2984 DWORD n;
2985 WSABUF wsabuf;
2986
2987 wsabuf.len = len;
2988 wsabuf.buf = (char*) buf;
2989
2990 if ( WS2_sendto( s, &wsabuf, 1, &n, flags, NULL, 0, NULL, NULL) == SOCKET_ERROR )
2991 return SOCKET_ERROR;
2992 else
2993 return n;
2994 }
2995
2996 /***********************************************************************
2997 * WSASend (WS2_32.72)
2998 */
2999 INT WINAPI WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
3000 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
3001 LPWSAOVERLAPPED lpOverlapped,
3002 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
3003 {
3004 return WS2_sendto( s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags,
3005 NULL, 0, lpOverlapped, lpCompletionRoutine );
3006 }
3007
3008 /***********************************************************************
3009 * WSASendDisconnect (WS2_32.73)
3010 */
3011 INT WINAPI WSASendDisconnect( SOCKET s, LPWSABUF lpBuffers )
3012 {
3013 return shutdown( s, SD_SEND );
3014 }
3015
3016
3017 /***********************************************************************
3018 * WSASendTo (WS2_32.74)
3019 */
3020 INT WINAPI WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
3021 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
3022 const struct sockaddr *to, int tolen,
3023 LPWSAOVERLAPPED lpOverlapped,
3024 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
3025 {
3026 /* Garena hooks WSASendTo(), so we need a wrapper */
3027 return WS2_sendto( s, lpBuffers, dwBufferCount,
3028 lpNumberOfBytesSent, dwFlags,
3029 to, tolen,
3030 lpOverlapped, lpCompletionRoutine );
3031 }
3032
3033 /***********************************************************************
3034 * sendto (WS2_32.20)
3035 */
3036 int WINAPI sendto( SOCKET s, const char *buf, int len, int flags, const struct sockaddr *to, int tolen )
3037 {
3038 DWORD n;
3039 WSABUF wsabuf;
3040
3041 wsabuf.len = len;
3042 wsabuf.buf = (char*) buf;
3043
3044 if ( WS2_sendto(s, &wsabuf, 1, &n, flags, to, tolen, NULL, NULL) == SOCKET_ERROR )
3045 return SOCKET_ERROR;
3046 else
3047 return n;
3048 }
3049
3050
3051 static int server_setsockopt( SOCKET s, ULONG code, const char *optval, int optlen )
3052 {
3053 IO_STATUS_BLOCK io;
3054 NTSTATUS status;
3055
3056 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, code, (void *)optval, optlen, NULL, 0 );
3057 SetLastError( NtStatusToWSAError( status ) );
3058 TRACE( "status %#lx.\n", status );
3059 return status ? -1 : 0;
3060 }
3061
3062
3063 /***********************************************************************
3064 * setsockopt (WS2_32.21)
3065 */
3066 int WINAPI setsockopt( SOCKET s, int level, int optname, const char *optval, int optlen )
3067 {
3068 DWORD value = 0;
3069
3070 TRACE( "socket %#Ix, %s, optval %s, optlen %d\n",
3071 s, debugstr_sockopt(level, optname), debugstr_optval(optval, optlen), optlen );
3072
3073 /* some broken apps pass the value directly instead of a pointer to it */
3074 if(optlen && IS_INTRESOURCE(optval))
3075 {
3076 SetLastError(WSAEFAULT);
3077 return SOCKET_ERROR;
3078 }
3079
3080 switch(level)
3081 {
3082 case SOL_SOCKET:
3083 switch(optname)
3084 {
3085 case SO_BROADCAST:
3086 if (!optval)
3087 {
3088 SetLastError( WSAEFAULT );
3089 return SOCKET_ERROR;
3090 }
3091 memcpy( &value, optval, min( optlen, sizeof(value) ));
3092 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_BROADCAST, (char *)&value, sizeof(value) );
3093 case SO_DONTLINGER:
3094 {
3095 LINGER linger;
3096
3097 if (!optval)
3098 {
3099 SetLastError( WSAEFAULT );
3100 return -1;
3101 }
3102
3103 linger.l_onoff = !*(const BOOL *)optval;
3104 linger.l_linger = 0;
3105 return setsockopt( s, SOL_SOCKET, SO_LINGER, (char *)&linger, sizeof(linger) );
3106 }
3107
3108 case SO_ERROR:
3109 FIXME( "SO_ERROR, stub!\n" );
3110 SetLastError( WSAENOPROTOOPT );
3111 return -1;
3112
3113 case SO_KEEPALIVE:
3114 if (optlen <= 0 || !optval)
3115 {
3116 SetLastError( optlen ? WSAENOBUFS : WSAEFAULT );
3117 return SOCKET_ERROR;
3118 }
3119 value = *optval;
3120 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_KEEPALIVE, (char *)&value, sizeof(value) );
3121
3122 case SO_LINGER:
3123 if (optlen < sizeof(LINGER) || !optval)
3124 {
3125 SetLastError( WSAEFAULT );
3126 return SOCKET_ERROR;
3127 }
3128 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_LINGER, optval, optlen );
3129
3130 case SO_OOBINLINE:
3131 if (!optval)
3132 {
3133 SetLastError( WSAEFAULT );
3134 return SOCKET_ERROR;
3135 }
3136 memcpy( &value, optval, min( optlen, sizeof(value) ));
3137 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_OOBINLINE, (char *)&value, sizeof(value) );
3138
3139 case SO_RCVBUF:
3140 if (optlen < 0) optlen = 4;
3141 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_RCVBUF, optval, optlen );
3142
3143 case SO_RCVTIMEO:
3144 if (optlen < 0) optlen = 4;
3145 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_RCVTIMEO, optval, optlen );
3146
3147 case SO_REUSEADDR:
3148 if (!optval)
3149 {
3150 SetLastError( WSAEFAULT );
3151 return SOCKET_ERROR;
3152 }
3153 memcpy( &value, optval, min( optlen, sizeof(value) ));
3154 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_REUSEADDR, (char *)&value, sizeof(value) );
3155
3156 case SO_SNDBUF:
3157 if (optlen < 0) optlen = 4;
3158 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_SNDBUF, optval, optlen );
3159
3160 case SO_SNDTIMEO:
3161 if (optlen < 0) optlen = 4;
3162 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_SNDTIMEO, optval, optlen );
3163
3164 /* SO_DEBUG is a privileged operation, ignore it. */
3165 case SO_DEBUG:
3166 TRACE("Ignoring SO_DEBUG\n");
3167 return 0;
3168
3169 /* For some reason the game GrandPrixLegends does set SO_DONTROUTE on its
3170 * socket. According to MSDN, this option is silently ignored.*/
3171 case SO_DONTROUTE:
3172 TRACE( "Ignoring SO_DONTROUTE.\n" );
3173 if (optlen <= 0)
3174 {
3175 SetLastError( optlen ? WSAENOBUFS : WSAEFAULT );
3176 return -1;
3177 }
3178 SetLastError( ERROR_SUCCESS );
3179 return 0;
3180
3181 /* Stops two sockets from being bound to the same port. Always happens
3182 * on unix systems, so just drop it. */
3183 case SO_EXCLUSIVEADDRUSE:
3184 TRACE("Ignoring SO_EXCLUSIVEADDRUSE, is always set.\n");
3185 return 0;
3186
3187 /* After a ConnectEx call succeeds, the socket can't be used with half of the
3188 * normal winsock functions on windows. We don't have that problem. */
3189 case SO_UPDATE_CONNECT_CONTEXT:
3190 TRACE("Ignoring SO_UPDATE_CONNECT_CONTEXT, since our sockets are normal\n");
3191 return 0;
3192
3193 /* After a AcceptEx call succeeds, the socket can't be used with half of the
3194 * normal winsock functions on windows. We don't have that problem. */
3195 case SO_UPDATE_ACCEPT_CONTEXT:
3196 TRACE("Ignoring SO_UPDATE_ACCEPT_CONTEXT, since our sockets are normal\n");
3197 return 0;
3198
3199 /* SO_OPENTYPE does not require a valid socket handle. */
3200 case SO_OPENTYPE:
3201 if (!optlen || optlen < sizeof(int) || !optval)
3202 {
3203 SetLastError( WSAEFAULT );
3204 return SOCKET_ERROR;
3205 }
3206 get_per_thread_data()->opentype = *(const int *)optval;
3207 TRACE("setting global SO_OPENTYPE = 0x%x\n", *((const int*)optval) );
3208 SetLastError( ERROR_SUCCESS );
3209 return 0;
3210
3211 case SO_RANDOMIZE_PORT:
3212 FIXME("Ignoring SO_RANDOMIZE_PORT\n");
3213 return 0;
3214
3215 case SO_PORT_SCALABILITY:
3216 FIXME("Ignoring SO_PORT_SCALABILITY\n");
3217 return 0;
3218
3219 case SO_REUSE_UNICASTPORT:
3220 FIXME("Ignoring SO_REUSE_UNICASTPORT\n");
3221 return 0;
3222
3223 case SO_REUSE_MULTICASTPORT:
3224 FIXME("Ignoring SO_REUSE_MULTICASTPORT\n");
3225 return 0;
3226
3227 default:
3228 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
3229 /* fall through */
3230
3231 case SO_ACCEPTCONN:
3232 case SO_TYPE:
3233 SetLastError(WSAENOPROTOOPT);
3234 return SOCKET_ERROR;
3235 }
3236 break; /* case SOL_SOCKET */
3237
3238 case NSPROTO_IPX:
3239 switch(optname)
3240 {
3241 case IPX_PTYPE:
3242 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPX_PTYPE, optval, optlen );
3243
3244 case IPX_FILTERPTYPE:
3245 /* Sets the receive filter packet type, at the moment we don't support it */
3246 FIXME("IPX_FILTERPTYPE: %x\n", *optval);
3247 /* Returning 0 is better for now than returning a SOCKET_ERROR */
3248 return 0;
3249
3250 default:
3251 FIXME("opt_name:%x\n", optname);
3252 SetLastError(WSAENOPROTOOPT);
3253 return SOCKET_ERROR;
3254 }
3255 break; /* case NSPROTO_IPX */
3256
3257 case IPPROTO_TCP:
3258 switch(optname)
3259 {
3260 case TCP_NODELAY:
3261 if (optlen <= 0 || !optval)
3262 {
3263 SetLastError( optlen && optval ? WSAENOBUFS : WSAEFAULT );
3264 return SOCKET_ERROR;
3265 }
3266 value = *optval;
3267 return server_setsockopt( s, IOCTL_AFD_WINE_SET_TCP_NODELAY, (char*)&value, sizeof(value) );
3268
3269 default:
3270 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
3271 SetLastError(WSAENOPROTOOPT);
3272 return SOCKET_ERROR;
3273 }
3274 break;
3275
3276 case IPPROTO_IP:
3277 if (optlen < 0)
3278 {
3279 SetLastError(WSAENOBUFS);
3280 return SOCKET_ERROR;
3281 }
3282
3283 switch(optname)
3284 {
3285 case IP_ADD_MEMBERSHIP:
3286 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_ADD_MEMBERSHIP, optval, optlen );
3287
3288 case IP_ADD_SOURCE_MEMBERSHIP:
3289 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_ADD_SOURCE_MEMBERSHIP, optval, optlen );
3290
3291 case IP_BLOCK_SOURCE:
3292 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_BLOCK_SOURCE, optval, optlen );
3293
3294 case IP_DONTFRAGMENT:
3295 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_DONTFRAGMENT, optval, optlen );
3296
3297 case IP_DROP_MEMBERSHIP:
3298 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_DROP_MEMBERSHIP, optval, optlen );
3299
3300 case IP_DROP_SOURCE_MEMBERSHIP:
3301 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_DROP_SOURCE_MEMBERSHIP, optval, optlen );
3302
3303 case IP_HDRINCL:
3304 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_HDRINCL, optval, optlen );
3305
3306 case IP_MULTICAST_IF:
3307 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_MULTICAST_IF, optval, optlen );
3308
3309 case IP_MULTICAST_LOOP:
3310 if (!optlen)
3311 {
3312 SetLastError( WSAEFAULT );
3313 return -1;
3314 }
3315 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_MULTICAST_LOOP, optval, optlen );
3316
3317 case IP_MULTICAST_TTL:
3318 if (!optlen)
3319 {
3320 SetLastError( WSAEFAULT );
3321 return -1;
3322 }
3323 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_MULTICAST_TTL, optval, optlen );
3324
3325 case IP_OPTIONS:
3326 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_OPTIONS, optval, optlen );
3327
3328 case IP_PKTINFO:
3329 if (optlen < sizeof(DWORD) || !optval)
3330 {
3331 SetLastError( WSAEFAULT );
3332 return SOCKET_ERROR;
3333 }
3334 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_PKTINFO, optval, optlen );
3335
3336 case IP_RECVTOS:
3337 if (optlen < sizeof(DWORD) || !optval)
3338 {
3339 SetLastError( WSAEFAULT );
3340 return SOCKET_ERROR;
3341 }
3342 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_RECVTOS, optval, optlen );
3343
3344 case IP_RECVTTL:
3345 if (optlen < sizeof(DWORD) || !optval)
3346 {
3347 SetLastError( WSAEFAULT );
3348 return SOCKET_ERROR;
3349 }
3350 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_RECVTTL, optval, optlen );
3351
3352 case IP_TOS:
3353 if (!optlen || !optval)
3354 {
3355 SetLastError(WSAEFAULT);
3356 return SOCKET_ERROR;
3357 }
3358 memcpy( &value, optval, min( optlen, sizeof(value) ));
3359 if (value > 0xff)
3360 {
3361 SetLastError(WSAEINVAL);
3362 return SOCKET_ERROR;
3363 }
3364 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_TOS, optval, optlen );
3365
3366 case IP_TTL:
3367 if (!optlen)
3368 {
3369 SetLastError( WSAEFAULT );
3370 return -1;
3371 }
3372 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_TTL, optval, optlen );
3373
3374 case IP_UNBLOCK_SOURCE:
3375 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_UNBLOCK_SOURCE, optval, optlen );
3376
3377 case IP_UNICAST_IF:
3378 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_UNICAST_IF, optval, optlen );
3379
3380 default:
3381 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
3382 SetLastError(WSAENOPROTOOPT);
3383 return SOCKET_ERROR;
3384 }
3385 break;
3386
3387 case IPPROTO_IPV6:
3388 if (optlen < 0)
3389 {
3390 SetLastError( WSAENOBUFS );
3391 return SOCKET_ERROR;
3392 }
3393
3394 switch(optname)
3395 {
3396 case IPV6_ADD_MEMBERSHIP:
3397 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_ADD_MEMBERSHIP, optval, optlen );
3398
3399 case IPV6_DONTFRAG:
3400 if (!optlen || !optval)
3401 {
3402 SetLastError( WSAEFAULT );
3403 return SOCKET_ERROR;
3404 }
3405 memcpy( &value, optval, min( optlen, sizeof(value) ));
3406 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_DONTFRAG, (char *)&value, sizeof(value) );
3407
3408 case IPV6_DROP_MEMBERSHIP:
3409 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_DROP_MEMBERSHIP, optval, optlen );
3410
3411 case IPV6_HOPLIMIT:
3412 if (optlen < sizeof(DWORD) || !optval)
3413 {
3414 SetLastError( WSAEFAULT );
3415 return SOCKET_ERROR;
3416 }
3417 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_RECVHOPLIMIT, optval, optlen );
3418
3419 case IPV6_MULTICAST_HOPS:
3420 if (!optlen || !optval)
3421 {
3422 SetLastError( WSAEFAULT );
3423 return SOCKET_ERROR;
3424 }
3425 memcpy( &value, optval, min( optlen, sizeof(value) ));
3426 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_MULTICAST_HOPS, (char *)&value, sizeof(value) );
3427
3428 case IPV6_MULTICAST_IF:
3429 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_MULTICAST_IF, optval, optlen );
3430
3431 case IPV6_MULTICAST_LOOP:
3432 if (!optlen || !optval)
3433 {
3434 SetLastError( WSAEFAULT );
3435 return SOCKET_ERROR;
3436 }
3437 memcpy( &value, optval, min( optlen, sizeof(value) ));
3438 value = !!value;
3439 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_MULTICAST_LOOP, (char *)&value, sizeof(value) );
3440
3441 case IPV6_PKTINFO:
3442 if (optlen < sizeof(DWORD) || !optval)
3443 {
3444 SetLastError( WSAEFAULT );
3445 return SOCKET_ERROR;
3446 }
3447 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_RECVPKTINFO, optval, optlen );
3448
3449 case IPV6_PROTECTION_LEVEL:
3450 FIXME("IPV6_PROTECTION_LEVEL is ignored!\n");
3451 return 0;
3452
3453 case IPV6_RECVTCLASS:
3454 if (optlen < sizeof(DWORD) || !optval)
3455 {
3456 SetLastError( WSAEFAULT );
3457 return SOCKET_ERROR;
3458 }
3459 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_RECVTCLASS, optval, optlen );
3460
3461 case IPV6_UNICAST_HOPS:
3462 if (!optlen || !optval)
3463 {
3464 SetLastError( WSAEFAULT );
3465 return SOCKET_ERROR;
3466 }
3467 memcpy( &value, optval, min( optlen, sizeof(value) ));
3468 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_UNICAST_HOPS, (char *)&value, sizeof(value) );
3469
3470 case IPV6_UNICAST_IF:
3471 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_UNICAST_IF, optval, optlen );
3472
3473 case IPV6_V6ONLY:
3474 if (!optlen || !optval)
3475 {
3476 SetLastError( WSAEFAULT );
3477 return SOCKET_ERROR;
3478 }
3479 value = *optval;
3480 return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_V6ONLY, (char *)&value, sizeof(value) );
3481
3482 default:
3483 FIXME("Unknown IPPROTO_IPV6 optname 0x%08x\n", optname);
3484 SetLastError(WSAENOPROTOOPT);
3485 return SOCKET_ERROR;
3486 }
3487 break;
3488
3489 default:
3490 WARN("Unknown level: 0x%08x\n", level);
3491 SetLastError(WSAEINVAL);
3492 return SOCKET_ERROR;
3493 } /* end switch(level) */
3494 }
3495
3496
3497 /***********************************************************************
3498 * shutdown (ws2_32.22)
3499 */
3500 int WINAPI shutdown( SOCKET s, int how )
3501 {
3502 IO_STATUS_BLOCK io;
3503 NTSTATUS status;
3504
3505 TRACE( "socket %#Ix, how %u\n", s, how );
3506
3507 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io,
3508 IOCTL_AFD_WINE_SHUTDOWN, &how, sizeof(how), NULL, 0 );
3509 SetLastError( NtStatusToWSAError( status ) );
3510 TRACE( "status %#lx.\n", status );
3511 return status ? -1 : 0;
3512 }
3513
3514
3515 /***********************************************************************
3516 * socket (WS2_32.23)
3517 */
3518 SOCKET WINAPI socket( int af, int type, int protocol )
3519 {
3520 TRACE("af=%d type=%d protocol=%d\n", af, type, protocol);
3521
3522 return WSASocketW( af, type, protocol, NULL, 0,
3523 get_per_thread_data()->opentype ? 0 : WSA_FLAG_OVERLAPPED );
3524 }
3525
3526
3527 /***********************************************************************
3528 * WSAEnumNetworkEvents (ws2_32.@)
3529 */
3530 int WINAPI WSAEnumNetworkEvents( SOCKET s, WSAEVENT event, WSANETWORKEVENTS *ret_events )
3531 {
3532 struct afd_get_events_params params;
3533 IO_STATUS_BLOCK io;
3534 NTSTATUS status;
3535
3536 TRACE( "socket %#Ix, event %p, events %p\n", s, event, ret_events );
3537
3538 ResetEvent( event );
3539
3540 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_GET_EVENTS,
3541 NULL, 0, &params, sizeof(params) );
3542 if (!status)
3543 {
3544 ret_events->lNetworkEvents = afd_poll_flag_to_win32( params.flags );
3545
3546 if (ret_events->lNetworkEvents & FD_READ)
3547 ret_events->iErrorCode[FD_READ_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_READ] );
3548
3549 if (ret_events->lNetworkEvents & FD_WRITE)
3550 ret_events->iErrorCode[FD_WRITE_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_WRITE] );
3551
3552 if (ret_events->lNetworkEvents & FD_OOB)
3553 ret_events->iErrorCode[FD_OOB_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_OOB] );
3554
3555 if (ret_events->lNetworkEvents & FD_ACCEPT)
3556 ret_events->iErrorCode[FD_ACCEPT_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_ACCEPT] );
3557
3558 if (ret_events->lNetworkEvents & FD_CONNECT)
3559 ret_events->iErrorCode[FD_CONNECT_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_CONNECT_ERR] );
3560
3561 if (ret_events->lNetworkEvents & FD_CLOSE)
3562 {
3563 if (!(ret_events->iErrorCode[FD_CLOSE_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_HUP] )))
3564 ret_events->iErrorCode[FD_CLOSE_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_RESET] );
3565 }
3566 }
3567 SetLastError( NtStatusToWSAError( status ) );
3568 TRACE( "status %#lx.\n", status );
3569 return status ? -1 : 0;
3570 }
3571
3572
3573 static unsigned int afd_poll_flag_from_win32( unsigned int flags )
3574 {
3575 static const unsigned int map[] =
3576 {
3577 AFD_POLL_READ,
3578 AFD_POLL_WRITE,
3579 AFD_POLL_OOB,
3580 AFD_POLL_ACCEPT,
3581 AFD_POLL_CONNECT | AFD_POLL_CONNECT_ERR,
3582 AFD_POLL_RESET | AFD_POLL_HUP,
3583 };
3584
3585 unsigned int i, ret = 0;
3586
3587 for (i = 0; i < ARRAY_SIZE(map); ++i)
3588 {
3589 if (flags & (1 << i)) ret |= map[i];
3590 }
3591
3592 return ret;
3593 }
3594
3595
3596 /***********************************************************************
3597 * WSAEventSelect (ws2_32.@)
3598 */
3599 int WINAPI WSAEventSelect( SOCKET s, WSAEVENT event, LONG mask )
3600 {
3601 struct afd_event_select_params params;
3602 IO_STATUS_BLOCK io;
3603 NTSTATUS status;
3604
3605 TRACE( "socket %#Ix, event %p, mask %#lx\n", s, event, mask );
3606
3607 params.event = event;
3608 params.mask = afd_poll_flag_from_win32( mask );
3609
3610 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_EVENT_SELECT,
3611 &params, sizeof(params), NULL, 0 );
3612 SetLastError( NtStatusToWSAError( status ) );
3613 TRACE( "status %#lx.\n", status );
3614 return status ? -1 : 0;
3615 }
3616
3617
3618 /**********************************************************************
3619 * WSAGetOverlappedResult (WS2_32.40)
3620 */
3621 BOOL WINAPI WSAGetOverlappedResult( SOCKET s, LPWSAOVERLAPPED lpOverlapped,
3622 LPDWORD lpcbTransfer, BOOL fWait,
3623 LPDWORD lpdwFlags )
3624 {
3625 NTSTATUS status;
3626
3627 TRACE( "socket %#Ix, overlapped %p, transfer %p, wait %d, flags %p\n",
3628 s, lpOverlapped, lpcbTransfer, fWait, lpdwFlags );
3629
3630 if ( lpOverlapped == NULL )
3631 {
3632 ERR( "Invalid pointer\n" );
3633 SetLastError(WSA_INVALID_PARAMETER);
3634 return FALSE;
3635 }
3636
3637 if (!socket_list_find( s ))
3638 {
3639 SetLastError( WSAENOTSOCK );
3640 return FALSE;
3641 }
3642
3643 status = lpOverlapped->Internal;
3644 if (status == STATUS_PENDING)
3645 {
3646 if (!fWait)
3647 {
3648 SetLastError( WSA_IO_INCOMPLETE );
3649 return FALSE;
3650 }
3651
3652 if (WaitForSingleObject( lpOverlapped->hEvent ? lpOverlapped->hEvent : SOCKET2HANDLE(s),
3653 INFINITE ) == WAIT_FAILED)
3654 return FALSE;
3655 status = lpOverlapped->Internal;
3656 }
3657
3658 if ( lpcbTransfer )
3659 *lpcbTransfer = lpOverlapped->InternalHigh;
3660
3661 if ( lpdwFlags )
3662 *lpdwFlags = lpOverlapped->u.s.Offset;
3663
3664 SetLastError( NtStatusToWSAError(status) );
3665 TRACE( "status %#lx.\n", status );
3666 return NT_SUCCESS( status );
3667 }
3668
3669
3670 /***********************************************************************
3671 * WSAAsyncSelect (ws2_32.@)
3672 */
3673 int WINAPI WSAAsyncSelect( SOCKET s, HWND window, UINT message, LONG mask )
3674 {
3675 struct afd_message_select_params params;
3676 IO_STATUS_BLOCK io;
3677 NTSTATUS status;
3678
3679 TRACE( "socket %#Ix, window %p, message %#x, mask %#lx\n", s, window, message, mask );
3680
3681 params.handle = s;
3682 params.window = HandleToULong( window );
3683 params.message = message;
3684 params.mask = afd_poll_flag_from_win32( mask );
3685
3686 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_WINE_MESSAGE_SELECT,
3687 &params, sizeof(params), NULL, 0 );
3688 SetLastError( NtStatusToWSAError( status ) );
3689 TRACE( "status %#lx.\n", status );
3690 return status ? -1 : 0;
3691 }
3692
3693
3694 /***********************************************************************
3695 * WSACreateEvent (WS2_32.31)
3696 *
3697 */
3698 WSAEVENT WINAPI WSACreateEvent(void)
3699 {
3700 /* Create a manual-reset event, with initial state: unsignaled */
3701 TRACE("\n");
3702
3703 return CreateEventW(NULL, TRUE, FALSE, NULL);
3704 }
3705
3706 /***********************************************************************
3707 * WSACloseEvent (WS2_32.29)
3708 *
3709 */
3710 BOOL WINAPI WSACloseEvent(WSAEVENT event)
3711 {
3712 TRACE ("event=%p\n", event);
3713
3714 return CloseHandle(event);
3715 }
3716
3717 /***********************************************************************
3718 * WSASocketA (WS2_32.78)
3719 *
3720 */
3721 SOCKET WINAPI WSASocketA(int af, int type, int protocol,
3722 LPWSAPROTOCOL_INFOA lpProtocolInfo,
3723 GROUP g, DWORD dwFlags)
3724 {
3725 INT len;
3726 WSAPROTOCOL_INFOW info;
3727
3728 if (!lpProtocolInfo) return WSASocketW(af, type, protocol, NULL, g, dwFlags);
3729
3730 memcpy(&info, lpProtocolInfo, FIELD_OFFSET(WSAPROTOCOL_INFOW, szProtocol));
3731 len = MultiByteToWideChar(CP_ACP, 0, lpProtocolInfo->szProtocol, -1,
3732 info.szProtocol, WSAPROTOCOL_LEN + 1);
3733
3734 if (!len)
3735 {
3736 SetLastError(WSAEINVAL);
3737 return SOCKET_ERROR;
3738 }
3739
3740 return WSASocketW(af, type, protocol, &info, g, dwFlags);
3741 }
3742
3743 /***********************************************************************
3744 * WSASocketW (WS2_32.79)
3745 *
3746 */
3747 SOCKET WINAPI WSASocketW(int af, int type, int protocol,
3748 LPWSAPROTOCOL_INFOW lpProtocolInfo,
3749 GROUP g, DWORD flags)
3750 {
3751 struct afd_create_params create_params;
3752 OBJECT_ATTRIBUTES attr;
3753 UNICODE_STRING string;
3754 IO_STATUS_BLOCK io;
3755 NTSTATUS status;
3756 HANDLE handle;
3757 SOCKET ret;
3758 DWORD err;
3759
3760 /*
3761 FIXME: The "advanced" parameters of WSASocketW (lpProtocolInfo,
3762 g, dwFlags except WSA_FLAG_OVERLAPPED) are ignored.
3763 */
3764
3765 TRACE( "family %d, type %d, protocol %d, info %p, group %u, flags %#lx\n",
3766 af, type, protocol, lpProtocolInfo, g, flags );
3767
3768 if (!num_startup)
3769 {
3770 WARN( "not initialised\n" );
3771 SetLastError( WSANOTINITIALISED );
3772 return -1;
3773 }
3774
3775 /* hack for WSADuplicateSocket */
3776 if (lpProtocolInfo && lpProtocolInfo->dwServiceFlags4 == 0xff00ff00)
3777 {
3778 ret = lpProtocolInfo->dwServiceFlags3;
3779 TRACE( "got duplicate %#Ix\n", ret );
3780 if (!socket_list_add(ret))
3781 {
3782 CloseHandle(SOCKET2HANDLE(ret));
3783 return INVALID_SOCKET;
3784 }
3785 return ret;
3786 }
3787
3788 if (lpProtocolInfo)
3789 {
3790 if (af == FROM_PROTOCOL_INFO || !af)
3791 af = lpProtocolInfo->iAddressFamily;
3792 if (type == FROM_PROTOCOL_INFO || !type)
3793 type = lpProtocolInfo->iSocketType;
3794 if (protocol == FROM_PROTOCOL_INFO || !protocol)
3795 protocol = lpProtocolInfo->iProtocol;
3796 }
3797
3798 if (!af && !protocol)
3799 {
3800 WSASetLastError(WSAEINVAL);
3801 return INVALID_SOCKET;
3802 }
3803
3804 if (!af && lpProtocolInfo)
3805 {
3806 WSASetLastError(WSAEAFNOSUPPORT);
3807 return INVALID_SOCKET;
3808 }
3809
3810 if (!af || !type || !protocol)
3811 {
3812 unsigned int i;
3813
3814 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
3815 {
3816 const WSAPROTOCOL_INFOW *info = &supported_protocols[i];
3817
3818 if (af && af != info->iAddressFamily) continue;
3819 if (type && type != info->iSocketType) continue;
3820 if (protocol && (protocol < info->iProtocol ||
3821 protocol > info->iProtocol + info->iProtocolMaxOffset)) continue;
3822 if (!protocol && !(info->dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)) continue;
3823
3824 if (!af) af = supported_protocols[i].iAddressFamily;
3825 if (!type) type = supported_protocols[i].iSocketType;
3826 if (!protocol) protocol = supported_protocols[i].iProtocol;
3827 break;
3828 }
3829 }
3830
3831 RtlInitUnicodeString(&string, L"\\Device\\Afd");
3832 InitializeObjectAttributes(&attr, &string, (flags & WSA_FLAG_NO_HANDLE_INHERIT) ? 0 : OBJ_INHERIT, NULL, NULL);
3833 if ((status = NtOpenFile(&handle, GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, &attr,
3834 &io, 0, (flags & WSA_FLAG_OVERLAPPED) ? 0 : FILE_SYNCHRONOUS_IO_NONALERT)))
3835 {
3836 WARN( "failed to create socket, status %#lx\n", status );
3837 WSASetLastError(NtStatusToWSAError(status));
3838 return INVALID_SOCKET;
3839 }
3840
3841 create_params.family = af;
3842 create_params.type = type;
3843 create_params.protocol = protocol;
3844 create_params.flags = flags & ~(WSA_FLAG_NO_HANDLE_INHERIT | WSA_FLAG_OVERLAPPED);
3845 if ((status = NtDeviceIoControlFile(handle, NULL, NULL, NULL, &io,
3846 IOCTL_AFD_WINE_CREATE, &create_params, sizeof(create_params), NULL, 0)))
3847 {
3848 WARN( "failed to initialize socket, status %#lx\n", status );
3849 err = RtlNtStatusToDosError( status );
3850 if (err == WSAEACCES) /* raw socket denied */
3851 {
3852 if (type == SOCK_RAW)
3853 ERR_(winediag)("Failed to create a socket of type SOCK_RAW, this requires special permissions.\n");
3854 else
3855 ERR_(winediag)("Failed to create socket, this requires special permissions.\n");
3856 }
3857 WSASetLastError(err);
3858 NtClose(handle);
3859 return INVALID_SOCKET;
3860 }
3861
3862 ret = HANDLE2SOCKET(handle);
3863 TRACE( "created %#Ix\n", ret );
3864
3865 if (!socket_list_add(ret))
3866 {
3867 CloseHandle(handle);
3868 return INVALID_SOCKET;
3869 }
3870 WSASetLastError(0);
3871 return ret;
3872 }
3873
3874 /***********************************************************************
3875 * WSAJoinLeaf (WS2_32.58)
3876 *
3877 */
3878 SOCKET WINAPI WSAJoinLeaf( SOCKET s, const struct sockaddr *addr, int addrlen, WSABUF *caller_data,
3879 WSABUF *callee_data, QOS *socket_qos, QOS *group_qos, DWORD flags)
3880 {
3881 FIXME("stub.\n");
3882 return INVALID_SOCKET;
3883 }
3884
3885 /***********************************************************************
3886 * __WSAFDIsSet (WS2_32.151)
3887 */
3888 int WINAPI __WSAFDIsSet( SOCKET s, fd_set *set )
3889 {
3890 int i = set->fd_count, ret = 0;
3891
3892 while (i--)
3893 if (set->fd_array[i] == s)
3894 {
3895 ret = 1;
3896 break;
3897 }
3898
3899 return ret;
3900 }
3901
3902 /***********************************************************************
3903 * WSAIsBlocking (WS2_32.114)
3904 */
3905 BOOL WINAPI WSAIsBlocking(void)
3906 {
3907 /* By default WinSock should set all its sockets to non-blocking mode
3908 * and poll in PeekMessage loop when processing "blocking" ones. This
3909 * function is supposed to tell if the program is in this loop. Our
3910 * blocking calls are truly blocking so we always return FALSE.
3911 *
3912 * Note: It is allowed to call this function without prior WSAStartup().
3913 */
3914
3915 TRACE("\n");
3916 return FALSE;
3917 }
3918
3919 /***********************************************************************
3920 * WSACancelBlockingCall (WS2_32.113)
3921 */
3922 INT WINAPI WSACancelBlockingCall(void)
3923 {
3924 TRACE("\n");
3925 return 0;
3926 }
3927
3928 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x )
3929 {
3930 FIXME("How was this called?\n");
3931 return x();
3932 }
3933
3934
3935 /***********************************************************************
3936 * WSASetBlockingHook (WS2_32.109)
3937 */
3938 FARPROC WINAPI WSASetBlockingHook(FARPROC lpBlockFunc)
3939 {
3940 FARPROC prev = blocking_hook;
3941 blocking_hook = lpBlockFunc;
3942 TRACE("hook %p\n", lpBlockFunc);
3943 return prev;
3944 }
3945
3946
3947 /***********************************************************************
3948 * WSAUnhookBlockingHook (WS2_32.110)
3949 */
3950 INT WINAPI WSAUnhookBlockingHook(void)
3951 {
3952 blocking_hook = (FARPROC)WSA_DefaultBlockingHook;
3953 return 0;
3954 }
3955
3956
3957 /***********************************************************************
3958 * WSARecv (WS2_32.67)
3959 */
3960 int WINAPI WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
3961 LPDWORD NumberOfBytesReceived, LPDWORD lpFlags,
3962 LPWSAOVERLAPPED lpOverlapped,
3963 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
3964 {
3965 return WS2_recv_base(s, lpBuffers, dwBufferCount, NumberOfBytesReceived, lpFlags,
3966 NULL, NULL, lpOverlapped, lpCompletionRoutine, NULL);
3967 }
3968
3969
3970 /***********************************************************************
3971 * WSARecvFrom (WS2_32.69)
3972 */
3973 INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
3974 DWORD *lpNumberOfBytesRecvd, DWORD *lpFlags, struct sockaddr *lpFrom,
3975 LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped,
3976 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
3977
3978 {
3979 /* Garena hooks WSARecvFrom(), so we need a wrapper */
3980 return WS2_recv_base( s, lpBuffers, dwBufferCount,
3981 lpNumberOfBytesRecvd, lpFlags,
3982 lpFrom, lpFromlen,
3983 lpOverlapped, lpCompletionRoutine, NULL );
3984 }
3985
3986
3987 /***********************************************************************
3988 * WSAAccept (ws2_32.@)
3989 */
3990 SOCKET WINAPI WSAAccept( SOCKET s, struct sockaddr *addr, int *addrlen,
3991 LPCONDITIONPROC callback, DWORD_PTR context )
3992 {
3993 int ret = 0, size;
3994 WSABUF caller_id, caller_data, callee_id, callee_data;
3995 struct sockaddr src_addr, dst_addr;
3996 GROUP group;
3997 SOCKET cs;
3998
3999 TRACE( "socket %#Ix, addr %p, addrlen %p, callback %p, context %#Ix\n",
4000 s, addr, addrlen, callback, context );
4001
4002 cs = accept( s, addr, addrlen );
4003 if (cs == SOCKET_ERROR) return SOCKET_ERROR;
4004 if (!callback) return cs;
4005
4006 if (addr && addrlen)
4007 {
4008 caller_id.buf = (char *)addr;
4009 caller_id.len = *addrlen;
4010 }
4011 else
4012 {
4013 size = sizeof(src_addr);
4014 getpeername( cs, &src_addr, &size );
4015 caller_id.buf = (char *)&src_addr;
4016 caller_id.len = size;
4017 }
4018 caller_data.buf = NULL;
4019 caller_data.len = 0;
4020
4021 size = sizeof(dst_addr);
4022 getsockname( cs, &dst_addr, &size );
4023
4024 callee_id.buf = (char *)&dst_addr;
4025 callee_id.len = sizeof(dst_addr);
4026
4027 ret = (*callback)( &caller_id, &caller_data, NULL, NULL,
4028 &callee_id, &callee_data, &group, context );
4029 TRACE( "callback returned %d.\n", ret );
4030 switch (ret)
4031 {
4032 case CF_ACCEPT:
4033 return cs;
4034
4035 case CF_DEFER:
4036 {
4037 ULONG server_handle = cs;
4038 IO_STATUS_BLOCK io;
4039 NTSTATUS status;
4040
4041 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_WINE_DEFER,
4042 &server_handle, sizeof(server_handle), NULL, 0 );
4043 closesocket( cs );
4044 SetLastError( status ? RtlNtStatusToDosError( status ) : WSATRY_AGAIN );
4045 TRACE( "status %#lx.\n", status );
4046 return -1;
4047 }
4048
4049 case CF_REJECT:
4050 closesocket( cs );
4051 SetLastError( WSAECONNREFUSED );
4052 return SOCKET_ERROR;
4053
4054 default:
4055 FIXME( "Unknown return type from Condition function\n" );
4056 SetLastError( WSAENOTSOCK );
4057 return SOCKET_ERROR;
4058 }
4059 }
4060
4061
4062 /***********************************************************************
4063 * WSADuplicateSocketA (WS2_32.32)
4064 */
4065 int WINAPI WSADuplicateSocketA( SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOA lpProtocolInfo )
4066 {
4067 return WS_DuplicateSocket(FALSE, s, dwProcessId, (LPWSAPROTOCOL_INFOW) lpProtocolInfo);
4068 }
4069
4070 /***********************************************************************
4071 * WSADuplicateSocketW (WS2_32.33)
4072 */
4073 int WINAPI WSADuplicateSocketW( SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo )
4074 {
4075 return WS_DuplicateSocket(TRUE, s, dwProcessId, lpProtocolInfo);
4076 }
4077
4078
4079 /***********************************************************************
4080 * WSAGetQOSByName (WS2_32.41)
4081 */
4082 BOOL WINAPI WSAGetQOSByName( SOCKET s, WSABUF *name, QOS *qos )
4083 {
4084 FIXME( "socket %#Ix, name %p, qos %p, stub!\n", s, name, qos );
4085 return FALSE;
4086 }
4087
4088
4089 /***********************************************************************
4090 * WSARecvDisconnect (WS2_32.68)
4091 */
4092 int WINAPI WSARecvDisconnect( SOCKET s, WSABUF *data )
4093 {
4094 TRACE( "socket %#Ix, data %p\n", s, data );
4095
4096 return shutdown( s, SD_RECEIVE );
4097 }
4098
4099
4100 static BOOL protocol_matches_filter( const int *filter, int protocol )
4101 {
4102 if (!filter) return TRUE;
4103 while (*filter)
4104 {
4105 if (protocol == *filter++) return TRUE;
4106 }
4107 return FALSE;
4108 }
4109
4110 /*****************************************************************************
4111 * WSAEnumProtocolsA [WS2_32.@]
4112 *
4113 * see function WSAEnumProtocolsW
4114 */
4115 int WINAPI WSAEnumProtocolsA( int *filter, WSAPROTOCOL_INFOA *protocols, DWORD *size )
4116 {
4117 DWORD i, count = 0;
4118
4119 TRACE("filter %p, protocols %p, size %p\n", filter, protocols, size);
4120
4121 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4122 {
4123 if (protocol_matches_filter( filter, supported_protocols[i].iProtocol ))
4124 ++count;
4125 }
4126
4127 if (!protocols || *size < count * sizeof(WSAPROTOCOL_INFOA))
4128 {
4129 *size = count * sizeof(WSAPROTOCOL_INFOA);
4130 WSASetLastError( WSAENOBUFS );
4131 return SOCKET_ERROR;
4132 }
4133
4134 count = 0;
4135 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4136 {
4137 if (protocol_matches_filter( filter, supported_protocols[i].iProtocol ))
4138 {
4139 memcpy( &protocols[count], &supported_protocols[i], offsetof( WSAPROTOCOL_INFOW, szProtocol ) );
4140 WideCharToMultiByte( CP_ACP, 0, supported_protocols[i].szProtocol, -1,
4141 protocols[count].szProtocol, sizeof(protocols[count].szProtocol), NULL, NULL );
4142 ++count;
4143 }
4144 }
4145 return count;
4146 }
4147
4148 /*****************************************************************************
4149 * WSAEnumProtocolsW [WS2_32.@]
4150 *
4151 * Retrieves information about specified set of active network protocols.
4152 *
4153 * PARAMS
4154 * protocols [I] Pointer to null-terminated array of protocol id's. NULL
4155 * retrieves information on all available protocols.
4156 * buffer [I] Pointer to a buffer to be filled with WSAPROTOCOL_INFO
4157 * structures.
4158 * len [I/O] Pointer to a variable specifying buffer size. On output
4159 * the variable holds the number of bytes needed when the
4160 * specified size is too small.
4161 *
4162 * RETURNS
4163 * Success: number of WSAPROTOCOL_INFO structures in buffer.
4164 * Failure: SOCKET_ERROR
4165 *
4166 * NOTES
4167 * NT4SP5 does not return SPX if protocols == NULL
4168 *
4169 * BUGS
4170 * - NT4SP5 returns in addition these list of NETBIOS protocols
4171 * (address family 17), each entry two times one for socket type 2 and 5
4172 *
4173 * iProtocol szProtocol
4174 * 0x80000000 \Device\NwlnkNb
4175 * 0xfffffffa \Device\NetBT_CBENT7
4176 * 0xfffffffb \Device\Nbf_CBENT7
4177 * 0xfffffffc \Device\NetBT_NdisWan5
4178 * 0xfffffffd \Device\NetBT_El9202
4179 * 0xfffffffe \Device\Nbf_El9202
4180 * 0xffffffff \Device\Nbf_NdisWan4
4181 *
4182 * - there is no check that the operating system supports the returned
4183 * protocols
4184 */
4185 int WINAPI WSAEnumProtocolsW( int *filter, WSAPROTOCOL_INFOW *protocols, DWORD *size )
4186 {
4187 DWORD i, count = 0;
4188
4189 TRACE("filter %p, protocols %p, size %p\n", filter, protocols, size);
4190
4191 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4192 {
4193 if (protocol_matches_filter( filter, supported_protocols[i].iProtocol ))
4194 ++count;
4195 }
4196
4197 if (!protocols || *size < count * sizeof(WSAPROTOCOL_INFOW))
4198 {
4199 *size = count * sizeof(WSAPROTOCOL_INFOW);
4200 WSASetLastError( WSAENOBUFS );
4201 return SOCKET_ERROR;
4202 }
4203
4204 count = 0;
4205 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4206 {
4207 if (protocol_matches_filter( filter, supported_protocols[i].iProtocol ))
4208 protocols[count++] = supported_protocols[i];
4209 }
4210 return count;
4211 }
Windows API implementation