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