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