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