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