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