?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32: Implement setsockopt(SO_DONTLINGER) on top of Win32 setsockopt(SO_LINGER).
[wine.git] / dlls / ws2_32 / socket.c
blob776268b381a31882137b93424a6d86352e7e3f40
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 /* Handle common cases. The special cases are below, sorted
2092 * alphabetically */
2093 case WS_SO_OOBINLINE:
2094 case WS_SO_RCVBUF:
2095 case WS_SO_REUSEADDR:
2096 case WS_SO_SNDBUF:
2097 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2098 return SOCKET_ERROR;
2099 convert_sockopt(&level, &optname);
2100 if (getsockopt(fd, level, optname, optval, (socklen_t *)optlen) != 0 )
2101 {
2102 SetLastError(wsaErrno());
2103 ret = SOCKET_ERROR;
2104 }
2105 release_sock_fd( s, fd );
2106 return ret;
2107
2108 case WS_SO_BSP_STATE:
2109 {
2110 CSADDR_INFO *csinfo = (CSADDR_INFO *)optval;
2111 WSAPROTOCOL_INFOW infow;
2112 int addr_size;
2113
2114 if (!ws_protocol_info( s, TRUE, &infow, &addr_size ))
2115 return -1;
2116
2117 if (infow.iAddressFamily == WS_AF_INET)
2118 addr_size = sizeof(struct sockaddr_in);
2119 else if (infow.iAddressFamily == WS_AF_INET6)
2120 addr_size = sizeof(struct sockaddr_in6);
2121 else
2122 {
2123 FIXME( "family %d is unsupported for SO_BSP_STATE\n", infow.iAddressFamily );
2124 SetLastError( WSAEAFNOSUPPORT );
2125 return -1;
2126 }
2127
2128 if (*optlen < sizeof(CSADDR_INFO) + addr_size * 2)
2129 {
2130 ret = 0;
2131 SetLastError( WSAEFAULT );
2132 return -1;
2133 }
2134
2135 csinfo->LocalAddr.lpSockaddr = (struct WS_sockaddr *)(csinfo + 1);
2136 csinfo->RemoteAddr.lpSockaddr = (struct WS_sockaddr *)((char *)(csinfo + 1) + addr_size);
2137
2138 csinfo->LocalAddr.iSockaddrLength = addr_size;
2139 if (WS_getsockname( s, csinfo->LocalAddr.lpSockaddr, &csinfo->LocalAddr.iSockaddrLength ) < 0)
2140 {
2141 csinfo->LocalAddr.lpSockaddr = NULL;
2142 csinfo->LocalAddr.iSockaddrLength = 0;
2143 }
2144
2145 csinfo->RemoteAddr.iSockaddrLength = addr_size;
2146 if (WS_getpeername( s, csinfo->RemoteAddr.lpSockaddr, &csinfo->RemoteAddr.iSockaddrLength ) < 0)
2147 {
2148 csinfo->RemoteAddr.lpSockaddr = NULL;
2149 csinfo->RemoteAddr.iSockaddrLength = 0;
2150 }
2151
2152 csinfo->iSocketType = infow.iSocketType;
2153 csinfo->iProtocol = infow.iProtocol;
2154 return 0;
2155 }
2156
2157 case WS_SO_DEBUG:
2158 WARN( "returning 0 for SO_DEBUG\n" );
2159 *(DWORD *)optval = 0;
2160 SetLastError( 0 );
2161 return 0;
2162
2163 case WS_SO_DONTLINGER:
2164 {
2165 struct WS_linger linger;
2166 int len = sizeof(linger);
2167 int ret;
2168
2169 if (!optlen || *optlen < sizeof(BOOL)|| !optval)
2170 {
2171 SetLastError(WSAEFAULT);
2172 return SOCKET_ERROR;
2173 }
2174
2175 if (!(ret = WS_getsockopt( s, WS_SOL_SOCKET, WS_SO_LINGER, (char *)&linger, &len )))
2176 {
2177 *(BOOL *)optval = !linger.l_onoff;
2178 *optlen = sizeof(BOOL);
2179 }
2180 return ret;
2181 }
2182
2183 case WS_SO_CONNECT_TIME:
2184 {
2185 static int pretendtime = 0;
2186 struct WS_sockaddr addr;
2187 int len = sizeof(addr);
2188
2189 if (!optlen || *optlen < sizeof(DWORD) || !optval)
2190 {
2191 SetLastError(WSAEFAULT);
2192 return SOCKET_ERROR;
2193 }
2194 if (WS_getpeername(s, &addr, &len) == SOCKET_ERROR)
2195 *(DWORD *)optval = ~0u;
2196 else
2197 {
2198 if (!pretendtime) FIXME("WS_SO_CONNECT_TIME - faking results\n");
2199 *(DWORD *)optval = pretendtime++;
2200 }
2201 *optlen = sizeof(DWORD);
2202 return ret;
2203 }
2204 /* As mentioned in setsockopt, Windows ignores this, so we
2205 * always return true here */
2206 case WS_SO_DONTROUTE:
2207 if (!optlen || *optlen < sizeof(BOOL) || !optval)
2208 {
2209 SetLastError(WSAEFAULT);
2210 return SOCKET_ERROR;
2211 }
2212 *(BOOL *)optval = TRUE;
2213 *optlen = sizeof(BOOL);
2214 return 0;
2215
2216 case WS_SO_ERROR:
2217 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_ERROR, optval, optlen );
2218
2219 case WS_SO_KEEPALIVE:
2220 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_KEEPALIVE, optval, optlen );
2221
2222 case WS_SO_LINGER:
2223 {
2224 /* struct linger and LINGER have different sizes */
2225 if (!optlen || *optlen < sizeof(LINGER) || !optval)
2226 {
2227 SetLastError(WSAEFAULT);
2228 return SOCKET_ERROR;
2229 }
2230 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2231 return SOCKET_ERROR;
2232
2233 if (_get_fd_type(fd) == SOCK_DGRAM)
2234 {
2235 release_sock_fd( s, fd );
2236 SetLastError( WSAENOPROTOOPT );
2237 return -1;
2238 }
2239 release_sock_fd( s, fd );
2240
2241 return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_LINGER, optval, optlen );
2242 }
2243
2244 case WS_SO_MAX_MSG_SIZE:
2245 if (!optlen || *optlen < sizeof(int) || !optval)
2246 {
2247 SetLastError(WSAEFAULT);
2248 return SOCKET_ERROR;
2249 }
2250 TRACE("getting global SO_MAX_MSG_SIZE = 65507\n");
2251 *(int *)optval = 65507;
2252 *optlen = sizeof(int);
2253 return 0;
2254
2255 /* SO_OPENTYPE does not require a valid socket handle. */
2256 case WS_SO_OPENTYPE:
2257 if (!optlen || *optlen < sizeof(int) || !optval)
2258 {
2259 SetLastError(WSAEFAULT);
2260 return SOCKET_ERROR;
2261 }
2262 *(int *)optval = get_per_thread_data()->opentype;
2263 *optlen = sizeof(int);
2264 TRACE("getting global SO_OPENTYPE = 0x%x\n", *((int*)optval) );
2265 return 0;
2266 case WS_SO_PROTOCOL_INFOA:
2267 case WS_SO_PROTOCOL_INFOW:
2268 {
2269 int size;
2270 WSAPROTOCOL_INFOW infow;
2271
2272 ret = ws_protocol_info(s, optname == WS_SO_PROTOCOL_INFOW, &infow, &size);
2273 if (ret)
2274 {
2275 if (!optlen || !optval || *optlen < size)
2276 {
2277 if(optlen) *optlen = size;
2278 ret = 0;
2279 SetLastError(WSAEFAULT);
2280 }
2281 else
2282 memcpy(optval, &infow, size);
2283 }
2284 return ret ? 0 : SOCKET_ERROR;
2285 }
2286 case WS_SO_RCVTIMEO:
2287 case WS_SO_SNDTIMEO:
2288 {
2289 INT64 timeout;
2290
2291 if (!optlen || *optlen < sizeof(int)|| !optval)
2292 {
2293 SetLastError(WSAEFAULT);
2294 return SOCKET_ERROR;
2295 }
2296 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2297 return SOCKET_ERROR;
2298
2299 timeout = get_rcvsnd_timeo(fd, optname == WS_SO_RCVTIMEO);
2300 *(int *)optval = timeout <= UINT_MAX ? timeout : UINT_MAX;
2301
2302 release_sock_fd( s, fd );
2303 return ret;
2304 }
2305 case WS_SO_TYPE:
2306 {
2307 int sock_type;
2308 if (!optlen || *optlen < sizeof(int) || !optval)
2309 {
2310 SetLastError(WSAEFAULT);
2311 return SOCKET_ERROR;
2312 }
2313 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2314 return SOCKET_ERROR;
2315
2316 sock_type = _get_fd_type(fd);
2317 if (sock_type == -1)
2318 {
2319 SetLastError(wsaErrno());
2320 ret = SOCKET_ERROR;
2321 }
2322 else
2323 (*(int *)optval) = convert_socktype_u2w(sock_type);
2324
2325 release_sock_fd( s, fd );
2326 return ret;
2327 }
2328 default:
2329 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
2330 SetLastError(WSAENOPROTOOPT);
2331 return SOCKET_ERROR;
2332 } /* end switch(optname) */
2333 }/* end case WS_SOL_SOCKET */
2334 #ifdef HAS_IPX
2335 case WS_NSPROTO_IPX:
2336 {
2337 struct WS_sockaddr_ipx addr;
2338 IPX_ADDRESS_DATA *data;
2339 int namelen;
2340 switch(optname)
2341 {
2342 case WS_IPX_PTYPE:
2343 if ((fd = get_sock_fd( s, 0, NULL )) == -1) return SOCKET_ERROR;
2344 #ifdef SOL_IPX
2345 if(getsockopt(fd, SOL_IPX, IPX_TYPE, optval, (socklen_t *)optlen) == -1)
2346 {
2347 ret = SOCKET_ERROR;
2348 }
2349 #else
2350 {
2351 struct ipx val;
2352 socklen_t len=sizeof(struct ipx);
2353 if(getsockopt(fd, 0, SO_DEFAULT_HEADERS, &val, &len) == -1 )
2354 ret = SOCKET_ERROR;
2355 else
2356 *optval = (int)val.ipx_pt;
2357 }
2358 #endif
2359 TRACE("ptype: %d (fd: %d)\n", *(int*)optval, fd);
2360 release_sock_fd( s, fd );
2361 return ret;
2362
2363 case WS_IPX_ADDRESS:
2364 /*
2365 * On a Win2000 system with one network card there are usually
2366 * three ipx devices one with a speed of 28.8kbps, 10Mbps and 100Mbps.
2367 * Using this call you can then retrieve info about this all.
2368 * In case of Linux it is a bit different. Usually you have
2369 * only "one" device active and further it is not possible to
2370 * query things like the linkspeed.
2371 */
2372 FIXME("IPX_ADDRESS\n");
2373 namelen = sizeof(struct WS_sockaddr_ipx);
2374 memset(&addr, 0, sizeof(struct WS_sockaddr_ipx));
2375 WS_getsockname(s, (struct WS_sockaddr*)&addr, &namelen);
2376
2377 data = (IPX_ADDRESS_DATA*)optval;
2378 memcpy(data->nodenum,addr.sa_nodenum,sizeof(data->nodenum));
2379 memcpy(data->netnum,addr.sa_netnum,sizeof(data->netnum));
2380 data->adapternum = 0;
2381 data->wan = FALSE; /* We are not on a wan for now .. */
2382 data->status = FALSE; /* Since we are not on a wan, the wan link isn't up */
2383 data->maxpkt = 1467; /* This value is the default one, at least on Win2k/WinXP */
2384 data->linkspeed = 100000; /* Set the line speed in 100bit/s to 10 Mbit;
2385 * note 1MB = 1000kB in this case */
2386 return 0;
2387
2388 case WS_IPX_MAX_ADAPTER_NUM:
2389 FIXME("IPX_MAX_ADAPTER_NUM\n");
2390 *(int*)optval = 1; /* As noted under IPX_ADDRESS we have just one card. */
2391 return 0;
2392
2393 default:
2394 FIXME("IPX optname:%x\n", optname);
2395 return SOCKET_ERROR;
2396 }/* end switch(optname) */
2397 } /* end case WS_NSPROTO_IPX */
2398 #endif
2399
2400 #ifdef HAS_IRDA
2401 #define MAX_IRDA_DEVICES 10
2402
2403 case WS_SOL_IRLMP:
2404 switch(optname)
2405 {
2406 case WS_IRLMP_ENUMDEVICES:
2407 {
2408 char buf[sizeof(struct irda_device_list) +
2409 (MAX_IRDA_DEVICES - 1) * sizeof(struct irda_device_info)];
2410 int res;
2411 socklen_t len = sizeof(buf);
2412
2413 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2414 return SOCKET_ERROR;
2415 res = getsockopt( fd, SOL_IRLMP, IRLMP_ENUMDEVICES, buf, &len );
2416 release_sock_fd( s, fd );
2417 if (res < 0)
2418 {
2419 SetLastError(wsaErrno());
2420 return SOCKET_ERROR;
2421 }
2422 else
2423 {
2424 struct irda_device_list *src = (struct irda_device_list *)buf;
2425 DEVICELIST *dst = (DEVICELIST *)optval;
2426 INT needed = sizeof(DEVICELIST);
2427 unsigned int i;
2428
2429 if (src->len > 0)
2430 needed += (src->len - 1) * sizeof(IRDA_DEVICE_INFO);
2431 if (*optlen < needed)
2432 {
2433 SetLastError(WSAEFAULT);
2434 return SOCKET_ERROR;
2435 }
2436 *optlen = needed;
2437 TRACE("IRLMP_ENUMDEVICES: %d devices found:\n", src->len);
2438 dst->numDevice = src->len;
2439 for (i = 0; i < src->len; i++)
2440 {
2441 TRACE("saddr = %08x, daddr = %08x, info = %s, hints = %02x%02x\n",
2442 src->dev[i].saddr, src->dev[i].daddr,
2443 src->dev[i].info, src->dev[i].hints[0],
2444 src->dev[i].hints[1]);
2445 memcpy( dst->Device[i].irdaDeviceID,
2446 &src->dev[i].daddr,
2447 sizeof(dst->Device[i].irdaDeviceID) ) ;
2448 memcpy( dst->Device[i].irdaDeviceName,
2449 src->dev[i].info,
2450 sizeof(dst->Device[i].irdaDeviceName) ) ;
2451 memcpy( &dst->Device[i].irdaDeviceHints1,
2452 &src->dev[i].hints[0],
2453 sizeof(dst->Device[i].irdaDeviceHints1) ) ;
2454 memcpy( &dst->Device[i].irdaDeviceHints2,
2455 &src->dev[i].hints[1],
2456 sizeof(dst->Device[i].irdaDeviceHints2) ) ;
2457 dst->Device[i].irdaCharSet = src->dev[i].charset;
2458 }
2459 return 0;
2460 }
2461 }
2462 default:
2463 FIXME("IrDA optname:0x%x\n", optname);
2464 return SOCKET_ERROR;
2465 }
2466 break; /* case WS_SOL_IRLMP */
2467 #undef MAX_IRDA_DEVICES
2468 #endif
2469
2470 /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */
2471 case WS_IPPROTO_TCP:
2472 switch(optname)
2473 {
2474 case WS_TCP_NODELAY:
2475 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2476 return SOCKET_ERROR;
2477 convert_sockopt(&level, &optname);
2478 if (getsockopt(fd, level, optname, optval, (socklen_t *)optlen) != 0 )
2479 {
2480 SetLastError(wsaErrno());
2481 ret = SOCKET_ERROR;
2482 }
2483 release_sock_fd( s, fd );
2484 return ret;
2485 }
2486 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
2487 return SOCKET_ERROR;
2488
2489 case WS_IPPROTO_IP:
2490 switch(optname)
2491 {
2492 case WS_IP_ADD_MEMBERSHIP:
2493 case WS_IP_DROP_MEMBERSHIP:
2494 #ifdef IP_HDRINCL
2495 case WS_IP_HDRINCL:
2496 #endif
2497 case WS_IP_MULTICAST_IF:
2498 case WS_IP_MULTICAST_LOOP:
2499 case WS_IP_MULTICAST_TTL:
2500 case WS_IP_OPTIONS:
2501 #if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
2502 case WS_IP_PKTINFO:
2503 #endif
2504 case WS_IP_TOS:
2505 case WS_IP_TTL:
2506 #ifdef IP_UNICAST_IF
2507 case WS_IP_UNICAST_IF:
2508 #endif
2509 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2510 return SOCKET_ERROR;
2511 convert_sockopt(&level, &optname);
2512 if (getsockopt(fd, level, optname, optval, (socklen_t *)optlen) != 0 )
2513 {
2514 SetLastError(wsaErrno());
2515 ret = SOCKET_ERROR;
2516 }
2517 release_sock_fd( s, fd );
2518 return ret;
2519 case WS_IP_DONTFRAGMENT:
2520 return get_dont_fragment(s, IPPROTO_IP, (BOOL *)optval) ? 0 : SOCKET_ERROR;
2521 }
2522 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
2523 return SOCKET_ERROR;
2524
2525 case WS_IPPROTO_IPV6:
2526 switch(optname)
2527 {
2528 #ifdef IPV6_ADD_MEMBERSHIP
2529 case WS_IPV6_ADD_MEMBERSHIP:
2530 #endif
2531 #ifdef IPV6_DROP_MEMBERSHIP
2532 case WS_IPV6_DROP_MEMBERSHIP:
2533 #endif
2534 case WS_IPV6_MULTICAST_IF:
2535 case WS_IPV6_MULTICAST_HOPS:
2536 case WS_IPV6_MULTICAST_LOOP:
2537 case WS_IPV6_UNICAST_HOPS:
2538 case WS_IPV6_V6ONLY:
2539 #ifdef IPV6_UNICAST_IF
2540 case WS_IPV6_UNICAST_IF:
2541 #endif
2542 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2543 return SOCKET_ERROR;
2544 convert_sockopt(&level, &optname);
2545 if (getsockopt(fd, level, optname, optval, (socklen_t *)optlen) != 0 )
2546 {
2547 SetLastError(wsaErrno());
2548 ret = SOCKET_ERROR;
2549 }
2550 release_sock_fd( s, fd );
2551 return ret;
2552 case WS_IPV6_DONTFRAG:
2553 return get_dont_fragment(s, IPPROTO_IPV6, (BOOL *)optval) ? 0 : SOCKET_ERROR;
2554 }
2555 FIXME("Unknown IPPROTO_IPV6 optname 0x%08x\n", optname);
2556 return SOCKET_ERROR;
2557
2558 default:
2559 WARN("Unknown level: 0x%08x\n", level);
2560 SetLastError(WSAEINVAL);
2561 return SOCKET_ERROR;
2562 } /* end switch(level) */
2563 }
2564
2565
2566 static const char *debugstr_wsaioctl(DWORD code)
2567 {
2568 const char *name = NULL, *buf_type, *family;
2569
2570 #define IOCTL_NAME(x) case x: name = #x; break
2571 switch (code)
2572 {
2573 IOCTL_NAME(WS_FIONBIO);
2574 IOCTL_NAME(WS_FIONREAD);
2575 IOCTL_NAME(WS_SIOCATMARK);
2576 /* IOCTL_NAME(WS_SIO_ACQUIRE_PORT_RESERVATION); */
2577 IOCTL_NAME(WS_SIO_ADDRESS_LIST_CHANGE);
2578 IOCTL_NAME(WS_SIO_ADDRESS_LIST_QUERY);
2579 IOCTL_NAME(WS_SIO_ASSOCIATE_HANDLE);
2580 /* IOCTL_NAME(WS_SIO_ASSOCIATE_PORT_RESERVATION);
2581 IOCTL_NAME(WS_SIO_BASE_HANDLE);
2582 IOCTL_NAME(WS_SIO_BSP_HANDLE);
2583 IOCTL_NAME(WS_SIO_BSP_HANDLE_SELECT);
2584 IOCTL_NAME(WS_SIO_BSP_HANDLE_POLL);
2585 IOCTL_NAME(WS_SIO_CHK_QOS); */
2586 IOCTL_NAME(WS_SIO_ENABLE_CIRCULAR_QUEUEING);
2587 IOCTL_NAME(WS_SIO_FIND_ROUTE);
2588 IOCTL_NAME(WS_SIO_FLUSH);
2589 IOCTL_NAME(WS_SIO_GET_BROADCAST_ADDRESS);
2590 IOCTL_NAME(WS_SIO_GET_EXTENSION_FUNCTION_POINTER);
2591 IOCTL_NAME(WS_SIO_GET_GROUP_QOS);
2592 IOCTL_NAME(WS_SIO_GET_INTERFACE_LIST);
2593 /* IOCTL_NAME(WS_SIO_GET_INTERFACE_LIST_EX); */
2594 IOCTL_NAME(WS_SIO_GET_QOS);
2595 IOCTL_NAME(WS_SIO_IDEAL_SEND_BACKLOG_CHANGE);
2596 IOCTL_NAME(WS_SIO_IDEAL_SEND_BACKLOG_QUERY);
2597 IOCTL_NAME(WS_SIO_KEEPALIVE_VALS);
2598 IOCTL_NAME(WS_SIO_MULTIPOINT_LOOPBACK);
2599 IOCTL_NAME(WS_SIO_MULTICAST_SCOPE);
2600 /* IOCTL_NAME(WS_SIO_QUERY_RSS_SCALABILITY_INFO);
2601 IOCTL_NAME(WS_SIO_QUERY_WFP_ALE_ENDPOINT_HANDLE); */
2602 IOCTL_NAME(WS_SIO_RCVALL);
2603 IOCTL_NAME(WS_SIO_RCVALL_IGMPMCAST);
2604 IOCTL_NAME(WS_SIO_RCVALL_MCAST);
2605 /* IOCTL_NAME(WS_SIO_RELEASE_PORT_RESERVATION); */
2606 IOCTL_NAME(WS_SIO_ROUTING_INTERFACE_CHANGE);
2607 IOCTL_NAME(WS_SIO_ROUTING_INTERFACE_QUERY);
2608 IOCTL_NAME(WS_SIO_SET_COMPATIBILITY_MODE);
2609 IOCTL_NAME(WS_SIO_SET_GROUP_QOS);
2610 IOCTL_NAME(WS_SIO_SET_QOS);
2611 IOCTL_NAME(WS_SIO_TRANSLATE_HANDLE);
2612 IOCTL_NAME(WS_SIO_UDP_CONNRESET);
2613 }
2614 #undef IOCTL_NAME
2615
2616 if (name)
2617 return name + 3;
2618
2619 /* If this is not a known code split its bits */
2620 switch(code & 0x18000000)
2621 {
2622 case WS_IOC_WS2:
2623 family = "IOC_WS2";
2624 break;
2625 case WS_IOC_PROTOCOL:
2626 family = "IOC_PROTOCOL";
2627 break;
2628 case WS_IOC_VENDOR:
2629 family = "IOC_VENDOR";
2630 break;
2631 default: /* WS_IOC_UNIX */
2632 {
2633 BYTE size = (code >> 16) & WS_IOCPARM_MASK;
2634 char x = (code & 0xff00) >> 8;
2635 BYTE y = code & 0xff;
2636 char args[14];
2637
2638 switch (code & (WS_IOC_VOID|WS_IOC_INOUT))
2639 {
2640 case WS_IOC_VOID:
2641 buf_type = "_IO";
2642 sprintf(args, "%d, %d", x, y);
2643 break;
2644 case WS_IOC_IN:
2645 buf_type = "_IOW";
2646 sprintf(args, "'%c', %d, %d", x, y, size);
2647 break;
2648 case WS_IOC_OUT:
2649 buf_type = "_IOR";
2650 sprintf(args, "'%c', %d, %d", x, y, size);
2651 break;
2652 default:
2653 buf_type = "?";
2654 sprintf(args, "'%c', %d, %d", x, y, size);
2655 break;
2656 }
2657 return wine_dbg_sprintf("%s(%s)", buf_type, args);
2658 }
2659 }
2660
2661 /* We are different from WS_IOC_UNIX. */
2662 switch (code & (WS_IOC_VOID|WS_IOC_INOUT))
2663 {
2664 case WS_IOC_VOID:
2665 buf_type = "_WSAIO";
2666 break;
2667 case WS_IOC_INOUT:
2668 buf_type = "_WSAIORW";
2669 break;
2670 case WS_IOC_IN:
2671 buf_type = "_WSAIOW";
2672 break;
2673 case WS_IOC_OUT:
2674 buf_type = "_WSAIOR";
2675 break;
2676 default:
2677 buf_type = "?";
2678 break;
2679 }
2680
2681 return wine_dbg_sprintf("%s(%s, %d)", buf_type, family,
2682 (USHORT)(code & 0xffff));
2683 }
2684
2685 /* do an ioctl call through the server */
2686 static DWORD server_ioctl_sock( SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size,
2687 LPVOID out_buff, DWORD out_size, LPDWORD ret_size,
2688 LPWSAOVERLAPPED overlapped,
2689 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
2690 {
2691 IO_STATUS_BLOCK iosb, *piosb = &iosb;
2692 HANDLE handle = SOCKET2HANDLE( s );
2693 PIO_APC_ROUTINE apc = NULL;
2694 HANDLE event = NULL;
2695 void *cvalue = NULL;
2696 NTSTATUS status;
2697
2698 if (overlapped)
2699 {
2700 piosb = (IO_STATUS_BLOCK *)overlapped;
2701 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
2702 event = overlapped->hEvent;
2703 }
2704 else
2705 {
2706 if (!(event = get_sync_event())) return GetLastError();
2707 }
2708
2709 if (completion)
2710 {
2711 event = NULL;
2712 cvalue = completion;
2713 apc = socket_apc;
2714 }
2715
2716 status = NtDeviceIoControlFile( handle, event, apc, cvalue, piosb, code,
2717 in_buff, in_size, out_buff, out_size );
2718 if (status == STATUS_PENDING && !overlapped)
2719 {
2720 if (WaitForSingleObject( event, INFINITE ) == WAIT_FAILED)
2721 return -1;
2722 status = piosb->u.Status;
2723 }
2724 if (status == STATUS_NOT_SUPPORTED)
2725 {
2726 FIXME("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
2727 code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
2728 }
2729 else if (status == STATUS_SUCCESS)
2730 *ret_size = piosb->Information;
2731
2732 return NtStatusToWSAError( status );
2733 }
2734
2735
2736 /**********************************************************************
2737 * WSAIoctl (WS2_32.50)
2738 *
2739 */
2740 INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID out_buff,
2741 DWORD out_size, LPDWORD ret_size, LPWSAOVERLAPPED overlapped,
2742 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
2743 {
2744 TRACE("%04lx, %s, %p, %d, %p, %d, %p, %p, %p\n",
2745 s, debugstr_wsaioctl(code), in_buff, in_size, out_buff, out_size, ret_size, overlapped, completion);
2746
2747 if (!ret_size)
2748 {
2749 SetLastError( WSAEFAULT );
2750 return -1;
2751 }
2752
2753 switch (code)
2754 {
2755 case WS_FIONBIO:
2756 {
2757 DWORD ret;
2758
2759 if (IS_INTRESOURCE( in_buff ))
2760 {
2761 SetLastError( WSAEFAULT );
2762 return -1;
2763 }
2764
2765 /* Explicitly ignore the output buffer; WeChat tries to pass an address
2766 * without write access. */
2767 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_FIONBIO, in_buff, in_size,
2768 NULL, 0, ret_size, overlapped, completion );
2769 SetLastError( ret );
2770 return ret ? -1 : 0;
2771 }
2772
2773 case WS_FIONREAD:
2774 {
2775 DWORD ret;
2776
2777 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_FIONREAD, in_buff, in_size,
2778 out_buff, out_size, ret_size, overlapped, completion );
2779 SetLastError( ret );
2780 if (!ret) *ret_size = sizeof(WS_u_long);
2781 return ret ? -1 : 0;
2782 }
2783
2784 case WS_SIOCATMARK:
2785 {
2786 DWORD ret;
2787
2788 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_SIOCATMARK, in_buff, in_size,
2789 out_buff, out_size, ret_size, overlapped, completion );
2790 SetLastError( ret );
2791 if (!ret) *ret_size = sizeof(WS_u_long);
2792 return ret ? -1 : 0;
2793 }
2794
2795 case WS_SIO_GET_INTERFACE_LIST:
2796 {
2797 DWORD ret;
2798
2799 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_GET_INTERFACE_LIST, in_buff, in_size,
2800 out_buff, out_size, ret_size, overlapped, completion );
2801 SetLastError( ret );
2802 if (ret && ret != ERROR_IO_PENDING) *ret_size = 0;
2803 return ret ? -1 : 0;
2804 }
2805
2806 case WS_SIO_ADDRESS_LIST_QUERY:
2807 {
2808 DWORD size, total;
2809
2810 TRACE("-> SIO_ADDRESS_LIST_QUERY request\n");
2811
2812 if (out_size && out_size < FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]))
2813 {
2814 *ret_size = 0;
2815 SetLastError(WSAEINVAL);
2816 return SOCKET_ERROR;
2817 }
2818
2819 if (GetAdaptersInfo(NULL, &size) == ERROR_BUFFER_OVERFLOW)
2820 {
2821 IP_ADAPTER_INFO *p, *table = HeapAlloc(GetProcessHeap(), 0, size);
2822 NTSTATUS status = STATUS_SUCCESS;
2823 SOCKET_ADDRESS_LIST *sa_list;
2824 SOCKADDR_IN *sockaddr;
2825 SOCKET_ADDRESS *sa;
2826 unsigned int i;
2827 DWORD ret = 0;
2828 DWORD num;
2829
2830 if (!table || GetAdaptersInfo(table, &size))
2831 {
2832 HeapFree(GetProcessHeap(), 0, table);
2833 SetLastError( WSAEINVAL );
2834 return -1;
2835 }
2836
2837 for (p = table, num = 0; p; p = p->Next)
2838 if (p->IpAddressList.IpAddress.String[0]) num++;
2839
2840 total = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[num]) + num * sizeof(*sockaddr);
2841 if (total > out_size || !out_buff)
2842 {
2843 *ret_size = total;
2844 HeapFree(GetProcessHeap(), 0, table);
2845 SetLastError( WSAEFAULT );
2846 return -1;
2847 }
2848
2849 sa_list = out_buff;
2850 sa = sa_list->Address;
2851 sockaddr = (SOCKADDR_IN *)&sa[num];
2852 sa_list->iAddressCount = num;
2853
2854 for (p = table, i = 0; p; p = p->Next)
2855 {
2856 if (!p->IpAddressList.IpAddress.String[0]) continue;
2857
2858 sa[i].lpSockaddr = (SOCKADDR *)&sockaddr[i];
2859 sa[i].iSockaddrLength = sizeof(SOCKADDR);
2860
2861 sockaddr[i].sin_family = WS_AF_INET;
2862 sockaddr[i].sin_port = 0;
2863 sockaddr[i].sin_addr.WS_s_addr = inet_addr(p->IpAddressList.IpAddress.String);
2864 i++;
2865 }
2866
2867 HeapFree(GetProcessHeap(), 0, table);
2868
2869 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2870 NULL, 0, ret_size, overlapped, completion );
2871 *ret_size = total;
2872 SetLastError( ret );
2873 return ret ? -1 : 0;
2874 }
2875 else
2876 {
2877 WARN("unable to get IP address list\n");
2878 SetLastError( WSAEINVAL );
2879 return -1;
2880 }
2881 }
2882
2883 case WS_SIO_GET_EXTENSION_FUNCTION_POINTER:
2884 {
2885 #define EXTENSION_FUNCTION(x, y) { x, y, #y },
2886 static const struct
2887 {
2888 GUID guid;
2889 void *func_ptr;
2890 const char *name;
2891 } guid_funcs[] = {
2892 EXTENSION_FUNCTION(WSAID_CONNECTEX, WS2_ConnectEx)
2893 EXTENSION_FUNCTION(WSAID_DISCONNECTEX, WS2_DisconnectEx)
2894 EXTENSION_FUNCTION(WSAID_ACCEPTEX, WS2_AcceptEx)
2895 EXTENSION_FUNCTION(WSAID_GETACCEPTEXSOCKADDRS, WS2_GetAcceptExSockaddrs)
2896 EXTENSION_FUNCTION(WSAID_TRANSMITFILE, WS2_TransmitFile)
2897 /* EXTENSION_FUNCTION(WSAID_TRANSMITPACKETS, WS2_TransmitPackets) */
2898 EXTENSION_FUNCTION(WSAID_WSARECVMSG, WS2_WSARecvMsg)
2899 EXTENSION_FUNCTION(WSAID_WSASENDMSG, WSASendMsg)
2900 };
2901 #undef EXTENSION_FUNCTION
2902 unsigned int i;
2903
2904 for (i = 0; i < ARRAY_SIZE(guid_funcs); i++)
2905 {
2906 if (IsEqualGUID(&guid_funcs[i].guid, in_buff))
2907 {
2908 NTSTATUS status = STATUS_SUCCESS;
2909 DWORD ret = 0;
2910
2911 TRACE( "returning %s\n", guid_funcs[i].name );
2912 *(void **)out_buff = guid_funcs[i].func_ptr;
2913
2914 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2915 NULL, 0, ret_size, overlapped, completion );
2916 *ret_size = sizeof(void *);
2917 SetLastError( ret );
2918 return ret ? -1 : 0;
2919 }
2920 }
2921
2922 FIXME("SIO_GET_EXTENSION_FUNCTION_POINTER %s: stub\n", debugstr_guid(in_buff));
2923 SetLastError( WSAEINVAL );
2924 return -1;
2925 }
2926
2927 case WS_SIO_KEEPALIVE_VALS:
2928 {
2929 DWORD ret;
2930
2931 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_KEEPALIVE_VALS, in_buff, in_size,
2932 out_buff, out_size, ret_size, overlapped, completion );
2933 if (!overlapped || completion) *ret_size = 0;
2934 SetLastError( ret );
2935 return ret ? -1 : 0;
2936 }
2937
2938 case WS_SIO_ROUTING_INTERFACE_QUERY:
2939 {
2940 struct WS_sockaddr *daddr = (struct WS_sockaddr *)in_buff;
2941 struct WS_sockaddr_in *daddr_in = (struct WS_sockaddr_in *)daddr;
2942 struct WS_sockaddr_in *saddr_in = out_buff;
2943 MIB_IPFORWARDROW row;
2944 PMIB_IPADDRTABLE ipAddrTable = NULL;
2945 DWORD size, i, found_index, ret = 0;
2946 NTSTATUS status = STATUS_SUCCESS;
2947
2948 TRACE( "-> WS_SIO_ROUTING_INTERFACE_QUERY request\n" );
2949
2950 if (!in_buff || in_size < sizeof(struct WS_sockaddr) ||
2951 !out_buff || out_size < sizeof(struct WS_sockaddr_in))
2952 {
2953 SetLastError( WSAEFAULT );
2954 return -1;
2955 }
2956 if (daddr->sa_family != WS_AF_INET)
2957 {
2958 FIXME("unsupported address family %d\n", daddr->sa_family);
2959 SetLastError( WSAEAFNOSUPPORT );
2960 return -1;
2961 }
2962 if (GetBestRoute( daddr_in->sin_addr.S_un.S_addr, 0, &row ) != NOERROR ||
2963 GetIpAddrTable( NULL, &size, FALSE ) != ERROR_INSUFFICIENT_BUFFER)
2964 {
2965 SetLastError( WSAEFAULT );
2966 return -1;
2967 }
2968 ipAddrTable = HeapAlloc( GetProcessHeap(), 0, size );
2969 if (GetIpAddrTable( ipAddrTable, &size, FALSE ))
2970 {
2971 HeapFree( GetProcessHeap(), 0, ipAddrTable );
2972 SetLastError( WSAEFAULT );
2973 return -1;
2974 }
2975 for (i = 0, found_index = ipAddrTable->dwNumEntries;
2976 i < ipAddrTable->dwNumEntries; i++)
2977 {
2978 if (ipAddrTable->table[i].dwIndex == row.dwForwardIfIndex)
2979 found_index = i;
2980 }
2981 if (found_index == ipAddrTable->dwNumEntries)
2982 {
2983 ERR("no matching IP address for interface %d\n",
2984 row.dwForwardIfIndex);
2985 HeapFree( GetProcessHeap(), 0, ipAddrTable );
2986 SetLastError( WSAEFAULT );
2987 return -1;
2988 }
2989 saddr_in->sin_family = WS_AF_INET;
2990 saddr_in->sin_addr.S_un.S_addr = ipAddrTable->table[found_index].dwAddr;
2991 saddr_in->sin_port = 0;
2992 HeapFree( GetProcessHeap(), 0, ipAddrTable );
2993
2994 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
2995 NULL, 0, ret_size, overlapped, completion );
2996 if (!ret) *ret_size = sizeof(struct WS_sockaddr_in);
2997 SetLastError( ret );
2998 return ret ? -1 : 0;
2999 }
3000
3001 case WS_SIO_ADDRESS_LIST_CHANGE:
3002 {
3003 int force_async = !!overlapped;
3004 DWORD ret;
3005
3006 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_ADDRESS_LIST_CHANGE, &force_async, sizeof(force_async),
3007 out_buff, out_size, ret_size, overlapped, completion );
3008 SetLastError( ret );
3009 return ret ? -1 : 0;
3010 }
3011
3012 case WS_SIO_UDP_CONNRESET:
3013 {
3014 NTSTATUS status = STATUS_SUCCESS;
3015 DWORD ret;
3016
3017 FIXME( "WS_SIO_UDP_CONNRESET stub\n" );
3018 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
3019 NULL, 0, ret_size, overlapped, completion );
3020 SetLastError( ret );
3021 return ret ? -1 : 0;
3022 }
3023
3024 case WS_SIO_BASE_HANDLE:
3025 {
3026 NTSTATUS status;
3027 DWORD ret;
3028
3029 if (overlapped)
3030 {
3031 status = STATUS_NOT_SUPPORTED;
3032 }
3033 else
3034 {
3035 status = STATUS_SUCCESS;
3036 *(SOCKET *)out_buff = s;
3037 }
3038 ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
3039 NULL, 0, ret_size, overlapped, completion );
3040 if (overlapped) ret = ERROR_IO_PENDING;
3041 if (!ret) *ret_size = sizeof(SOCKET);
3042 SetLastError( ret );
3043 return ret ? -1 : 0;
3044 }
3045
3046 default:
3047 FIXME( "unimplemented ioctl %s\n", debugstr_wsaioctl( code ) );
3048 /* fall through */
3049 case LOWORD(WS_FIONBIO): /* Netscape tries to use this */
3050 case WS_SIO_SET_COMPATIBILITY_MODE:
3051 {
3052 NTSTATUS status = STATUS_NOT_SUPPORTED;
3053
3054 server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status),
3055 NULL, 0, ret_size, overlapped, completion );
3056 if (overlapped)
3057 {
3058 SetLastError( ERROR_IO_PENDING );
3059 }
3060 else
3061 {
3062 *ret_size = 0;
3063 SetLastError( WSAEOPNOTSUPP );
3064 }
3065 return -1;
3066 }
3067 }
3068 }
3069
3070
3071 /***********************************************************************
3072 * ioctlsocket (WS2_32.10)
3073 */
3074 int WINAPI WS_ioctlsocket(SOCKET s, LONG cmd, WS_u_long *argp)
3075 {
3076 DWORD ret_size;
3077 return WSAIoctl( s, cmd, argp, sizeof(WS_u_long), argp, sizeof(WS_u_long), &ret_size, NULL, NULL );
3078 }
3079
3080
3081 /***********************************************************************
3082 * listen (ws2_32.13)
3083 */
3084 int WINAPI WS_listen( SOCKET s, int backlog )
3085 {
3086 struct afd_listen_params params = {.backlog = backlog};
3087 IO_STATUS_BLOCK io;
3088 NTSTATUS status;
3089
3090 TRACE( "socket %#lx, backlog %d\n", s, backlog );
3091
3092 status = NtDeviceIoControlFile( SOCKET2HANDLE(s), NULL, NULL, NULL, &io,
3093 IOCTL_AFD_LISTEN, &params, sizeof(params), NULL, 0 );
3094 SetLastError( NtStatusToWSAError( status ) );
3095 return status ? -1 : 0;
3096 }
3097
3098
3099 /***********************************************************************
3100 * recv (WS2_32.16)
3101 */
3102 int WINAPI WS_recv(SOCKET s, char *buf, int len, int flags)
3103 {
3104 DWORD n, dwFlags = flags;
3105 WSABUF wsabuf;
3106
3107 wsabuf.len = len;
3108 wsabuf.buf = buf;
3109
3110 if ( WS2_recv_base(s, &wsabuf, 1, &n, &dwFlags, NULL, NULL, NULL, NULL, NULL) == SOCKET_ERROR )
3111 return SOCKET_ERROR;
3112 else
3113 return n;
3114 }
3115
3116 /***********************************************************************
3117 * recvfrom (WS2_32.17)
3118 */
3119 int WINAPI WS_recvfrom(SOCKET s, char *buf, INT len, int flags,
3120 struct WS_sockaddr *from, int *fromlen)
3121 {
3122 DWORD n, dwFlags = flags;
3123 WSABUF wsabuf;
3124
3125 wsabuf.len = len;
3126 wsabuf.buf = buf;
3127
3128 if ( WS2_recv_base(s, &wsabuf, 1, &n, &dwFlags, from, fromlen, NULL, NULL, NULL) == SOCKET_ERROR )
3129 return SOCKET_ERROR;
3130 else
3131 return n;
3132 }
3133
3134
3135 /* as FD_SET(), but returns 1 if the fd was added, 0 otherwise */
3136 static int add_fd_to_set( SOCKET fd, struct WS_fd_set *set )
3137 {
3138 unsigned int i;
3139
3140 for (i = 0; i < set->fd_count; ++i)
3141 {
3142 if (set->fd_array[i] == fd)
3143 return 0;
3144 }
3145
3146 if (set->fd_count < WS_FD_SETSIZE)
3147 {
3148 set->fd_array[set->fd_count++] = fd;
3149 return 1;
3150 }
3151
3152 return 0;
3153 }
3154
3155
3156 /***********************************************************************
3157 * select (ws2_32.18)
3158 */
3159 int WINAPI WS_select( int count, WS_fd_set *read_ptr, WS_fd_set *write_ptr,
3160 WS_fd_set *except_ptr, const struct WS_timeval *timeout)
3161 {
3162 char buffer[offsetof( struct afd_poll_params, sockets[WS_FD_SETSIZE * 3] )] = {0};
3163 struct afd_poll_params *params = (struct afd_poll_params *)buffer;
3164 struct WS_fd_set read, write, except;
3165 ULONG params_size, i, j;
3166 SOCKET poll_socket = 0;
3167 IO_STATUS_BLOCK io;
3168 HANDLE sync_event;
3169 int ret_count = 0;
3170 NTSTATUS status;
3171
3172 TRACE( "read %p, write %p, except %p, timeout %p\n", read_ptr, write_ptr, except_ptr, timeout );
3173
3174 WS_FD_ZERO( &read );
3175 WS_FD_ZERO( &write );
3176 WS_FD_ZERO( &except );
3177 if (read_ptr) read = *read_ptr;
3178 if (write_ptr) write = *write_ptr;
3179 if (except_ptr) except = *except_ptr;
3180
3181 if (!(sync_event = get_sync_event())) return -1;
3182
3183 if (timeout)
3184 params->timeout = timeout->tv_sec * -10000000 + timeout->tv_usec * -10;
3185 else
3186 params->timeout = TIMEOUT_INFINITE;
3187
3188 for (i = 0; i < read.fd_count; ++i)
3189 {
3190 params->sockets[params->count].socket = read.fd_array[i];
3191 params->sockets[params->count].flags = AFD_POLL_READ | AFD_POLL_ACCEPT | AFD_POLL_HUP;
3192 ++params->count;
3193 poll_socket = read.fd_array[i];
3194 }
3195
3196 for (i = 0; i < write.fd_count; ++i)
3197 {
3198 params->sockets[params->count].socket = write.fd_array[i];
3199 params->sockets[params->count].flags = AFD_POLL_WRITE;
3200 ++params->count;
3201 poll_socket = write.fd_array[i];
3202 }
3203
3204 for (i = 0; i < except.fd_count; ++i)
3205 {
3206 params->sockets[params->count].socket = except.fd_array[i];
3207 params->sockets[params->count].flags = AFD_POLL_OOB | AFD_POLL_CONNECT_ERR;
3208 ++params->count;
3209 poll_socket = except.fd_array[i];
3210 }
3211
3212 if (!params->count)
3213 {
3214 SetLastError( WSAEINVAL );
3215 return -1;
3216 }
3217
3218 params_size = offsetof( struct afd_poll_params, sockets[params->count] );
3219
3220 status = NtDeviceIoControlFile( (HANDLE)poll_socket, sync_event, NULL, NULL, &io,
3221 IOCTL_AFD_POLL, params, params_size, params, params_size );
3222 if (status == STATUS_PENDING)
3223 {
3224 if (WaitForSingleObject( sync_event, INFINITE ) == WAIT_FAILED)
3225 return -1;
3226 status = io.u.Status;
3227 }
3228 if (status == STATUS_TIMEOUT) status = STATUS_SUCCESS;
3229 if (!status)
3230 {
3231 /* pointers may alias, so clear them all first */
3232 if (read_ptr) WS_FD_ZERO( read_ptr );
3233 if (write_ptr) WS_FD_ZERO( write_ptr );
3234 if (except_ptr) WS_FD_ZERO( except_ptr );
3235
3236 for (i = 0; i < params->count; ++i)
3237 {
3238 unsigned int flags = params->sockets[i].flags;
3239 SOCKET s = params->sockets[i].socket;
3240
3241 for (j = 0; j < read.fd_count; ++j)
3242 {
3243 if (read.fd_array[j] == s
3244 && (flags & (AFD_POLL_READ | AFD_POLL_ACCEPT | AFD_POLL_HUP | AFD_POLL_CLOSE)))
3245 {
3246 ret_count += add_fd_to_set( s, read_ptr );
3247 flags &= ~AFD_POLL_CLOSE;
3248 }
3249 }
3250
3251 if (flags & AFD_POLL_CLOSE)
3252 status = STATUS_INVALID_HANDLE;
3253
3254 for (j = 0; j < write.fd_count; ++j)
3255 {
3256 if (write.fd_array[j] == s && (flags & AFD_POLL_WRITE))
3257 ret_count += add_fd_to_set( s, write_ptr );
3258 }
3259
3260 for (j = 0; j < except.fd_count; ++j)
3261 {
3262 if (except.fd_array[j] == s && (flags & (AFD_POLL_OOB | AFD_POLL_CONNECT_ERR)))
3263 ret_count += add_fd_to_set( s, except_ptr );
3264 }
3265 }
3266 }
3267
3268 SetLastError( NtStatusToWSAError( status ) );
3269 return status ? -1 : ret_count;
3270 }
3271
3272
3273 static unsigned int afd_poll_flag_to_win32( unsigned int flags )
3274 {
3275 static const unsigned int map[] =
3276 {
3277 FD_READ, /* READ */
3278 FD_OOB, /* OOB */
3279 FD_WRITE, /* WRITE */
3280 FD_CLOSE, /* HUP */
3281 FD_CLOSE, /* RESET */
3282 0, /* CLOSE */
3283 FD_CONNECT, /* CONNECT */
3284 FD_ACCEPT, /* ACCEPT */
3285 FD_CONNECT, /* CONNECT_ERR */
3286 };
3287
3288 unsigned int i, ret = 0;
3289
3290 for (i = 0; i < ARRAY_SIZE(map); ++i)
3291 {
3292 if (flags & (1 << i)) ret |= map[i];
3293 }
3294
3295 return ret;
3296 }
3297
3298
3299 /***********************************************************************
3300 * WSAPoll (ws2_32.@)
3301 */
3302 int WINAPI WSAPoll( WSAPOLLFD *fds, ULONG count, int timeout )
3303 {
3304 struct afd_poll_params *params;
3305 ULONG params_size, i, j;
3306 SOCKET poll_socket = 0;
3307 IO_STATUS_BLOCK io;
3308 HANDLE sync_event;
3309 int ret_count = 0;
3310 NTSTATUS status;
3311
3312 if (!count)
3313 {
3314 SetLastError(WSAEINVAL);
3315 return SOCKET_ERROR;
3316 }
3317 if (!fds)
3318 {
3319 SetLastError(WSAEFAULT);
3320 return SOCKET_ERROR;
3321 }
3322
3323 if (!(sync_event = get_sync_event())) return -1;
3324
3325 params_size = offsetof( struct afd_poll_params, sockets[count] );
3326 if (!(params = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, params_size )))
3327 {
3328 SetLastError(WSAENOBUFS);
3329 return SOCKET_ERROR;
3330 }
3331
3332 params->timeout = (timeout >= 0 ? timeout * -10000 : TIMEOUT_INFINITE);
3333
3334 for (i = 0; i < count; ++i)
3335 {
3336 unsigned int flags = AFD_POLL_HUP | AFD_POLL_RESET | AFD_POLL_CONNECT_ERR;
3337
3338 if ((INT_PTR)fds[i].fd < 0 || !socket_list_find( fds[i].fd ))
3339 {
3340 fds[i].revents = WS_POLLNVAL;
3341 continue;
3342 }
3343
3344 poll_socket = fds[i].fd;
3345 params->sockets[params->count].socket = fds[i].fd;
3346
3347 if (fds[i].events & WS_POLLRDNORM)
3348 flags |= AFD_POLL_ACCEPT | AFD_POLL_READ;
3349 if (fds[i].events & WS_POLLRDBAND)
3350 flags |= AFD_POLL_OOB;
3351 if (fds[i].events & WS_POLLWRNORM)
3352 flags |= AFD_POLL_WRITE;
3353 params->sockets[params->count].flags = flags;
3354 ++params->count;
3355
3356 fds[i].revents = 0;
3357 }
3358
3359 if (!poll_socket)
3360 {
3361 SetLastError( WSAENOTSOCK );
3362 HeapFree( GetProcessHeap(), 0, params );
3363 return -1;
3364 }
3365
3366 status = NtDeviceIoControlFile( (HANDLE)poll_socket, sync_event, NULL, NULL, &io, IOCTL_AFD_POLL,
3367 params, params_size, params, params_size );
3368 if (status == STATUS_PENDING)
3369 {
3370 if (WaitForSingleObject( sync_event, INFINITE ) == WAIT_FAILED)
3371 {
3372 HeapFree( GetProcessHeap(), 0, params );
3373 return -1;
3374 }
3375 status = io.u.Status;
3376 }
3377 if (!status)
3378 {
3379 for (i = 0; i < count; ++i)
3380 {
3381 for (j = 0; j < params->count; ++j)
3382 {
3383 if (fds[i].fd == params->sockets[j].socket)
3384 {
3385 unsigned int revents = 0;
3386
3387 if (params->sockets[j].flags & (AFD_POLL_ACCEPT | AFD_POLL_READ))
3388 revents |= WS_POLLRDNORM;
3389 if (params->sockets[j].flags & AFD_POLL_OOB)
3390 revents |= WS_POLLRDBAND;
3391 if (params->sockets[j].flags & AFD_POLL_WRITE)
3392 revents |= WS_POLLWRNORM;
3393 if (params->sockets[j].flags & AFD_POLL_HUP)
3394 revents |= WS_POLLHUP;
3395 if (params->sockets[j].flags & (AFD_POLL_RESET | AFD_POLL_CONNECT_ERR))
3396 revents |= WS_POLLERR;
3397 if (params->sockets[j].flags & AFD_POLL_CLOSE)
3398 revents |= WS_POLLNVAL;
3399
3400 fds[i].revents = revents & (fds[i].events | WS_POLLHUP | WS_POLLERR | WS_POLLNVAL);
3401
3402 if (fds[i].revents)
3403 ++ret_count;
3404 }
3405 }
3406 }
3407 }
3408 if (status == STATUS_TIMEOUT) status = STATUS_SUCCESS;
3409
3410 HeapFree( GetProcessHeap(), 0, params );
3411
3412 SetLastError( NtStatusToWSAError( status ) );
3413 return status ? -1 : ret_count;
3414 }
3415
3416
3417 /***********************************************************************
3418 * send (WS2_32.19)
3419 */
3420 int WINAPI WS_send(SOCKET s, const char *buf, int len, int flags)
3421 {
3422 DWORD n;
3423 WSABUF wsabuf;
3424
3425 wsabuf.len = len;
3426 wsabuf.buf = (char*) buf;
3427
3428 if ( WS2_sendto( s, &wsabuf, 1, &n, flags, NULL, 0, NULL, NULL) == SOCKET_ERROR )
3429 return SOCKET_ERROR;
3430 else
3431 return n;
3432 }
3433
3434 /***********************************************************************
3435 * WSASend (WS2_32.72)
3436 */
3437 INT WINAPI WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
3438 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
3439 LPWSAOVERLAPPED lpOverlapped,
3440 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
3441 {
3442 return WS2_sendto( s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags,
3443 NULL, 0, lpOverlapped, lpCompletionRoutine );
3444 }
3445
3446 /***********************************************************************
3447 * WSASendDisconnect (WS2_32.73)
3448 */
3449 INT WINAPI WSASendDisconnect( SOCKET s, LPWSABUF lpBuffers )
3450 {
3451 return WS_shutdown( s, SD_SEND );
3452 }
3453
3454
3455 /***********************************************************************
3456 * WSASendTo (WS2_32.74)
3457 */
3458 INT WINAPI WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
3459 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
3460 const struct WS_sockaddr *to, int tolen,
3461 LPWSAOVERLAPPED lpOverlapped,
3462 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
3463 {
3464 /* Garena hooks WSASendTo(), so we need a wrapper */
3465 return WS2_sendto( s, lpBuffers, dwBufferCount,
3466 lpNumberOfBytesSent, dwFlags,
3467 to, tolen,
3468 lpOverlapped, lpCompletionRoutine );
3469 }
3470
3471 /***********************************************************************
3472 * sendto (WS2_32.20)
3473 */
3474 int WINAPI WS_sendto(SOCKET s, const char *buf, int len, int flags,
3475 const struct WS_sockaddr *to, int tolen)
3476 {
3477 DWORD n;
3478 WSABUF wsabuf;
3479
3480 wsabuf.len = len;
3481 wsabuf.buf = (char*) buf;
3482
3483 if ( WS2_sendto(s, &wsabuf, 1, &n, flags, to, tolen, NULL, NULL) == SOCKET_ERROR )
3484 return SOCKET_ERROR;
3485 else
3486 return n;
3487 }
3488
3489
3490 static int server_setsockopt( SOCKET s, ULONG code, const char *optval, int optlen )
3491 {
3492 IO_STATUS_BLOCK io;
3493 NTSTATUS status;
3494
3495 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, code, (void *)optval, optlen, NULL, 0 );
3496 SetLastError( NtStatusToWSAError( status ) );
3497 return status ? -1 : 0;
3498 }
3499
3500
3501 /***********************************************************************
3502 * setsockopt (WS2_32.21)
3503 */
3504 int WINAPI WS_setsockopt(SOCKET s, int level, int optname,
3505 const char *optval, int optlen)
3506 {
3507 int fd;
3508 int woptval;
3509 struct timeval tval;
3510 struct ip_mreq_source mreq_source;
3511
3512 TRACE("(socket %04lx, %s, optval %s, optlen %d)\n", s,
3513 debugstr_sockopt(level, optname), debugstr_optval(optval, optlen),
3514 optlen);
3515
3516 /* some broken apps pass the value directly instead of a pointer to it */
3517 if(optlen && IS_INTRESOURCE(optval))
3518 {
3519 SetLastError(WSAEFAULT);
3520 return SOCKET_ERROR;
3521 }
3522
3523 switch(level)
3524 {
3525 case WS_SOL_SOCKET:
3526 switch(optname)
3527 {
3528 case WS_SO_BROADCAST:
3529 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_BROADCAST, optval, optlen );
3530
3531 case WS_SO_DONTLINGER:
3532 {
3533 struct WS_linger linger;
3534
3535 if (!optval)
3536 {
3537 SetLastError( WSAEFAULT );
3538 return -1;
3539 }
3540
3541 linger.l_onoff = !*(const BOOL *)optval;
3542 linger.l_linger = 0;
3543 return WS_setsockopt( s, WS_SOL_SOCKET, WS_SO_LINGER, (char *)&linger, sizeof(linger) );
3544 }
3545
3546 case WS_SO_ERROR:
3547 FIXME( "SO_ERROR, stub!\n" );
3548 SetLastError( WSAENOPROTOOPT );
3549 return -1;
3550
3551 case WS_SO_KEEPALIVE:
3552 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_KEEPALIVE, optval, optlen );
3553
3554 case WS_SO_LINGER:
3555 return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_LINGER, optval, optlen );
3556
3557 /* Some options need some conversion before they can be sent to
3558 * setsockopt. The conversions are done here, then they will fall through
3559 * to the general case. Special options that are not passed to
3560 * setsockopt follow below that.*/
3561
3562 case WS_SO_SNDBUF:
3563 if (!*(const int *)optval)
3564 {
3565 FIXME("SO_SNDBUF ignoring request to disable send buffering\n");
3566 #ifdef __APPLE__
3567 return 0;
3568 #endif
3569 }
3570 convert_sockopt(&level, &optname);
3571 break;
3572
3573 case WS_SO_RCVBUF:
3574 if (*(const int*)optval < 2048)
3575 {
3576 WARN("SO_RCVBF for %d bytes is too small: ignored\n", *(const int*)optval );
3577 return 0;
3578 }
3579 /* Fall through */
3580
3581 /* The options listed here don't need any special handling. Thanks to
3582 * the conversion happening above, options from there will fall through
3583 * to this, too.*/
3584 case WS_SO_OOBINLINE:
3585 /* BSD socket SO_REUSEADDR is not 100% compatible to winsock semantics.
3586 * however, using it the BSD way fixes bug 8513 and seems to be what
3587 * most programmers assume, anyway */
3588 case WS_SO_REUSEADDR:
3589 convert_sockopt(&level, &optname);
3590 break;
3591
3592 /* SO_DEBUG is a privileged operation, ignore it. */
3593 case WS_SO_DEBUG:
3594 TRACE("Ignoring SO_DEBUG\n");
3595 return 0;
3596
3597 /* For some reason the game GrandPrixLegends does set SO_DONTROUTE on its
3598 * socket. According to MSDN, this option is silently ignored.*/
3599 case WS_SO_DONTROUTE:
3600 TRACE("Ignoring SO_DONTROUTE\n");
3601 return 0;
3602
3603 /* Stops two sockets from being bound to the same port. Always happens
3604 * on unix systems, so just drop it. */
3605 case WS_SO_EXCLUSIVEADDRUSE:
3606 TRACE("Ignoring SO_EXCLUSIVEADDRUSE, is always set.\n");
3607 return 0;
3608
3609 /* After a ConnectEx call succeeds, the socket can't be used with half of the
3610 * normal winsock functions on windows. We don't have that problem. */
3611 case WS_SO_UPDATE_CONNECT_CONTEXT:
3612 TRACE("Ignoring SO_UPDATE_CONNECT_CONTEXT, since our sockets are normal\n");
3613 return 0;
3614
3615 /* After a AcceptEx call succeeds, the socket can't be used with half of the
3616 * normal winsock functions on windows. We don't have that problem. */
3617 case WS_SO_UPDATE_ACCEPT_CONTEXT:
3618 TRACE("Ignoring SO_UPDATE_ACCEPT_CONTEXT, since our sockets are normal\n");
3619 return 0;
3620
3621 /* SO_OPENTYPE does not require a valid socket handle. */
3622 case WS_SO_OPENTYPE:
3623 if (!optlen || optlen < sizeof(int) || !optval)
3624 {
3625 SetLastError(WSAEFAULT);
3626 return SOCKET_ERROR;
3627 }
3628 get_per_thread_data()->opentype = *(const int *)optval;
3629 TRACE("setting global SO_OPENTYPE = 0x%x\n", *((const int*)optval) );
3630 return 0;
3631
3632 #ifdef SO_RCVTIMEO
3633 case WS_SO_RCVTIMEO:
3634 #endif
3635 #ifdef SO_SNDTIMEO
3636 case WS_SO_SNDTIMEO:
3637 #endif
3638 #if defined(SO_RCVTIMEO) || defined(SO_SNDTIMEO)
3639 if (optval && optlen == sizeof(UINT32)) {
3640 /* WinSock passes milliseconds instead of struct timeval */
3641 tval.tv_usec = (*(const UINT32*)optval % 1000) * 1000;
3642 tval.tv_sec = *(const UINT32*)optval / 1000;
3643 /* min of 500 milliseconds */
3644 if (tval.tv_sec == 0 && tval.tv_usec && tval.tv_usec < 500000)
3645 tval.tv_usec = 500000;
3646 optlen = sizeof(struct timeval);
3647 optval = (char*)&tval;
3648 } else if (optlen == sizeof(struct timeval)) {
3649 WARN("SO_SND/RCVTIMEO for %d bytes: assuming unixism\n", optlen);
3650 } else {
3651 WARN("SO_SND/RCVTIMEO for %d bytes is weird: ignored\n", optlen);
3652 return 0;
3653 }
3654 convert_sockopt(&level, &optname);
3655 break;
3656 #endif
3657
3658 case WS_SO_RANDOMIZE_PORT:
3659 FIXME("Ignoring WS_SO_RANDOMIZE_PORT\n");
3660 return 0;
3661
3662 case WS_SO_PORT_SCALABILITY:
3663 FIXME("Ignoring WS_SO_PORT_SCALABILITY\n");
3664 return 0;
3665
3666 case WS_SO_REUSE_UNICASTPORT:
3667 FIXME("Ignoring WS_SO_REUSE_UNICASTPORT\n");
3668 return 0;
3669
3670 case WS_SO_REUSE_MULTICASTPORT:
3671 FIXME("Ignoring WS_SO_REUSE_MULTICASTPORT\n");
3672 return 0;
3673
3674 default:
3675 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
3676 /* fall through */
3677
3678 case WS_SO_ACCEPTCONN:
3679 case WS_SO_TYPE:
3680 SetLastError(WSAENOPROTOOPT);
3681 return SOCKET_ERROR;
3682 }
3683 break; /* case WS_SOL_SOCKET */
3684
3685 #ifdef HAS_IPX
3686 case WS_NSPROTO_IPX:
3687 switch(optname)
3688 {
3689 case WS_IPX_PTYPE:
3690 return set_ipx_packettype(s, *(int*)optval);
3691
3692 case WS_IPX_FILTERPTYPE:
3693 /* Sets the receive filter packet type, at the moment we don't support it */
3694 FIXME("IPX_FILTERPTYPE: %x\n", *optval);
3695 /* Returning 0 is better for now than returning a SOCKET_ERROR */
3696 return 0;
3697
3698 default:
3699 FIXME("opt_name:%x\n", optname);
3700 return SOCKET_ERROR;
3701 }
3702 break; /* case WS_NSPROTO_IPX */
3703 #endif
3704
3705 /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */
3706 case WS_IPPROTO_TCP:
3707 switch(optname)
3708 {
3709 case WS_TCP_NODELAY:
3710 convert_sockopt(&level, &optname);
3711 break;
3712 default:
3713 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
3714 return SOCKET_ERROR;
3715 }
3716 break;
3717
3718 case WS_IPPROTO_IP:
3719 switch(optname)
3720 {
3721 case WS_IP_ADD_SOURCE_MEMBERSHIP:
3722 case WS_IP_DROP_SOURCE_MEMBERSHIP:
3723 case WS_IP_BLOCK_SOURCE:
3724 case WS_IP_UNBLOCK_SOURCE:
3725 {
3726 WS_IP_MREQ_SOURCE* val = (void*)optval;
3727 mreq_source.imr_interface.s_addr = val->imr_interface.S_un.S_addr;
3728 mreq_source.imr_multiaddr.s_addr = val->imr_multiaddr.S_un.S_addr;
3729 mreq_source.imr_sourceaddr.s_addr = val->imr_sourceaddr.S_un.S_addr;
3730
3731 optval = (char*)&mreq_source;
3732 optlen = sizeof(mreq_source);
3733
3734 convert_sockopt(&level, &optname);
3735 break;
3736 }
3737 case WS_IP_ADD_MEMBERSHIP:
3738 case WS_IP_DROP_MEMBERSHIP:
3739 #ifdef IP_HDRINCL
3740 case WS_IP_HDRINCL:
3741 #endif
3742 case WS_IP_MULTICAST_IF:
3743 case WS_IP_MULTICAST_LOOP:
3744 case WS_IP_MULTICAST_TTL:
3745 case WS_IP_OPTIONS:
3746 #if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
3747 case WS_IP_PKTINFO:
3748 #endif
3749 case WS_IP_TOS:
3750 case WS_IP_TTL:
3751 #ifdef IP_UNICAST_IF
3752 case WS_IP_UNICAST_IF:
3753 #endif
3754 convert_sockopt(&level, &optname);
3755 break;
3756 case WS_IP_DONTFRAGMENT:
3757 return set_dont_fragment(s, IPPROTO_IP, *(BOOL *)optval) ? 0 : SOCKET_ERROR;
3758 default:
3759 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
3760 return SOCKET_ERROR;
3761 }
3762 break;
3763
3764 case WS_IPPROTO_IPV6:
3765 switch(optname)
3766 {
3767 #ifdef IPV6_ADD_MEMBERSHIP
3768 case WS_IPV6_ADD_MEMBERSHIP:
3769 #endif
3770 #ifdef IPV6_DROP_MEMBERSHIP
3771 case WS_IPV6_DROP_MEMBERSHIP:
3772 #endif
3773 case WS_IPV6_MULTICAST_IF:
3774 case WS_IPV6_MULTICAST_HOPS:
3775 case WS_IPV6_MULTICAST_LOOP:
3776 case WS_IPV6_UNICAST_HOPS:
3777 #ifdef IPV6_UNICAST_IF
3778 case WS_IPV6_UNICAST_IF:
3779 #endif
3780 convert_sockopt(&level, &optname);
3781 break;
3782 case WS_IPV6_DONTFRAG:
3783 return set_dont_fragment(s, IPPROTO_IPV6, *(BOOL *)optval) ? 0 : SOCKET_ERROR;
3784 case WS_IPV6_PROTECTION_LEVEL:
3785 FIXME("IPV6_PROTECTION_LEVEL is ignored!\n");
3786 return 0;
3787 case WS_IPV6_V6ONLY:
3788 {
3789 union generic_unix_sockaddr uaddr;
3790 socklen_t uaddrlen;
3791 int bound;
3792
3793 fd = get_sock_fd( s, 0, NULL );
3794 if (fd == -1) return SOCKET_ERROR;
3795
3796 bound = is_fd_bound(fd, &uaddr, &uaddrlen);
3797 release_sock_fd( s, fd );
3798 if (bound == 0 && uaddr.addr.sa_family == AF_INET)
3799 {
3800 /* Changing IPV6_V6ONLY succeeds on AF_INET (IPv4) socket
3801 * on Windows (with IPv6 support) if the socket is unbound.
3802 * It is essentially a noop, though Windows does store the value
3803 */
3804 WARN("Silently ignoring IPPROTO_IPV6+IPV6_V6ONLY on AF_INET socket\n");
3805 return 0;
3806 }
3807 level = IPPROTO_IPV6;
3808 optname = IPV6_V6ONLY;
3809 break;
3810 }
3811 default:
3812 FIXME("Unknown IPPROTO_IPV6 optname 0x%08x\n", optname);
3813 return SOCKET_ERROR;
3814 }
3815 break;
3816
3817 default:
3818 WARN("Unknown level: 0x%08x\n", level);
3819 SetLastError(WSAEINVAL);
3820 return SOCKET_ERROR;
3821 } /* end switch(level) */
3822
3823 /* avoid endianness issues if argument is a 16-bit int */
3824 if (optval && optlen < sizeof(int))
3825 {
3826 woptval= *((const INT16 *) optval);
3827 optval= (char*) &woptval;
3828 woptval&= (1 << optlen * 8) - 1;
3829 optlen=sizeof(int);
3830 }
3831 fd = get_sock_fd( s, 0, NULL );
3832 if (fd == -1) return SOCKET_ERROR;
3833
3834 if (setsockopt(fd, level, optname, optval, optlen) == 0)
3835 {
3836 #ifdef __APPLE__
3837 if (level == SOL_SOCKET && optname == SO_REUSEADDR &&
3838 setsockopt(fd, level, SO_REUSEPORT, optval, optlen) != 0)
3839 {
3840 SetLastError(wsaErrno());
3841 release_sock_fd( s, fd );
3842 return SOCKET_ERROR;
3843 }
3844 #endif
3845 release_sock_fd( s, fd );
3846 return 0;
3847 }
3848 TRACE("Setting socket error, %d\n", wsaErrno());
3849 SetLastError(wsaErrno());
3850 release_sock_fd( s, fd );
3851
3852 return SOCKET_ERROR;
3853 }
3854
3855
3856 /***********************************************************************
3857 * shutdown (ws2_32.22)
3858 */
3859 int WINAPI WS_shutdown( SOCKET s, int how )
3860 {
3861 IO_STATUS_BLOCK io;
3862 NTSTATUS status;
3863
3864 TRACE( "socket %#lx, how %u\n", s, how );
3865
3866 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io,
3867 IOCTL_AFD_WINE_SHUTDOWN, &how, sizeof(how), NULL, 0 );
3868 SetLastError( NtStatusToWSAError( status ) );
3869 return status ? -1 : 0;
3870 }
3871
3872
3873 /***********************************************************************
3874 * socket (WS2_32.23)
3875 */
3876 SOCKET WINAPI WS_socket(int af, int type, int protocol)
3877 {
3878 TRACE("af=%d type=%d protocol=%d\n", af, type, protocol);
3879
3880 return WSASocketW( af, type, protocol, NULL, 0,
3881 get_per_thread_data()->opentype ? 0 : WSA_FLAG_OVERLAPPED );
3882 }
3883
3884
3885 /***********************************************************************
3886 * WSAEnumNetworkEvents (ws2_32.@)
3887 */
3888 int WINAPI WSAEnumNetworkEvents( SOCKET s, WSAEVENT event, WSANETWORKEVENTS *ret_events )
3889 {
3890 struct afd_get_events_params params;
3891 IO_STATUS_BLOCK io;
3892 NTSTATUS status;
3893
3894 TRACE( "socket %#lx, event %p, events %p\n", s, event, ret_events );
3895
3896 ResetEvent( event );
3897
3898 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_GET_EVENTS,
3899 NULL, 0, &params, sizeof(params) );
3900 if (!status)
3901 {
3902 ret_events->lNetworkEvents = afd_poll_flag_to_win32( params.flags );
3903
3904 if (ret_events->lNetworkEvents & FD_READ)
3905 ret_events->iErrorCode[FD_READ_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_READ] );
3906
3907 if (ret_events->lNetworkEvents & FD_WRITE)
3908 ret_events->iErrorCode[FD_WRITE_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_WRITE] );
3909
3910 if (ret_events->lNetworkEvents & FD_OOB)
3911 ret_events->iErrorCode[FD_OOB_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_OOB] );
3912
3913 if (ret_events->lNetworkEvents & FD_ACCEPT)
3914 ret_events->iErrorCode[FD_ACCEPT_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_ACCEPT] );
3915
3916 if (ret_events->lNetworkEvents & FD_CONNECT)
3917 ret_events->iErrorCode[FD_CONNECT_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_CONNECT_ERR] );
3918
3919 if (ret_events->lNetworkEvents & FD_CLOSE)
3920 {
3921 if (!(ret_events->iErrorCode[FD_CLOSE_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_HUP] )))
3922 ret_events->iErrorCode[FD_CLOSE_BIT] = NtStatusToWSAError( params.status[AFD_POLL_BIT_RESET] );
3923 }
3924 }
3925 SetLastError( NtStatusToWSAError( status ) );
3926 return status ? -1 : 0;
3927 }
3928
3929
3930 static unsigned int afd_poll_flag_from_win32( unsigned int flags )
3931 {
3932 static const unsigned int map[] =
3933 {
3934 AFD_POLL_READ,
3935 AFD_POLL_WRITE,
3936 AFD_POLL_OOB,
3937 AFD_POLL_ACCEPT,
3938 AFD_POLL_CONNECT | AFD_POLL_CONNECT_ERR,
3939 AFD_POLL_RESET | AFD_POLL_HUP,
3940 };
3941
3942 unsigned int i, ret = 0;
3943
3944 for (i = 0; i < ARRAY_SIZE(map); ++i)
3945 {
3946 if (flags & (1 << i)) ret |= map[i];
3947 }
3948
3949 return ret;
3950 }
3951
3952
3953 /***********************************************************************
3954 * WSAEventSelect (ws2_32.@)
3955 */
3956 int WINAPI WSAEventSelect( SOCKET s, WSAEVENT event, LONG mask )
3957 {
3958 struct afd_event_select_params params;
3959 IO_STATUS_BLOCK io;
3960 NTSTATUS status;
3961
3962 TRACE( "socket %#lx, event %p, mask %#x\n", s, event, mask );
3963
3964 params.event = event;
3965 params.mask = afd_poll_flag_from_win32( mask );
3966
3967 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_EVENT_SELECT,
3968 &params, sizeof(params), NULL, 0 );
3969 SetLastError( NtStatusToWSAError( status ) );
3970 return status ? -1 : 0;
3971 }
3972
3973
3974 /**********************************************************************
3975 * WSAGetOverlappedResult (WS2_32.40)
3976 */
3977 BOOL WINAPI WSAGetOverlappedResult( SOCKET s, LPWSAOVERLAPPED lpOverlapped,
3978 LPDWORD lpcbTransfer, BOOL fWait,
3979 LPDWORD lpdwFlags )
3980 {
3981 NTSTATUS status;
3982
3983 TRACE( "socket %04lx ovl %p trans %p, wait %d flags %p\n",
3984 s, lpOverlapped, lpcbTransfer, fWait, lpdwFlags );
3985
3986 if ( lpOverlapped == NULL )
3987 {
3988 ERR( "Invalid pointer\n" );
3989 SetLastError(WSA_INVALID_PARAMETER);
3990 return FALSE;
3991 }
3992
3993 status = lpOverlapped->Internal;
3994 if (status == STATUS_PENDING)
3995 {
3996 if (!fWait)
3997 {
3998 SetLastError( WSA_IO_INCOMPLETE );
3999 return FALSE;
4000 }
4001
4002 if (WaitForSingleObject( lpOverlapped->hEvent ? lpOverlapped->hEvent : SOCKET2HANDLE(s),
4003 INFINITE ) == WAIT_FAILED)
4004 return FALSE;
4005 status = lpOverlapped->Internal;
4006 }
4007
4008 if ( lpcbTransfer )
4009 *lpcbTransfer = lpOverlapped->InternalHigh;
4010
4011 if ( lpdwFlags )
4012 *lpdwFlags = lpOverlapped->u.s.Offset;
4013
4014 SetLastError( NtStatusToWSAError(status) );
4015 return NT_SUCCESS( status );
4016 }
4017
4018
4019 /***********************************************************************
4020 * WSAAsyncSelect (ws2_32.@)
4021 */
4022 int WINAPI WSAAsyncSelect( SOCKET s, HWND window, UINT message, LONG mask )
4023 {
4024 struct afd_message_select_params params;
4025 IO_STATUS_BLOCK io;
4026 NTSTATUS status;
4027
4028 TRACE( "socket %#lx, window %p, message %#x, mask %#x\n", s, window, message, mask );
4029
4030 params.handle = wine_server_obj_handle( (HANDLE)s );
4031 params.window = wine_server_user_handle( window );
4032 params.message = message;
4033 params.mask = afd_poll_flag_from_win32( mask );
4034
4035 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_WINE_MESSAGE_SELECT,
4036 &params, sizeof(params), NULL, 0 );
4037 SetLastError( NtStatusToWSAError( status ) );
4038 return status ? -1 : 0;
4039 }
4040
4041
4042 /***********************************************************************
4043 * WSACreateEvent (WS2_32.31)
4044 *
4045 */
4046 WSAEVENT WINAPI WSACreateEvent(void)
4047 {
4048 /* Create a manual-reset event, with initial state: unsignaled */
4049 TRACE("\n");
4050
4051 return CreateEventW(NULL, TRUE, FALSE, NULL);
4052 }
4053
4054 /***********************************************************************
4055 * WSACloseEvent (WS2_32.29)
4056 *
4057 */
4058 BOOL WINAPI WSACloseEvent(WSAEVENT event)
4059 {
4060 TRACE ("event=%p\n", event);
4061
4062 return CloseHandle(event);
4063 }
4064
4065 /***********************************************************************
4066 * WSASocketA (WS2_32.78)
4067 *
4068 */
4069 SOCKET WINAPI WSASocketA(int af, int type, int protocol,
4070 LPWSAPROTOCOL_INFOA lpProtocolInfo,
4071 GROUP g, DWORD dwFlags)
4072 {
4073 INT len;
4074 WSAPROTOCOL_INFOW info;
4075
4076 TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%x\n",
4077 af, type, protocol, lpProtocolInfo, g, dwFlags);
4078
4079 if (!lpProtocolInfo) return WSASocketW(af, type, protocol, NULL, g, dwFlags);
4080
4081 memcpy(&info, lpProtocolInfo, FIELD_OFFSET(WSAPROTOCOL_INFOW, szProtocol));
4082 len = MultiByteToWideChar(CP_ACP, 0, lpProtocolInfo->szProtocol, -1,
4083 info.szProtocol, WSAPROTOCOL_LEN + 1);
4084
4085 if (!len)
4086 {
4087 SetLastError(WSAEINVAL);
4088 return SOCKET_ERROR;
4089 }
4090
4091 return WSASocketW(af, type, protocol, &info, g, dwFlags);
4092 }
4093
4094 /***********************************************************************
4095 * WSASocketW (WS2_32.79)
4096 *
4097 */
4098 SOCKET WINAPI WSASocketW(int af, int type, int protocol,
4099 LPWSAPROTOCOL_INFOW lpProtocolInfo,
4100 GROUP g, DWORD flags)
4101 {
4102 static const WCHAR afdW[] = {'\\','D','e','v','i','c','e','\\','A','f','d',0};
4103 struct afd_create_params create_params;
4104 OBJECT_ATTRIBUTES attr;
4105 UNICODE_STRING string;
4106 IO_STATUS_BLOCK io;
4107 NTSTATUS status;
4108 HANDLE handle;
4109 SOCKET ret;
4110 DWORD err;
4111
4112 /*
4113 FIXME: The "advanced" parameters of WSASocketW (lpProtocolInfo,
4114 g, dwFlags except WSA_FLAG_OVERLAPPED) are ignored.
4115 */
4116
4117 TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%x\n",
4118 af, type, protocol, lpProtocolInfo, g, flags );
4119
4120 if (!num_startup)
4121 {
4122 err = WSANOTINITIALISED;
4123 goto done;
4124 }
4125
4126 /* hack for WSADuplicateSocket */
4127 if (lpProtocolInfo && lpProtocolInfo->dwServiceFlags4 == 0xff00ff00)
4128 {
4129 ret = lpProtocolInfo->dwServiceFlags3;
4130 TRACE("\tgot duplicate %04lx\n", ret);
4131 if (!socket_list_add(ret))
4132 {
4133 CloseHandle(SOCKET2HANDLE(ret));
4134 return INVALID_SOCKET;
4135 }
4136 return ret;
4137 }
4138
4139 if (lpProtocolInfo)
4140 {
4141 if (af == FROM_PROTOCOL_INFO || !af)
4142 af = lpProtocolInfo->iAddressFamily;
4143 if (type == FROM_PROTOCOL_INFO || !type)
4144 type = lpProtocolInfo->iSocketType;
4145 if (protocol == FROM_PROTOCOL_INFO || !protocol)
4146 protocol = lpProtocolInfo->iProtocol;
4147 }
4148
4149 if (!af && !protocol)
4150 {
4151 WSASetLastError(WSAEINVAL);
4152 return INVALID_SOCKET;
4153 }
4154
4155 if (!af && lpProtocolInfo)
4156 {
4157 WSASetLastError(WSAEAFNOSUPPORT);
4158 return INVALID_SOCKET;
4159 }
4160
4161 if (!af || !type || !protocol)
4162 {
4163 unsigned int i;
4164
4165 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4166 {
4167 const WSAPROTOCOL_INFOW *info = &supported_protocols[i];
4168
4169 if (af && af != info->iAddressFamily) continue;
4170 if (type && type != info->iSocketType) continue;
4171 if (protocol && (protocol < info->iProtocol ||
4172 protocol > info->iProtocol + info->iProtocolMaxOffset)) continue;
4173 if (!protocol && !(info->dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)) continue;
4174
4175 if (!af) af = supported_protocols[i].iAddressFamily;
4176 if (!type) type = supported_protocols[i].iSocketType;
4177 if (!protocol) protocol = supported_protocols[i].iProtocol;
4178 break;
4179 }
4180 }
4181
4182 RtlInitUnicodeString(&string, afdW);
4183 InitializeObjectAttributes(&attr, &string, (flags & WSA_FLAG_NO_HANDLE_INHERIT) ? 0 : OBJ_INHERIT, NULL, NULL);
4184 if ((status = NtOpenFile(&handle, GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, &attr,
4185 &io, 0, (flags & WSA_FLAG_OVERLAPPED) ? 0 : FILE_SYNCHRONOUS_IO_NONALERT)))
4186 {
4187 WARN("Failed to create socket, status %#x.\n", status);
4188 WSASetLastError(NtStatusToWSAError(status));
4189 return INVALID_SOCKET;
4190 }
4191
4192 create_params.family = af;
4193 create_params.type = type;
4194 create_params.protocol = protocol;
4195 create_params.flags = flags & ~(WSA_FLAG_NO_HANDLE_INHERIT | WSA_FLAG_OVERLAPPED);
4196 if ((status = NtDeviceIoControlFile(handle, NULL, NULL, NULL, &io,
4197 IOCTL_AFD_WINE_CREATE, &create_params, sizeof(create_params), NULL, 0)))
4198 {
4199 WARN("Failed to initialize socket, status %#x.\n", status);
4200 err = RtlNtStatusToDosError( status );
4201 if (err == WSAEACCES) /* raw socket denied */
4202 {
4203 if (type == SOCK_RAW)
4204 ERR_(winediag)("Failed to create a socket of type SOCK_RAW, this requires special permissions.\n");
4205 else
4206 ERR_(winediag)("Failed to create socket, this requires special permissions.\n");
4207 }
4208 WSASetLastError(err);
4209 NtClose(handle);
4210 return INVALID_SOCKET;
4211 }
4212
4213 ret = HANDLE2SOCKET(handle);
4214 TRACE("\tcreated %04lx\n", ret );
4215
4216 if (!socket_list_add(ret))
4217 {
4218 CloseHandle(handle);
4219 return INVALID_SOCKET;
4220 }
4221 return ret;
4222
4223 done:
4224 WARN("\t\tfailed, error %d!\n", err);
4225 SetLastError(err);
4226 return INVALID_SOCKET;
4227 }
4228
4229 /***********************************************************************
4230 * WSAJoinLeaf (WS2_32.58)
4231 *
4232 */
4233 SOCKET WINAPI WSAJoinLeaf(
4234 SOCKET s,
4235 const struct WS_sockaddr *addr,
4236 int addrlen,
4237 LPWSABUF lpCallerData,
4238 LPWSABUF lpCalleeData,
4239 LPQOS lpSQOS,
4240 LPQOS lpGQOS,
4241 DWORD dwFlags)
4242 {
4243 FIXME("stub.\n");
4244 return INVALID_SOCKET;
4245 }
4246
4247 /***********************************************************************
4248 * __WSAFDIsSet (WS2_32.151)
4249 */
4250 int WINAPI __WSAFDIsSet(SOCKET s, WS_fd_set *set)
4251 {
4252 int i = set->fd_count, ret = 0;
4253
4254 while (i--)
4255 if (set->fd_array[i] == s)
4256 {
4257 ret = 1;
4258 break;
4259 }
4260
4261 TRACE("(socket %04lx, fd_set %p, count %i) <- %d\n", s, set, set->fd_count, ret);
4262 return ret;
4263 }
4264
4265 /***********************************************************************
4266 * WSAIsBlocking (WS2_32.114)
4267 */
4268 BOOL WINAPI WSAIsBlocking(void)
4269 {
4270 /* By default WinSock should set all its sockets to non-blocking mode
4271 * and poll in PeekMessage loop when processing "blocking" ones. This
4272 * function is supposed to tell if the program is in this loop. Our
4273 * blocking calls are truly blocking so we always return FALSE.
4274 *
4275 * Note: It is allowed to call this function without prior WSAStartup().
4276 */
4277
4278 TRACE("\n");
4279 return FALSE;
4280 }
4281
4282 /***********************************************************************
4283 * WSACancelBlockingCall (WS2_32.113)
4284 */
4285 INT WINAPI WSACancelBlockingCall(void)
4286 {
4287 TRACE("\n");
4288 return 0;
4289 }
4290
4291 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x )
4292 {
4293 FIXME("How was this called?\n");
4294 return x();
4295 }
4296
4297
4298 /***********************************************************************
4299 * WSASetBlockingHook (WS2_32.109)
4300 */
4301 FARPROC WINAPI WSASetBlockingHook(FARPROC lpBlockFunc)
4302 {
4303 FARPROC prev = blocking_hook;
4304 blocking_hook = lpBlockFunc;
4305 TRACE("hook %p\n", lpBlockFunc);
4306 return prev;
4307 }
4308
4309
4310 /***********************************************************************
4311 * WSAUnhookBlockingHook (WS2_32.110)
4312 */
4313 INT WINAPI WSAUnhookBlockingHook(void)
4314 {
4315 blocking_hook = (FARPROC)WSA_DefaultBlockingHook;
4316 return 0;
4317 }
4318
4319
4320 /***********************************************************************
4321 * WSARecv (WS2_32.67)
4322 */
4323 int WINAPI WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
4324 LPDWORD NumberOfBytesReceived, LPDWORD lpFlags,
4325 LPWSAOVERLAPPED lpOverlapped,
4326 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
4327 {
4328 return WS2_recv_base(s, lpBuffers, dwBufferCount, NumberOfBytesReceived, lpFlags,
4329 NULL, NULL, lpOverlapped, lpCompletionRoutine, NULL);
4330 }
4331
4332
4333 /***********************************************************************
4334 * WSARecvFrom (WS2_32.69)
4335 */
4336 INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
4337 LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct WS_sockaddr *lpFrom,
4338 LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped,
4339 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
4340
4341 {
4342 /* Garena hooks WSARecvFrom(), so we need a wrapper */
4343 return WS2_recv_base( s, lpBuffers, dwBufferCount,
4344 lpNumberOfBytesRecvd, lpFlags,
4345 lpFrom, lpFromlen,
4346 lpOverlapped, lpCompletionRoutine, NULL );
4347 }
4348
4349
4350 /***********************************************************************
4351 * WSAAccept (ws2_32.@)
4352 */
4353 SOCKET WINAPI WSAAccept( SOCKET s, struct WS_sockaddr *addr, int *addrlen,
4354 LPCONDITIONPROC callback, DWORD_PTR context )
4355 {
4356 int ret = 0, size;
4357 WSABUF caller_id, caller_data, callee_id, callee_data;
4358 struct WS_sockaddr src_addr, dst_addr;
4359 GROUP group;
4360 SOCKET cs;
4361
4362 TRACE( "socket %#lx, addr %p, addrlen %p, callback %p, context %#lx\n",
4363 s, addr, addrlen, callback, context );
4364
4365 cs = WS_accept(s, addr, addrlen);
4366 if (cs == SOCKET_ERROR) return SOCKET_ERROR;
4367 if (!callback) return cs;
4368
4369 if (addr && addrlen)
4370 {
4371 caller_id.buf = (char *)addr;
4372 caller_id.len = *addrlen;
4373 }
4374 else
4375 {
4376 size = sizeof(src_addr);
4377 WS_getpeername( cs, &src_addr, &size );
4378 caller_id.buf = (char *)&src_addr;
4379 caller_id.len = size;
4380 }
4381 caller_data.buf = NULL;
4382 caller_data.len = 0;
4383
4384 size = sizeof(dst_addr);
4385 WS_getsockname( cs, &dst_addr, &size );
4386
4387 callee_id.buf = (char *)&dst_addr;
4388 callee_id.len = sizeof(dst_addr);
4389
4390 ret = (*callback)( &caller_id, &caller_data, NULL, NULL,
4391 &callee_id, &callee_data, &group, context );
4392
4393 switch (ret)
4394 {
4395 case CF_ACCEPT:
4396 return cs;
4397
4398 case CF_DEFER:
4399 {
4400 obj_handle_t server_handle = cs;
4401 IO_STATUS_BLOCK io;
4402 NTSTATUS status;
4403
4404 status = NtDeviceIoControlFile( (HANDLE)s, NULL, NULL, NULL, &io, IOCTL_AFD_WINE_DEFER,
4405 &server_handle, sizeof(server_handle), NULL, 0 );
4406 SetLastError( status ? RtlNtStatusToDosError( status ) : WSATRY_AGAIN );
4407 return -1;
4408 }
4409
4410 case CF_REJECT:
4411 WS_closesocket( cs );
4412 SetLastError( WSAECONNREFUSED );
4413 return SOCKET_ERROR;
4414
4415 default:
4416 FIXME( "Unknown return type from Condition function\n" );
4417 SetLastError( WSAENOTSOCK );
4418 return SOCKET_ERROR;
4419 }
4420 }
4421
4422
4423 /***********************************************************************
4424 * WSADuplicateSocketA (WS2_32.32)
4425 */
4426 int WINAPI WSADuplicateSocketA( SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOA lpProtocolInfo )
4427 {
4428 return WS_DuplicateSocket(FALSE, s, dwProcessId, (LPWSAPROTOCOL_INFOW) lpProtocolInfo);
4429 }
4430
4431 /***********************************************************************
4432 * WSADuplicateSocketW (WS2_32.33)
4433 */
4434 int WINAPI WSADuplicateSocketW( SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo )
4435 {
4436 return WS_DuplicateSocket(TRUE, s, dwProcessId, lpProtocolInfo);
4437 }
4438
4439
4440 /***********************************************************************
4441 * WSAGetQOSByName (WS2_32.41)
4442 */
4443 BOOL WINAPI WSAGetQOSByName( SOCKET s, LPWSABUF lpQOSName, LPQOS lpQOS )
4444 {
4445 FIXME( "(0x%04lx %p %p) Stub!\n", s, lpQOSName, lpQOS );
4446 return FALSE;
4447 }
4448
4449
4450 /***********************************************************************
4451 * WSARecvDisconnect (WS2_32.68)
4452 */
4453 INT WINAPI WSARecvDisconnect( SOCKET s, LPWSABUF disconnectdata )
4454 {
4455 TRACE( "(%04lx %p)\n", s, disconnectdata );
4456
4457 return WS_shutdown( s, SD_RECEIVE );
4458 }
4459
4460
4461 static BOOL protocol_matches_filter( const int *filter, int protocol )
4462 {
4463 if (!filter) return TRUE;
4464 while (*filter)
4465 {
4466 if (protocol == *filter++) return TRUE;
4467 }
4468 return FALSE;
4469 }
4470
4471 /*****************************************************************************
4472 * WSAEnumProtocolsA [WS2_32.@]
4473 *
4474 * see function WSAEnumProtocolsW
4475 */
4476 int WINAPI WSAEnumProtocolsA( int *filter, WSAPROTOCOL_INFOA *protocols, DWORD *size )
4477 {
4478 DWORD i, count = 0;
4479
4480 TRACE("filter %p, protocols %p, size %p\n", filter, protocols, size);
4481
4482 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4483 {
4484 if (protocol_matches_filter( filter, supported_protocols[i].iProtocol ))
4485 ++count;
4486 }
4487
4488 if (!protocols || *size < count * sizeof(WSAPROTOCOL_INFOA))
4489 {
4490 *size = count * sizeof(WSAPROTOCOL_INFOA);
4491 WSASetLastError( WSAENOBUFS );
4492 return SOCKET_ERROR;
4493 }
4494
4495 count = 0;
4496 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4497 {
4498 if (protocol_matches_filter( filter, supported_protocols[i].iProtocol ))
4499 {
4500 memcpy( &protocols[count], &supported_protocols[i], offsetof( WSAPROTOCOL_INFOW, szProtocol ) );
4501 WideCharToMultiByte( CP_ACP, 0, supported_protocols[i].szProtocol, -1,
4502 protocols[count].szProtocol, sizeof(protocols[count].szProtocol), NULL, NULL );
4503 ++count;
4504 }
4505 }
4506 return count;
4507 }
4508
4509 /*****************************************************************************
4510 * WSAEnumProtocolsW [WS2_32.@]
4511 *
4512 * Retrieves information about specified set of active network protocols.
4513 *
4514 * PARAMS
4515 * protocols [I] Pointer to null-terminated array of protocol id's. NULL
4516 * retrieves information on all available protocols.
4517 * buffer [I] Pointer to a buffer to be filled with WSAPROTOCOL_INFO
4518 * structures.
4519 * len [I/O] Pointer to a variable specifying buffer size. On output
4520 * the variable holds the number of bytes needed when the
4521 * specified size is too small.
4522 *
4523 * RETURNS
4524 * Success: number of WSAPROTOCOL_INFO structures in buffer.
4525 * Failure: SOCKET_ERROR
4526 *
4527 * NOTES
4528 * NT4SP5 does not return SPX if protocols == NULL
4529 *
4530 * BUGS
4531 * - NT4SP5 returns in addition these list of NETBIOS protocols
4532 * (address family 17), each entry two times one for socket type 2 and 5
4533 *
4534 * iProtocol szProtocol
4535 * 0x80000000 \Device\NwlnkNb
4536 * 0xfffffffa \Device\NetBT_CBENT7
4537 * 0xfffffffb \Device\Nbf_CBENT7
4538 * 0xfffffffc \Device\NetBT_NdisWan5
4539 * 0xfffffffd \Device\NetBT_El9202
4540 * 0xfffffffe \Device\Nbf_El9202
4541 * 0xffffffff \Device\Nbf_NdisWan4
4542 *
4543 * - there is no check that the operating system supports the returned
4544 * protocols
4545 */
4546 int WINAPI WSAEnumProtocolsW( int *filter, WSAPROTOCOL_INFOW *protocols, DWORD *size )
4547 {
4548 DWORD i, count = 0;
4549
4550 TRACE("filter %p, protocols %p, size %p\n", filter, protocols, size);
4551
4552 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4553 {
4554 if (protocol_matches_filter( filter, supported_protocols[i].iProtocol ))
4555 ++count;
4556 }
4557
4558 if (!protocols || *size < count * sizeof(WSAPROTOCOL_INFOW))
4559 {
4560 *size = count * sizeof(WSAPROTOCOL_INFOW);
4561 WSASetLastError( WSAENOBUFS );
4562 return SOCKET_ERROR;
4563 }
4564
4565 count = 0;
4566 for (i = 0; i < ARRAY_SIZE(supported_protocols); ++i)
4567 {
4568 if (protocol_matches_filter( filter, supported_protocols[i].iProtocol ))
4569 protocols[count++] = supported_protocols[i];
4570 }
4571 return count;
4572 }
Windows API implementation