?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32: Correct returned error code for an invalid socket.
[wine.git] / dlls / ws2_32 / socket.c
blobeb21e4b4b35540d5061f4fc7ad4a11566733e6ae
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 <stdarg.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <sys/types.h>
36 #include <limits.h>
37 #ifdef HAVE_SYS_IPC_H
38 # include <sys/ipc.h>
39 #endif
40 #ifdef HAVE_SYS_IOCTL_H
41 # include <sys/ioctl.h>
42 #endif
43 #ifdef HAVE_SYS_FILIO_H
44 # include <sys/filio.h>
45 #endif
46 #ifdef HAVE_SYS_SOCKIO_H
47 # include <sys/sockio.h>
48 #endif
49
50 #if defined(__EMX__)
51 # include <sys/so_ioctl.h>
52 #endif
53
54 #ifdef HAVE_SYS_PARAM_H
55 # include <sys/param.h>
56 #endif
57
58 #ifdef HAVE_SYS_MSG_H
59 # include <sys/msg.h>
60 #endif
61 #ifdef HAVE_SYS_WAIT_H
62 # include <sys/wait.h>
63 #endif
64 #ifdef HAVE_SYS_UIO_H
65 # include <sys/uio.h>
66 #endif
67 #ifdef HAVE_SYS_SOCKET_H
68 #include <sys/socket.h>
69 #endif
70 #ifdef HAVE_NETINET_IN_H
71 # include <netinet/in.h>
72 #endif
73 #ifdef HAVE_NETINET_TCP_H
74 # include <netinet/tcp.h>
75 #endif
76 #ifdef HAVE_ARPA_INET_H
77 # include <arpa/inet.h>
78 #endif
79 #include <ctype.h>
80 #include <fcntl.h>
81 #include <errno.h>
82 #ifdef HAVE_NETDB_H
83 #include <netdb.h>
84 #endif
85 #ifdef HAVE_UNISTD_H
86 # include <unistd.h>
87 #endif
88 #include <stdlib.h>
89 #ifdef HAVE_ARPA_NAMESER_H
90 # include <arpa/nameser.h>
91 #endif
92 #ifdef HAVE_RESOLV_H
93 # include <resolv.h>
94 #endif
95 #ifdef HAVE_NET_IF_H
96 # include <net/if.h>
97 #endif
98 #ifdef HAVE_LINUX_FILTER_H
99 # include <linux/filter.h>
100 #endif
101
102 #ifdef HAVE_NETIPX_IPX_H
103 # include <netipx/ipx.h>
104 #elif defined(HAVE_LINUX_IPX_H)
105 # ifdef HAVE_ASM_TYPES_H
106 # include <asm/types.h>
107 # endif
108 # ifdef HAVE_LINUX_TYPES_H
109 # include <linux/types.h>
110 # endif
111 # include <linux/ipx.h>
112 #endif
113 #if defined(SOL_IPX) || defined(SO_DEFAULT_HEADERS)
114 # define HAS_IPX
115 #endif
116
117 #ifdef HAVE_LINUX_IRDA_H
118 # ifdef HAVE_LINUX_TYPES_H
119 # include <linux/types.h>
120 # endif
121 # include <linux/irda.h>
122 # define HAS_IRDA
123 #endif
124
125 #ifdef HAVE_POLL_H
126 #include <poll.h>
127 #endif
128 #ifdef HAVE_SYS_POLL_H
129 # include <sys/poll.h>
130 #endif
131 #ifdef HAVE_SYS_TIME_H
132 # include <sys/time.h>
133 #endif
134
135 #define NONAMELESSUNION
136 #define NONAMELESSSTRUCT
137 #include "ntstatus.h"
138 #define WIN32_NO_STATUS
139 #include "windef.h"
140 #include "winbase.h"
141 #include "wingdi.h"
142 #include "winuser.h"
143 #include "winerror.h"
144 #include "winnls.h"
145 #include "winsock2.h"
146 #include "mswsock.h"
147 #include "ws2tcpip.h"
148 #include "ws2spi.h"
149 #include "wsipx.h"
150 #include "wsnwlink.h"
151 #include "wshisotp.h"
152 #include "mstcpip.h"
153 #include "af_irda.h"
154 #include "winnt.h"
155 #define USE_WC_PREFIX /* For CMSG_DATA */
156 #include "iphlpapi.h"
157 #include "ip2string.h"
158 #include "wine/server.h"
159 #include "wine/debug.h"
160 #include "wine/exception.h"
161 #include "wine/unicode.h"
162 #include "wine/heap.h"
163
164 #if defined(linux) && !defined(IP_UNICAST_IF)
165 #define IP_UNICAST_IF 50
166 #endif
167
168 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
169 # define sipx_network sipx_addr.x_net
170 # define sipx_node sipx_addr.x_host.c_host
171 #endif /* __FreeBSD__ */
172
173 #ifndef INADDR_NONE
174 #define INADDR_NONE ~0UL
175 #endif
176
177 #if !defined(TCP_KEEPIDLE) && defined(TCP_KEEPALIVE)
178 /* TCP_KEEPALIVE is the Mac OS name for TCP_KEEPIDLE */
179 #define TCP_KEEPIDLE TCP_KEEPALIVE
180 #endif
181
182 #define FILE_USE_FILE_POINTER_POSITION ((LONGLONG)-2)
183
184 WINE_DEFAULT_DEBUG_CHANNEL(winsock);
185 WINE_DECLARE_DEBUG_CHANNEL(winediag);
186
187 /* names of the protocols */
188 static const WCHAR NameIpxW[] = {'I', 'P', 'X', '\0'};
189 static const WCHAR NameSpxW[] = {'S', 'P', 'X', '\0'};
190 static const WCHAR NameSpxIIW[] = {'S', 'P', 'X', ' ', 'I', 'I', '\0'};
191 static const WCHAR NameTcpW[] = {'T', 'C', 'P', '/', 'I', 'P', '\0'};
192 static const WCHAR NameUdpW[] = {'U', 'D', 'P', '/', 'I', 'P', '\0'};
193
194 /* Taken from Win2k */
195 static const GUID ProviderIdIP = { 0xe70f1aa0, 0xab8b, 0x11cf,
196 { 0x8c, 0xa3, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92 } };
197 static const GUID ProviderIdIPX = { 0x11058240, 0xbe47, 0x11cf,
198 { 0x95, 0xc8, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92 } };
199 static const GUID ProviderIdSPX = { 0x11058241, 0xbe47, 0x11cf,
200 { 0x95, 0xc8, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92 } };
201
202 static const INT valid_protocols[] =
203 {
204 WS_IPPROTO_TCP,
205 WS_IPPROTO_UDP,
206 WS_NSPROTO_IPX,
207 WS_NSPROTO_SPX,
208 WS_NSPROTO_SPXII,
209 0
210 };
211
212 #define IS_IPX_PROTO(X) ((X) >= WS_NSPROTO_IPX && (X) <= WS_NSPROTO_IPX + 255)
213
214 #if defined(IP_UNICAST_IF) && defined(SO_ATTACH_FILTER)
215 # define LINUX_BOUND_IF
216 struct interface_filter {
217 struct sock_filter iface_memaddr;
218 struct sock_filter iface_rule;
219 struct sock_filter ip_memaddr;
220 struct sock_filter ip_rule;
221 struct sock_filter return_keep;
222 struct sock_filter return_dump;
223 };
224 # define FILTER_JUMP_DUMP(here) (u_char)(offsetof(struct interface_filter, return_dump) \
225 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
226 /sizeof(struct sock_filter)
227 # define FILTER_JUMP_KEEP(here) (u_char)(offsetof(struct interface_filter, return_keep) \
228 -offsetof(struct interface_filter, here)-sizeof(struct sock_filter)) \
229 /sizeof(struct sock_filter)
230 # define FILTER_JUMP_NEXT() (u_char)(0)
231 # define SKF_NET_DESTIP 16 /* offset in the network header to the destination IP */
232 static struct interface_filter generic_interface_filter = {
233 /* This filter rule allows incoming packets on the specified interface, which works for all
234 * remotely generated packets and for locally generated broadcast packets. */
235 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, SKF_AD_OFF+SKF_AD_IFINDEX),
236 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xdeadbeef, FILTER_JUMP_KEEP(iface_rule), FILTER_JUMP_NEXT()),
237 /* This rule allows locally generated packets targeted at the specific IP address of the chosen
238 * adapter (local packets not destined for the broadcast address do not have IFINDEX set) */
239 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, SKF_NET_OFF+SKF_NET_DESTIP),
240 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xdeadbeef, FILTER_JUMP_KEEP(ip_rule), FILTER_JUMP_DUMP(ip_rule)),
241 BPF_STMT(BPF_RET+BPF_K, (u_int)-1), /* keep packet */
242 BPF_STMT(BPF_RET+BPF_K, 0) /* dump packet */
243 };
244 #endif /* LINUX_BOUND_IF */
245
246 extern ssize_t CDECL __wine_locked_recvmsg( int fd, struct msghdr *hdr, int flags );
247
248 /*
249 * The actual definition of WSASendTo, wrapped in a different function name
250 * so that internal calls from ws2_32 itself will not trigger programs like
251 * Garena, which hooks WSASendTo/WSARecvFrom calls.
252 */
253 static int WS2_sendto( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
254 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
255 const struct WS_sockaddr *to, int tolen,
256 LPWSAOVERLAPPED lpOverlapped,
257 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
258
259 /*
260 * Internal fundamental receive function, essentially WSARecvFrom with an
261 * additional parameter to support message control headers.
262 */
263 static int WS2_recv_base( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
264 LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags,
265 struct WS_sockaddr *lpFrom,
266 LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped,
267 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
268 LPWSABUF lpControlBuffer );
269
270 /* critical section to protect some non-reentrant net function */
271 static CRITICAL_SECTION csWSgetXXXbyYYY;
272 static CRITICAL_SECTION_DEBUG critsect_debug =
273 {
274 0, 0, &csWSgetXXXbyYYY,
275 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
276 0, 0, { (DWORD_PTR)(__FILE__ ": csWSgetXXXbyYYY") }
277 };
278 static CRITICAL_SECTION csWSgetXXXbyYYY = { &critsect_debug, -1, 0, 0, 0, 0 };
279
280 static in_addr_t *if_addr_cache;
281 static unsigned int if_addr_cache_size;
282 static CRITICAL_SECTION cs_if_addr_cache;
283 static CRITICAL_SECTION_DEBUG cs_if_addr_cache_debug =
284 {
285 0, 0, &cs_if_addr_cache,
286 { &cs_if_addr_cache_debug.ProcessLocksList, &cs_if_addr_cache_debug.ProcessLocksList },
287 0, 0, { (DWORD_PTR)(__FILE__ ": cs_if_addr_cache") }
288 };
289 static CRITICAL_SECTION cs_if_addr_cache = { &cs_if_addr_cache_debug, -1, 0, 0, 0, 0 };
290
291 union generic_unix_sockaddr
292 {
293 struct sockaddr addr;
294 char data[128]; /* should be big enough for all families */
295 };
296
297 static inline const char *debugstr_sockaddr( const struct WS_sockaddr *a )
298 {
299 if (!a) return "(nil)";
300 switch (a->sa_family)
301 {
302 case WS_AF_INET:
303 {
304 char buf[16];
305 const char *p;
306 struct WS_sockaddr_in *sin = (struct WS_sockaddr_in *)a;
307
308 p = WS_inet_ntop( WS_AF_INET, &sin->sin_addr, buf, sizeof(buf) );
309 if (!p)
310 p = "(unknown IPv4 address)";
311
312 return wine_dbg_sprintf("{ family AF_INET, address %s, port %d }",
313 p, ntohs(sin->sin_port));
314 }
315 case WS_AF_INET6:
316 {
317 char buf[46];
318 const char *p;
319 struct WS_sockaddr_in6 *sin = (struct WS_sockaddr_in6 *)a;
320
321 p = WS_inet_ntop( WS_AF_INET6, &sin->sin6_addr, buf, sizeof(buf) );
322 if (!p)
323 p = "(unknown IPv6 address)";
324 return wine_dbg_sprintf("{ family AF_INET6, address %s, port %d }",
325 p, ntohs(sin->sin6_port));
326 }
327 case WS_AF_IPX:
328 {
329 int i;
330 char netnum[16], nodenum[16];
331 struct WS_sockaddr_ipx *sin = (struct WS_sockaddr_ipx *)a;
332
333 for (i = 0;i < 4; i++) sprintf(netnum + i * 2, "%02X", (unsigned char) sin->sa_netnum[i]);
334 for (i = 0;i < 6; i++) sprintf(nodenum + i * 2, "%02X", (unsigned char) sin->sa_nodenum[i]);
335
336 return wine_dbg_sprintf("{ family AF_IPX, address %s.%s, ipx socket %d }",
337 netnum, nodenum, sin->sa_socket);
338 }
339 case WS_AF_IRDA:
340 {
341 DWORD addr;
342
343 memcpy( &addr, ((const SOCKADDR_IRDA *)a)->irdaDeviceID, sizeof(addr) );
344 addr = ntohl( addr );
345 return wine_dbg_sprintf("{ family AF_IRDA, addr %08x, name %s }",
346 addr,
347 ((const SOCKADDR_IRDA *)a)->irdaServiceName);
348 }
349 default:
350 return wine_dbg_sprintf("{ family %d }", a->sa_family);
351 }
352 }
353
354 static inline const char *debugstr_sockopt(int level, int optname)
355 {
356 const char *stropt = NULL, *strlevel = NULL;
357
358 #define DEBUG_SOCKLEVEL(x) case (x): strlevel = #x
359 #define DEBUG_SOCKOPT(x) case (x): stropt = #x; break
360
361 switch(level)
362 {
363 DEBUG_SOCKLEVEL(WS_SOL_SOCKET);
364 switch(optname)
365 {
366 DEBUG_SOCKOPT(WS_SO_ACCEPTCONN);
367 DEBUG_SOCKOPT(WS_SO_BROADCAST);
368 DEBUG_SOCKOPT(WS_SO_BSP_STATE);
369 DEBUG_SOCKOPT(WS_SO_CONDITIONAL_ACCEPT);
370 DEBUG_SOCKOPT(WS_SO_CONNECT_TIME);
371 DEBUG_SOCKOPT(WS_SO_DEBUG);
372 DEBUG_SOCKOPT(WS_SO_DONTLINGER);
373 DEBUG_SOCKOPT(WS_SO_DONTROUTE);
374 DEBUG_SOCKOPT(WS_SO_ERROR);
375 DEBUG_SOCKOPT(WS_SO_EXCLUSIVEADDRUSE);
376 DEBUG_SOCKOPT(WS_SO_GROUP_ID);
377 DEBUG_SOCKOPT(WS_SO_GROUP_PRIORITY);
378 DEBUG_SOCKOPT(WS_SO_KEEPALIVE);
379 DEBUG_SOCKOPT(WS_SO_LINGER);
380 DEBUG_SOCKOPT(WS_SO_MAX_MSG_SIZE);
381 DEBUG_SOCKOPT(WS_SO_OOBINLINE);
382 DEBUG_SOCKOPT(WS_SO_OPENTYPE);
383 DEBUG_SOCKOPT(WS_SO_PROTOCOL_INFOA);
384 DEBUG_SOCKOPT(WS_SO_PROTOCOL_INFOW);
385 DEBUG_SOCKOPT(WS_SO_RCVBUF);
386 DEBUG_SOCKOPT(WS_SO_RCVTIMEO);
387 DEBUG_SOCKOPT(WS_SO_REUSEADDR);
388 DEBUG_SOCKOPT(WS_SO_SNDBUF);
389 DEBUG_SOCKOPT(WS_SO_SNDTIMEO);
390 DEBUG_SOCKOPT(WS_SO_TYPE);
391 DEBUG_SOCKOPT(WS_SO_UPDATE_CONNECT_CONTEXT);
392 }
393 break;
394
395 DEBUG_SOCKLEVEL(WS_NSPROTO_IPX);
396 switch(optname)
397 {
398 DEBUG_SOCKOPT(WS_IPX_PTYPE);
399 DEBUG_SOCKOPT(WS_IPX_FILTERPTYPE);
400 DEBUG_SOCKOPT(WS_IPX_DSTYPE);
401 DEBUG_SOCKOPT(WS_IPX_RECVHDR);
402 DEBUG_SOCKOPT(WS_IPX_MAXSIZE);
403 DEBUG_SOCKOPT(WS_IPX_ADDRESS);
404 DEBUG_SOCKOPT(WS_IPX_MAX_ADAPTER_NUM);
405 }
406 break;
407
408 DEBUG_SOCKLEVEL(WS_SOL_IRLMP);
409 switch(optname)
410 {
411 DEBUG_SOCKOPT(WS_IRLMP_ENUMDEVICES);
412 }
413 break;
414
415 DEBUG_SOCKLEVEL(WS_IPPROTO_TCP);
416 switch(optname)
417 {
418 DEBUG_SOCKOPT(WS_TCP_BSDURGENT);
419 DEBUG_SOCKOPT(WS_TCP_EXPEDITED_1122);
420 DEBUG_SOCKOPT(WS_TCP_NODELAY);
421 }
422 break;
423
424 DEBUG_SOCKLEVEL(WS_IPPROTO_IP);
425 switch(optname)
426 {
427 DEBUG_SOCKOPT(WS_IP_ADD_MEMBERSHIP);
428 DEBUG_SOCKOPT(WS_IP_DONTFRAGMENT);
429 DEBUG_SOCKOPT(WS_IP_DROP_MEMBERSHIP);
430 DEBUG_SOCKOPT(WS_IP_HDRINCL);
431 DEBUG_SOCKOPT(WS_IP_MULTICAST_IF);
432 DEBUG_SOCKOPT(WS_IP_MULTICAST_LOOP);
433 DEBUG_SOCKOPT(WS_IP_MULTICAST_TTL);
434 DEBUG_SOCKOPT(WS_IP_OPTIONS);
435 DEBUG_SOCKOPT(WS_IP_PKTINFO);
436 DEBUG_SOCKOPT(WS_IP_RECEIVE_BROADCAST);
437 DEBUG_SOCKOPT(WS_IP_TOS);
438 DEBUG_SOCKOPT(WS_IP_TTL);
439 DEBUG_SOCKOPT(WS_IP_UNICAST_IF);
440 }
441 break;
442
443 DEBUG_SOCKLEVEL(WS_IPPROTO_IPV6);
444 switch(optname)
445 {
446 DEBUG_SOCKOPT(WS_IPV6_ADD_MEMBERSHIP);
447 DEBUG_SOCKOPT(WS_IPV6_DROP_MEMBERSHIP);
448 DEBUG_SOCKOPT(WS_IPV6_MULTICAST_IF);
449 DEBUG_SOCKOPT(WS_IPV6_MULTICAST_HOPS);
450 DEBUG_SOCKOPT(WS_IPV6_MULTICAST_LOOP);
451 DEBUG_SOCKOPT(WS_IPV6_UNICAST_HOPS);
452 DEBUG_SOCKOPT(WS_IPV6_V6ONLY);
453 DEBUG_SOCKOPT(WS_IPV6_UNICAST_IF);
454 DEBUG_SOCKOPT(WS_IPV6_DONTFRAG);
455 }
456 break;
457 }
458 #undef DEBUG_SOCKLEVEL
459 #undef DEBUG_SOCKOPT
460
461 if (!strlevel)
462 strlevel = wine_dbg_sprintf("WS_0x%x", level);
463 if (!stropt)
464 stropt = wine_dbg_sprintf("WS_0x%x", optname);
465
466 return wine_dbg_sprintf("level %s, name %s", strlevel + 3, stropt + 3);
467 }
468
469 static inline const char *debugstr_optval(const char *optval, int optlenval)
470 {
471 if (optval && !IS_INTRESOURCE(optval) && optlenval >= 1 && optlenval <= sizeof(DWORD))
472 {
473 DWORD value = 0;
474 memcpy(&value, optval, optlenval);
475 return wine_dbg_sprintf("%p (%u)", optval, value);
476 }
477 return wine_dbg_sprintf("%p", optval);
478 }
479
480 /* HANDLE<->SOCKET conversion (SOCKET is UINT_PTR). */
481 #define SOCKET2HANDLE(s) ((HANDLE)(s))
482 #define HANDLE2SOCKET(h) ((SOCKET)(h))
483
484 /****************************************************************
485 * Async IO declarations
486 ****************************************************************/
487
488 typedef NTSTATUS async_callback_t( void *user, IO_STATUS_BLOCK *io, NTSTATUS status );
489
490 struct ws2_async_io
491 {
492 async_callback_t *callback; /* must be the first field */
493 struct ws2_async_io *next;
494 };
495
496 struct ws2_async_shutdown
497 {
498 struct ws2_async_io io;
499 HANDLE hSocket;
500 IO_STATUS_BLOCK iosb;
501 int type;
502 };
503
504 struct ws2_async
505 {
506 struct ws2_async_io io;
507 HANDLE hSocket;
508 LPWSAOVERLAPPED user_overlapped;
509 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_func;
510 IO_STATUS_BLOCK local_iosb;
511 struct WS_sockaddr *addr;
512 union
513 {
514 int val; /* for send operations */
515 int *ptr; /* for recv operations */
516 } addrlen;
517 DWORD flags;
518 DWORD *lpFlags;
519 WSABUF *control;
520 unsigned int n_iovecs;
521 unsigned int first_iovec;
522 struct iovec iovec[1];
523 };
524
525 struct ws2_accept_async
526 {
527 struct ws2_async_io io;
528 HANDLE listen_socket;
529 HANDLE accept_socket;
530 LPOVERLAPPED user_overlapped;
531 ULONG_PTR cvalue;
532 PVOID buf; /* buffer to write data to */
533 int data_len;
534 int local_len;
535 int remote_len;
536 struct ws2_async *read;
537 };
538
539 struct ws2_transmitfile_async
540 {
541 struct ws2_async_io io;
542 char *buffer;
543 HANDLE file;
544 DWORD file_read;
545 DWORD file_bytes;
546 DWORD bytes_per_send;
547 TRANSMIT_FILE_BUFFERS buffers;
548 DWORD flags;
549 LARGE_INTEGER offset;
550 struct ws2_async write;
551 };
552
553 static struct ws2_async_io *async_io_freelist;
554
555 static void release_async_io( struct ws2_async_io *io )
556 {
557 for (;;)
558 {
559 struct ws2_async_io *next = async_io_freelist;
560 io->next = next;
561 if (InterlockedCompareExchangePointer( (void **)&async_io_freelist, io, next ) == next) return;
562 }
563 }
564
565 static struct ws2_async_io *alloc_async_io( DWORD size, async_callback_t callback )
566 {
567 /* first free remaining previous fileinfos */
568
569 struct ws2_async_io *io = InterlockedExchangePointer( (void **)&async_io_freelist, NULL );
570
571 while (io)
572 {
573 struct ws2_async_io *next = io->next;
574 HeapFree( GetProcessHeap(), 0, io );
575 io = next;
576 }
577
578 io = HeapAlloc( GetProcessHeap(), 0, size );
579 if (io) io->callback = callback;
580 return io;
581 }
582
583 static NTSTATUS register_async( int type, HANDLE handle, struct ws2_async_io *async, HANDLE event,
584 PIO_APC_ROUTINE apc, void *apc_context, IO_STATUS_BLOCK *io )
585 {
586 NTSTATUS status;
587
588 SERVER_START_REQ( register_async )
589 {
590 req->type = type;
591 req->async.handle = wine_server_obj_handle( handle );
592 req->async.user = wine_server_client_ptr( async );
593 req->async.iosb = wine_server_client_ptr( io );
594 req->async.event = wine_server_obj_handle( event );
595 req->async.apc = wine_server_client_ptr( apc );
596 req->async.apc_context = wine_server_client_ptr( apc_context );
597 status = wine_server_call( req );
598 }
599 SERVER_END_REQ;
600
601 return status;
602 }
603
604 /****************************************************************/
605
606 /* ----------------------------------- internal data */
607
608 /* ws_... struct conversion flags */
609
610 typedef struct /* WSAAsyncSelect() control struct */
611 {
612 HANDLE service, event, sock;
613 HWND hWnd;
614 UINT uMsg;
615 LONG lEvent;
616 } ws_select_info;
617
618 #define WS_MAX_SOCKETS_PER_PROCESS 128 /* reasonable guess */
619 #define WS_MAX_UDP_DATAGRAM 1024
620 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x );
621
622 /* hostent's, servent's and protent's are stored in one buffer per thread,
623 * as documented on MSDN for the functions that return any of the buffers */
624 struct per_thread_data
625 {
626 int opentype;
627 struct WS_hostent *he_buffer;
628 struct WS_servent *se_buffer;
629 struct WS_protoent *pe_buffer;
630 struct pollfd *fd_cache;
631 unsigned int fd_count;
632 int he_len;
633 int se_len;
634 int pe_len;
635 char ntoa_buffer[16]; /* 4*3 digits + 3 '.' + 1 '\0' */
636 };
637
638 /* internal: routing description information */
639 struct route {
640 struct in_addr addr;
641 IF_INDEX interface;
642 DWORD metric, default_route;
643 };
644
645 static INT num_startup; /* reference counter */
646 static FARPROC blocking_hook = (FARPROC)WSA_DefaultBlockingHook;
647
648 /* function prototypes */
649 static struct WS_hostent *WS_create_he(char *name, int aliases, int aliases_size, int addresses, int address_length);
650 static struct WS_hostent *WS_dup_he(const struct hostent* p_he);
651 static struct WS_protoent *WS_create_pe( const char *name, char **aliases, int prot );
652 static struct WS_servent *WS_dup_se(const struct servent* p_se);
653 static int ws_protocol_info(SOCKET s, int unicode, WSAPROTOCOL_INFOW *buffer, int *size);
654
655 int WSAIOCTL_GetInterfaceCount(void);
656 int WSAIOCTL_GetInterfaceName(int intNumber, char *intName);
657
658 static void WS_AddCompletion( SOCKET sock, ULONG_PTR CompletionValue, NTSTATUS CompletionStatus, ULONG Information, BOOL force );
659
660 #define MAP_OPTION(opt) { WS_##opt, opt }
661
662 static const int ws_flags_map[][2] =
663 {
664 MAP_OPTION( MSG_OOB ),
665 MAP_OPTION( MSG_PEEK ),
666 MAP_OPTION( MSG_DONTROUTE ),
667 MAP_OPTION( MSG_WAITALL ),
668 { WS_MSG_PARTIAL, 0 },
669 };
670
671 static const int ws_sock_map[][2] =
672 {
673 MAP_OPTION( SO_DEBUG ),
674 MAP_OPTION( SO_ACCEPTCONN ),
675 MAP_OPTION( SO_REUSEADDR ),
676 MAP_OPTION( SO_KEEPALIVE ),
677 MAP_OPTION( SO_DONTROUTE ),
678 MAP_OPTION( SO_BROADCAST ),
679 MAP_OPTION( SO_LINGER ),
680 MAP_OPTION( SO_OOBINLINE ),
681 MAP_OPTION( SO_SNDBUF ),
682 MAP_OPTION( SO_RCVBUF ),
683 MAP_OPTION( SO_ERROR ),
684 MAP_OPTION( SO_TYPE ),
685 #ifdef SO_RCVTIMEO
686 MAP_OPTION( SO_RCVTIMEO ),
687 #endif
688 #ifdef SO_SNDTIMEO
689 MAP_OPTION( SO_SNDTIMEO ),
690 #endif
691 };
692
693 static const int ws_tcp_map[][2] =
694 {
695 #ifdef TCP_NODELAY
696 MAP_OPTION( TCP_NODELAY ),
697 #endif
698 };
699
700 static const int ws_ip_map[][2] =
701 {
702 MAP_OPTION( IP_MULTICAST_IF ),
703 MAP_OPTION( IP_MULTICAST_TTL ),
704 MAP_OPTION( IP_MULTICAST_LOOP ),
705 MAP_OPTION( IP_ADD_MEMBERSHIP ),
706 MAP_OPTION( IP_DROP_MEMBERSHIP ),
707 MAP_OPTION( IP_ADD_SOURCE_MEMBERSHIP ),
708 MAP_OPTION( IP_DROP_SOURCE_MEMBERSHIP ),
709 MAP_OPTION( IP_BLOCK_SOURCE ),
710 MAP_OPTION( IP_UNBLOCK_SOURCE ),
711 MAP_OPTION( IP_OPTIONS ),
712 #ifdef IP_HDRINCL
713 MAP_OPTION( IP_HDRINCL ),
714 #endif
715 MAP_OPTION( IP_TOS ),
716 MAP_OPTION( IP_TTL ),
717 #if defined(IP_PKTINFO)
718 MAP_OPTION( IP_PKTINFO ),
719 #elif defined(IP_RECVDSTADDR)
720 { WS_IP_PKTINFO, IP_RECVDSTADDR },
721 #endif
722 #ifdef IP_UNICAST_IF
723 MAP_OPTION( IP_UNICAST_IF ),
724 #endif
725 };
726
727 static const int ws_ipv6_map[][2] =
728 {
729 #ifdef IPV6_ADD_MEMBERSHIP
730 MAP_OPTION( IPV6_ADD_MEMBERSHIP ),
731 #endif
732 #ifdef IPV6_DROP_MEMBERSHIP
733 MAP_OPTION( IPV6_DROP_MEMBERSHIP ),
734 #endif
735 MAP_OPTION( IPV6_MULTICAST_IF ),
736 MAP_OPTION( IPV6_MULTICAST_HOPS ),
737 MAP_OPTION( IPV6_MULTICAST_LOOP ),
738 MAP_OPTION( IPV6_UNICAST_HOPS ),
739 MAP_OPTION( IPV6_V6ONLY ),
740 #ifdef IPV6_UNICAST_IF
741 MAP_OPTION( IPV6_UNICAST_IF ),
742 #endif
743 };
744
745 static const int ws_af_map[][2] =
746 {
747 MAP_OPTION( AF_UNSPEC ),
748 MAP_OPTION( AF_INET ),
749 MAP_OPTION( AF_INET6 ),
750 #ifdef HAS_IPX
751 MAP_OPTION( AF_IPX ),
752 #endif
753 #ifdef AF_IRDA
754 MAP_OPTION( AF_IRDA ),
755 #endif
756 {FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO},
757 };
758
759 static const int ws_socktype_map[][2] =
760 {
761 MAP_OPTION( SOCK_DGRAM ),
762 MAP_OPTION( SOCK_STREAM ),
763 MAP_OPTION( SOCK_RAW ),
764 {FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO},
765 };
766
767 static const int ws_proto_map[][2] =
768 {
769 MAP_OPTION( IPPROTO_IP ),
770 MAP_OPTION( IPPROTO_TCP ),
771 MAP_OPTION( IPPROTO_UDP ),
772 MAP_OPTION( IPPROTO_IPV6 ),
773 MAP_OPTION( IPPROTO_ICMP ),
774 MAP_OPTION( IPPROTO_IGMP ),
775 MAP_OPTION( IPPROTO_RAW ),
776 MAP_OPTION( IPPROTO_IPIP ),
777 {FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO},
778 };
779
780 static const int ws_aiflag_map[][2] =
781 {
782 MAP_OPTION( AI_PASSIVE ),
783 MAP_OPTION( AI_CANONNAME ),
784 MAP_OPTION( AI_NUMERICHOST ),
785 #ifdef AI_NUMERICSERV
786 MAP_OPTION( AI_NUMERICSERV ),
787 #endif
788 #ifdef AI_V4MAPPED
789 MAP_OPTION( AI_V4MAPPED ),
790 #endif
791 MAP_OPTION( AI_ADDRCONFIG ),
792 };
793
794 static const int ws_niflag_map[][2] =
795 {
796 MAP_OPTION( NI_NOFQDN ),
797 MAP_OPTION( NI_NUMERICHOST ),
798 MAP_OPTION( NI_NAMEREQD ),
799 MAP_OPTION( NI_NUMERICSERV ),
800 MAP_OPTION( NI_DGRAM ),
801 };
802
803 static const int ws_eai_map[][2] =
804 {
805 MAP_OPTION( EAI_AGAIN ),
806 MAP_OPTION( EAI_BADFLAGS ),
807 MAP_OPTION( EAI_FAIL ),
808 MAP_OPTION( EAI_FAMILY ),
809 MAP_OPTION( EAI_MEMORY ),
810 /* Note: EAI_NODATA is deprecated, but still
811 * used by Windows and Linux... We map the newer
812 * EAI_NONAME to EAI_NODATA for now until Windows
813 * changes too.
814 */
815 #ifdef EAI_NODATA
816 MAP_OPTION( EAI_NODATA ),
817 #endif
818 #ifdef EAI_NONAME
819 { WS_EAI_NODATA, EAI_NONAME },
820 #endif
821
822 MAP_OPTION( EAI_SERVICE ),
823 MAP_OPTION( EAI_SOCKTYPE ),
824 { 0, 0 }
825 };
826
827 static const int ws_poll_map[][2] =
828 {
829 MAP_OPTION( POLLERR ),
830 MAP_OPTION( POLLHUP ),
831 MAP_OPTION( POLLNVAL ),
832 MAP_OPTION( POLLWRNORM ),
833 MAP_OPTION( POLLWRBAND ),
834 MAP_OPTION( POLLRDNORM ),
835 { WS_POLLRDBAND, POLLPRI }
836 };
837
838 static const char magic_loopback_addr[] = {127, 12, 34, 56};
839
840 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
841 #if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
842 static inline WSACMSGHDR *fill_control_message(int level, int type, WSACMSGHDR *current, ULONG *maxsize, void *data, int len)
843 {
844 ULONG msgsize = sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(len);
845 char *ptr = (char *) current + sizeof(WSACMSGHDR);
846
847 /* Make sure there is at least enough room for this entry */
848 if (msgsize > *maxsize)
849 return NULL;
850 *maxsize -= msgsize;
851 /* Fill in the entry */
852 current->cmsg_len = sizeof(WSACMSGHDR) + len;
853 current->cmsg_level = level;
854 current->cmsg_type = type;
855 memcpy(ptr, data, len);
856 /* Return the pointer to where next entry should go */
857 return (WSACMSGHDR *) (ptr + WSA_CMSG_ALIGN(len));
858 }
859 #endif /* defined(IP_PKTINFO) || defined(IP_RECVDSTADDR) */
860
861 static inline int convert_control_headers(struct msghdr *hdr, WSABUF *control)
862 {
863 #if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
864 WSACMSGHDR *cmsg_win = (WSACMSGHDR *) control->buf, *ptr;
865 ULONG ctlsize = control->len;
866 struct cmsghdr *cmsg_unix;
867
868 ptr = cmsg_win;
869 /* Loop over all the headers, converting as appropriate */
870 for (cmsg_unix = CMSG_FIRSTHDR(hdr); cmsg_unix != NULL; cmsg_unix = CMSG_NXTHDR(hdr, cmsg_unix))
871 {
872 switch(cmsg_unix->cmsg_level)
873 {
874 case IPPROTO_IP:
875 switch(cmsg_unix->cmsg_type)
876 {
877 #if defined(IP_PKTINFO)
878 case IP_PKTINFO:
879 {
880 /* Convert the Unix IP_PKTINFO structure to the Windows version */
881 struct in_pktinfo *data_unix = (struct in_pktinfo *) CMSG_DATA(cmsg_unix);
882 struct WS_in_pktinfo data_win;
883
884 memcpy(&data_win.ipi_addr,&data_unix->ipi_addr.s_addr,4); /* 4 bytes = 32 address bits */
885 data_win.ipi_ifindex = data_unix->ipi_ifindex;
886 ptr = fill_control_message(WS_IPPROTO_IP, WS_IP_PKTINFO, ptr, &ctlsize,
887 (void*)&data_win, sizeof(data_win));
888 if (!ptr) goto error;
889 } break;
890 #elif defined(IP_RECVDSTADDR)
891 case IP_RECVDSTADDR:
892 {
893 struct in_addr *addr_unix = (struct in_addr *) CMSG_DATA(cmsg_unix);
894 struct WS_in_pktinfo data_win;
895
896 memcpy(&data_win.ipi_addr, &addr_unix->s_addr, 4); /* 4 bytes = 32 address bits */
897 data_win.ipi_ifindex = 0; /* FIXME */
898 ptr = fill_control_message(WS_IPPROTO_IP, WS_IP_PKTINFO, ptr, &ctlsize,
899 (void*)&data_win, sizeof(data_win));
900 if (!ptr) goto error;
901 } break;
902 #endif /* IP_PKTINFO */
903 default:
904 FIXME("Unhandled IPPROTO_IP message header type %d\n", cmsg_unix->cmsg_type);
905 break;
906 }
907 break;
908 default:
909 FIXME("Unhandled message header level %d\n", cmsg_unix->cmsg_level);
910 break;
911 }
912 }
913
914 /* Set the length of the returned control headers */
915 control->len = (char*)ptr - (char*)cmsg_win;
916 return 1;
917 error:
918 control->len = 0;
919 return 0;
920 #else /* defined(IP_PKTINFO) || defined(IP_RECVDSTADDR) */
921 control->len = 0;
922 return 1;
923 #endif /* defined(IP_PKTINFO) || defined(IP_RECVDSTADDR) */
924 }
925 #endif /* HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS */
926
927 /* ----------------------------------- error handling */
928
929 static NTSTATUS sock_get_ntstatus( int err )
930 {
931 switch ( err )
932 {
933 case EBADF: return STATUS_INVALID_HANDLE;
934 case EBUSY: return STATUS_DEVICE_BUSY;
935 case EPERM:
936 case EACCES: return STATUS_ACCESS_DENIED;
937 case EFAULT: return STATUS_NO_MEMORY;
938 case EINVAL: return STATUS_INVALID_PARAMETER;
939 case ENFILE:
940 case EMFILE: return STATUS_TOO_MANY_OPENED_FILES;
941 case EWOULDBLOCK: return STATUS_CANT_WAIT;
942 case EINPROGRESS: return STATUS_PENDING;
943 case EALREADY: return STATUS_NETWORK_BUSY;
944 case ENOTSOCK: return STATUS_OBJECT_TYPE_MISMATCH;
945 case EDESTADDRREQ: return STATUS_INVALID_PARAMETER;
946 case EMSGSIZE: return STATUS_BUFFER_OVERFLOW;
947 case EPROTONOSUPPORT:
948 case ESOCKTNOSUPPORT:
949 case EPFNOSUPPORT:
950 case EAFNOSUPPORT:
951 case EPROTOTYPE: return STATUS_NOT_SUPPORTED;
952 case ENOPROTOOPT: return STATUS_INVALID_PARAMETER;
953 case EOPNOTSUPP: return STATUS_NOT_SUPPORTED;
954 case EADDRINUSE: return STATUS_ADDRESS_ALREADY_ASSOCIATED;
955 case EADDRNOTAVAIL: return STATUS_INVALID_PARAMETER;
956 case ECONNREFUSED: return STATUS_CONNECTION_REFUSED;
957 case ESHUTDOWN: return STATUS_PIPE_DISCONNECTED;
958 case ENOTCONN: return STATUS_CONNECTION_DISCONNECTED;
959 case ETIMEDOUT: return STATUS_IO_TIMEOUT;
960 case ENETUNREACH: return STATUS_NETWORK_UNREACHABLE;
961 case ENETDOWN: return STATUS_NETWORK_BUSY;
962 case EPIPE:
963 case ECONNRESET: return STATUS_CONNECTION_RESET;
964 case ECONNABORTED: return STATUS_CONNECTION_ABORTED;
965
966 case 0: return STATUS_SUCCESS;
967 default:
968 WARN("Unknown errno %d!\n", err);
969 return STATUS_UNSUCCESSFUL;
970 }
971 }
972
973 static UINT sock_get_error( int err )
974 {
975 switch(err)
976 {
977 case EINTR: return WSAEINTR;
978 case EPERM:
979 case EACCES: return WSAEACCES;
980 case EFAULT: return WSAEFAULT;
981 case EINVAL: return WSAEINVAL;
982 case EMFILE: return WSAEMFILE;
983 case EWOULDBLOCK: return WSAEWOULDBLOCK;
984 case EINPROGRESS: return WSAEINPROGRESS;
985 case EALREADY: return WSAEALREADY;
986 case EBADF:
987 case ENOTSOCK: return WSAENOTSOCK;
988 case EDESTADDRREQ: return WSAEDESTADDRREQ;
989 case EMSGSIZE: return WSAEMSGSIZE;
990 case EPROTOTYPE: return WSAEPROTOTYPE;
991 case ENOPROTOOPT: return WSAENOPROTOOPT;
992 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
993 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
994 case EOPNOTSUPP: return WSAEOPNOTSUPP;
995 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
996 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
997 case EADDRINUSE: return WSAEADDRINUSE;
998 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
999 case ENETDOWN: return WSAENETDOWN;
1000 case ENETUNREACH: return WSAENETUNREACH;
1001 case ENETRESET: return WSAENETRESET;
1002 case ECONNABORTED: return WSAECONNABORTED;
1003 case EPIPE:
1004 case ECONNRESET: return WSAECONNRESET;
1005 case ENOBUFS: return WSAENOBUFS;
1006 case EISCONN: return WSAEISCONN;
1007 case ENOTCONN: return WSAENOTCONN;
1008 case ESHUTDOWN: return WSAESHUTDOWN;
1009 case ETOOMANYREFS: return WSAETOOMANYREFS;
1010 case ETIMEDOUT: return WSAETIMEDOUT;
1011 case ECONNREFUSED: return WSAECONNREFUSED;
1012 case ELOOP: return WSAELOOP;
1013 case ENAMETOOLONG: return WSAENAMETOOLONG;
1014 case EHOSTDOWN: return WSAEHOSTDOWN;
1015 case EHOSTUNREACH: return WSAEHOSTUNREACH;
1016 case ENOTEMPTY: return WSAENOTEMPTY;
1017 #ifdef EPROCLIM
1018 case EPROCLIM: return WSAEPROCLIM;
1019 #endif
1020 #ifdef EUSERS
1021 case EUSERS: return WSAEUSERS;
1022 #endif
1023 #ifdef EDQUOT
1024 case EDQUOT: return WSAEDQUOT;
1025 #endif
1026 #ifdef ESTALE
1027 case ESTALE: return WSAESTALE;
1028 #endif
1029 #ifdef EREMOTE
1030 case EREMOTE: return WSAEREMOTE;
1031 #endif
1032
1033 /* just in case we ever get here and there are no problems */
1034 case 0: return 0;
1035 default:
1036 WARN("Unknown errno %d!\n", err);
1037 return WSAEOPNOTSUPP;
1038 }
1039 }
1040
1041 static UINT wsaErrno(void)
1042 {
1043 int loc_errno = errno;
1044 WARN("errno %d, (%s).\n", loc_errno, strerror(loc_errno));
1045
1046 return sock_get_error( loc_errno );
1047 }
1048
1049 /* most ws2 overlapped functions return an ntstatus-based error code */
1050 static NTSTATUS wsaErrStatus(void)
1051 {
1052 int loc_errno = errno;
1053 WARN("errno %d, (%s).\n", loc_errno, strerror(loc_errno));
1054
1055 return sock_get_ntstatus(loc_errno);
1056 }
1057
1058 static UINT wsaHerrno(int loc_errno)
1059 {
1060 WARN("h_errno %d.\n", loc_errno);
1061
1062 switch(loc_errno)
1063 {
1064 case HOST_NOT_FOUND: return WSAHOST_NOT_FOUND;
1065 case TRY_AGAIN: return WSATRY_AGAIN;
1066 case NO_RECOVERY: return WSANO_RECOVERY;
1067 case NO_DATA: return WSANO_DATA;
1068 case ENOBUFS: return WSAENOBUFS;
1069
1070 case 0: return 0;
1071 default:
1072 WARN("Unknown h_errno %d!\n", loc_errno);
1073 return WSAEOPNOTSUPP;
1074 }
1075 }
1076
1077 static NTSTATUS sock_error_to_ntstatus( DWORD err )
1078 {
1079 switch (err)
1080 {
1081 case 0: return STATUS_SUCCESS;
1082 case WSAEBADF: return STATUS_INVALID_HANDLE;
1083 case WSAEACCES: return STATUS_ACCESS_DENIED;
1084 case WSAEFAULT: return STATUS_NO_MEMORY;
1085 case WSAEINVAL: return STATUS_INVALID_PARAMETER;
1086 case WSAEMFILE: return STATUS_TOO_MANY_OPENED_FILES;
1087 case WSAEWOULDBLOCK: return STATUS_CANT_WAIT;
1088 case WSAEINPROGRESS: return STATUS_PENDING;
1089 case WSAEALREADY: return STATUS_NETWORK_BUSY;
1090 case WSAENOTSOCK: return STATUS_OBJECT_TYPE_MISMATCH;
1091 case WSAEDESTADDRREQ: return STATUS_INVALID_PARAMETER;
1092 case WSAEMSGSIZE: return STATUS_BUFFER_OVERFLOW;
1093 case WSAEPROTONOSUPPORT:
1094 case WSAESOCKTNOSUPPORT:
1095 case WSAEPFNOSUPPORT:
1096 case WSAEAFNOSUPPORT:
1097 case WSAEPROTOTYPE: return STATUS_NOT_SUPPORTED;
1098 case WSAENOPROTOOPT: return STATUS_INVALID_PARAMETER;
1099 case WSAEOPNOTSUPP: return STATUS_NOT_SUPPORTED;
1100 case WSAEADDRINUSE: return STATUS_ADDRESS_ALREADY_ASSOCIATED;
1101 case WSAEADDRNOTAVAIL: return STATUS_INVALID_PARAMETER;
1102 case WSAECONNREFUSED: return STATUS_CONNECTION_REFUSED;
1103 case WSAESHUTDOWN: return STATUS_PIPE_DISCONNECTED;
1104 case WSAENOTCONN: return STATUS_CONNECTION_DISCONNECTED;
1105 case WSAETIMEDOUT: return STATUS_IO_TIMEOUT;
1106 case WSAENETUNREACH: return STATUS_NETWORK_UNREACHABLE;
1107 case WSAENETDOWN: return STATUS_NETWORK_BUSY;
1108 case WSAECONNRESET: return STATUS_CONNECTION_RESET;
1109 case WSAECONNABORTED: return STATUS_CONNECTION_ABORTED;
1110 default:
1111 FIXME("unmapped error %u\n", err);
1112 return STATUS_UNSUCCESSFUL;
1113 }
1114 }
1115
1116 static DWORD NtStatusToWSAError( DWORD status )
1117 {
1118 switch ( status )
1119 {
1120 case STATUS_SUCCESS: return 0;
1121 case STATUS_PENDING: return WSA_IO_PENDING;
1122 case STATUS_INVALID_HANDLE:
1123 case STATUS_OBJECT_TYPE_MISMATCH: return WSAENOTSOCK;
1124 case STATUS_INVALID_PARAMETER: return WSAEINVAL;
1125 case STATUS_PIPE_DISCONNECTED: return WSAESHUTDOWN;
1126 case STATUS_NETWORK_BUSY: return WSAEALREADY;
1127 case STATUS_NETWORK_UNREACHABLE: return WSAENETUNREACH;
1128 case STATUS_CONNECTION_REFUSED: return WSAECONNREFUSED;
1129 case STATUS_CONNECTION_DISCONNECTED: return WSAENOTCONN;
1130 case STATUS_CONNECTION_RESET: return WSAECONNRESET;
1131 case STATUS_CONNECTION_ABORTED: return WSAECONNABORTED;
1132 case STATUS_CANCELLED: return WSA_OPERATION_ABORTED;
1133 case STATUS_ADDRESS_ALREADY_ASSOCIATED: return WSAEADDRINUSE;
1134 case STATUS_IO_TIMEOUT:
1135 case STATUS_TIMEOUT: return WSAETIMEDOUT;
1136 case STATUS_NO_MEMORY: return WSAEFAULT;
1137 case STATUS_ACCESS_DENIED: return WSAEACCES;
1138 case STATUS_TOO_MANY_OPENED_FILES: return WSAEMFILE;
1139 case STATUS_CANT_WAIT: return WSAEWOULDBLOCK;
1140 case STATUS_BUFFER_OVERFLOW: return WSAEMSGSIZE;
1141 case STATUS_NOT_SUPPORTED: return WSAEOPNOTSUPP;
1142 case STATUS_HOST_UNREACHABLE: return WSAEHOSTUNREACH;
1143 default: return RtlNtStatusToDosError( status );
1144 }
1145 }
1146
1147 /* set last error code from NT status without mapping WSA errors */
1148 static inline unsigned int set_error( unsigned int err )
1149 {
1150 if (err)
1151 {
1152 err = NtStatusToWSAError( err );
1153 SetLastError( err );
1154 }
1155 return err;
1156 }
1157
1158 static inline int get_sock_fd( SOCKET s, DWORD access, unsigned int *options )
1159 {
1160 int fd;
1161 if (set_error( wine_server_handle_to_fd( SOCKET2HANDLE(s), access, &fd, options ) ))
1162 return -1;
1163 return fd;
1164 }
1165
1166 static inline void release_sock_fd( SOCKET s, int fd )
1167 {
1168 wine_server_release_fd( SOCKET2HANDLE(s), fd );
1169 }
1170
1171 static void _enable_event( HANDLE s, unsigned int event,
1172 unsigned int sstate, unsigned int cstate )
1173 {
1174 SERVER_START_REQ( enable_socket_event )
1175 {
1176 req->handle = wine_server_obj_handle( s );
1177 req->mask = event;
1178 req->sstate = sstate;
1179 req->cstate = cstate;
1180 wine_server_call( req );
1181 }
1182 SERVER_END_REQ;
1183 }
1184
1185 static DWORD sock_is_blocking(SOCKET s, BOOL *ret)
1186 {
1187 DWORD err;
1188 SERVER_START_REQ( get_socket_event )
1189 {
1190 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
1191 req->service = FALSE;
1192 req->c_event = 0;
1193 err = NtStatusToWSAError( wine_server_call( req ));
1194 *ret = (reply->state & FD_WINE_NONBLOCKING) == 0;
1195 }
1196 SERVER_END_REQ;
1197 return err;
1198 }
1199
1200 static unsigned int _get_sock_mask(SOCKET s)
1201 {
1202 unsigned int ret;
1203 SERVER_START_REQ( get_socket_event )
1204 {
1205 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
1206 req->service = FALSE;
1207 req->c_event = 0;
1208 wine_server_call( req );
1209 ret = reply->mask;
1210 }
1211 SERVER_END_REQ;
1212 return ret;
1213 }
1214
1215 static void _sync_sock_state(SOCKET s)
1216 {
1217 BOOL dummy;
1218 /* do a dummy wineserver request in order to let
1219 the wineserver run through its select loop once */
1220 sock_is_blocking(s, &dummy);
1221 }
1222
1223 static void _get_sock_errors(SOCKET s, int *events)
1224 {
1225 SERVER_START_REQ( get_socket_event )
1226 {
1227 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
1228 req->service = FALSE;
1229 req->c_event = 0;
1230 wine_server_set_reply( req, events, sizeof(int) * FD_MAX_EVENTS );
1231 wine_server_call( req );
1232 }
1233 SERVER_END_REQ;
1234 }
1235
1236 static int get_sock_error(SOCKET s, unsigned int bit)
1237 {
1238 int events[FD_MAX_EVENTS];
1239 _get_sock_errors(s, events);
1240 return events[bit];
1241 }
1242
1243 static int _get_fd_type(int fd)
1244 {
1245 int sock_type = -1;
1246 socklen_t optlen = sizeof(sock_type);
1247 getsockopt(fd, SOL_SOCKET, SO_TYPE, (char*) &sock_type, &optlen);
1248 return sock_type;
1249 }
1250
1251 static BOOL set_dont_fragment(SOCKET s, int level, BOOL value)
1252 {
1253 int fd, optname;
1254
1255 if (level == IPPROTO_IP)
1256 {
1257 #ifdef IP_DONTFRAG
1258 optname = IP_DONTFRAG;
1259 #elif defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) && defined(IP_PMTUDISC_DONT)
1260 optname = IP_MTU_DISCOVER;
1261 value = value ? IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
1262 #else
1263 static int once;
1264 if (!once++)
1265 FIXME("IP_DONTFRAGMENT for IPv4 not supported in this platform\n");
1266 return TRUE; /* fake success */
1267 #endif
1268 }
1269 else
1270 {
1271 #ifdef IPV6_DONTFRAG
1272 optname = IPV6_DONTFRAG;
1273 #elif defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) && defined(IPV6_PMTUDISC_DONT)
1274 optname = IPV6_MTU_DISCOVER;
1275 value = value ? IPV6_PMTUDISC_DO : IPV6_PMTUDISC_DONT;
1276 #else
1277 static int once;
1278 if (!once++)
1279 FIXME("IP_DONTFRAGMENT for IPv6 not supported in this platform\n");
1280 return TRUE; /* fake success */
1281 #endif
1282 }
1283
1284 fd = get_sock_fd(s, 0, NULL);
1285 if (fd == -1) return FALSE;
1286
1287 if (!setsockopt(fd, level, optname, &value, sizeof(value)))
1288 value = TRUE;
1289 else
1290 {
1291 WSASetLastError(wsaErrno());
1292 value = FALSE;
1293 }
1294
1295 release_sock_fd(s, fd);
1296 return value;
1297 }
1298
1299 static BOOL get_dont_fragment(SOCKET s, int level, BOOL *out)
1300 {
1301 int fd, optname, value, not_expected;
1302 socklen_t optlen = sizeof(value);
1303
1304 if (level == IPPROTO_IP)
1305 {
1306 #ifdef IP_DONTFRAG
1307 optname = IP_DONTFRAG;
1308 not_expected = 0;
1309 #elif defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DONT)
1310 optname = IP_MTU_DISCOVER;
1311 not_expected = IP_PMTUDISC_DONT;
1312 #else
1313 static int once;
1314 if (!once++)
1315 FIXME("IP_DONTFRAGMENT for IPv4 not supported in this platform\n");
1316 return TRUE; /* fake success */
1317 #endif
1318 }
1319 else
1320 {
1321 #ifdef IPV6_DONTFRAG
1322 optname = IPV6_DONTFRAG;
1323 not_expected = 0;
1324 #elif defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DONT)
1325 optname = IPV6_MTU_DISCOVER;
1326 not_expected = IPV6_PMTUDISC_DONT;
1327 #else
1328 static int once;
1329 if (!once++)
1330 FIXME("IP_DONTFRAGMENT for IPv6 not supported in this platform\n");
1331 return TRUE; /* fake success */
1332 #endif
1333 }
1334
1335 fd = get_sock_fd(s, 0, NULL);
1336 if (fd == -1) return FALSE;
1337
1338 if (!getsockopt(fd, level, optname, &value, &optlen))
1339 {
1340 *out = value != not_expected;
1341 value = TRUE;
1342 }
1343 else
1344 {
1345 WSASetLastError(wsaErrno());
1346 value = FALSE;
1347 }
1348
1349 release_sock_fd(s, fd);
1350 return value;
1351 }
1352
1353 static struct per_thread_data *get_per_thread_data(void)
1354 {
1355 struct per_thread_data * ptb = NtCurrentTeb()->WinSockData;
1356 /* lazy initialization */
1357 if (!ptb)
1358 {
1359 ptb = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ptb) );
1360 NtCurrentTeb()->WinSockData = ptb;
1361 }
1362 return ptb;
1363 }
1364
1365 static void free_per_thread_data(void)
1366 {
1367 struct per_thread_data * ptb = NtCurrentTeb()->WinSockData;
1368
1369 if (!ptb) return;
1370
1371 /* delete scratch buffers */
1372 HeapFree( GetProcessHeap(), 0, ptb->he_buffer );
1373 HeapFree( GetProcessHeap(), 0, ptb->se_buffer );
1374 HeapFree( GetProcessHeap(), 0, ptb->pe_buffer );
1375 HeapFree( GetProcessHeap(), 0, ptb->fd_cache );
1376
1377 HeapFree( GetProcessHeap(), 0, ptb );
1378 NtCurrentTeb()->WinSockData = NULL;
1379 }
1380
1381 /***********************************************************************
1382 * DllMain (WS2_32.init)
1383 */
1384 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
1385 {
1386 TRACE("%p 0x%x %p\n", hInstDLL, fdwReason, fImpLoad);
1387 switch (fdwReason) {
1388 case DLL_PROCESS_ATTACH:
1389 break;
1390 case DLL_PROCESS_DETACH:
1391 if (fImpLoad) break;
1392 free_per_thread_data();
1393 DeleteCriticalSection(&csWSgetXXXbyYYY);
1394 break;
1395 case DLL_THREAD_DETACH:
1396 free_per_thread_data();
1397 break;
1398 }
1399 return TRUE;
1400 }
1401
1402 /***********************************************************************
1403 * convert_flags()
1404 *
1405 * Converts send/recv flags from Windows format.
1406 * Return the converted flag bits, unsupported flags remain unchanged.
1407 */
1408 static int convert_flags(int flags)
1409 {
1410 int i, out;
1411 if (!flags) return 0;
1412
1413 for (out = i = 0; flags && i < ARRAY_SIZE(ws_flags_map); i++)
1414 {
1415 if (ws_flags_map[i][0] & flags)
1416 {
1417 out |= ws_flags_map[i][1];
1418 flags &= ~ws_flags_map[i][0];
1419 }
1420 }
1421 if (flags)
1422 {
1423 FIXME("Unknown send/recv flags 0x%x, using anyway...\n", flags);
1424 out |= flags;
1425 }
1426 return out;
1427 }
1428
1429 /***********************************************************************
1430 * convert_sockopt()
1431 *
1432 * Converts socket flags from Windows format.
1433 * Return 1 if converted, 0 if not (error).
1434 */
1435 static int convert_sockopt(INT *level, INT *optname)
1436 {
1437 unsigned int i;
1438 switch (*level)
1439 {
1440 case WS_SOL_SOCKET:
1441 *level = SOL_SOCKET;
1442 for(i = 0; i < ARRAY_SIZE(ws_sock_map); i++) {
1443 if( ws_sock_map[i][0] == *optname )
1444 {
1445 *optname = ws_sock_map[i][1];
1446 return 1;
1447 }
1448 }
1449 FIXME("Unknown SOL_SOCKET optname 0x%x\n", *optname);
1450 break;
1451 case WS_IPPROTO_TCP:
1452 *level = IPPROTO_TCP;
1453 for(i = 0; i < ARRAY_SIZE(ws_tcp_map); i++) {
1454 if ( ws_tcp_map[i][0] == *optname )
1455 {
1456 *optname = ws_tcp_map[i][1];
1457 return 1;
1458 }
1459 }
1460 FIXME("Unknown IPPROTO_TCP optname 0x%x\n", *optname);
1461 break;
1462 case WS_IPPROTO_IP:
1463 *level = IPPROTO_IP;
1464 for(i = 0; i < ARRAY_SIZE(ws_ip_map); i++) {
1465 if (ws_ip_map[i][0] == *optname )
1466 {
1467 *optname = ws_ip_map[i][1];
1468 return 1;
1469 }
1470 }
1471 FIXME("Unknown IPPROTO_IP optname 0x%x\n", *optname);
1472 break;
1473 case WS_IPPROTO_IPV6:
1474 *level = IPPROTO_IPV6;
1475 for(i = 0; i < ARRAY_SIZE(ws_ipv6_map); i++) {
1476 if (ws_ipv6_map[i][0] == *optname )
1477 {
1478 *optname = ws_ipv6_map[i][1];
1479 return 1;
1480 }
1481 }
1482 FIXME("Unknown IPPROTO_IPV6 optname 0x%x\n", *optname);
1483 break;
1484 default: FIXME("Unimplemented or unknown socket level\n");
1485 }
1486 return 0;
1487 }
1488
1489 /* ----------------------------------- Per-thread info (or per-process?) */
1490
1491 static char *strdup_lower(const char *str)
1492 {
1493 int i;
1494 char *ret = HeapAlloc( GetProcessHeap(), 0, strlen(str) + 1 );
1495
1496 if (ret)
1497 {
1498 for (i = 0; str[i]; i++) ret[i] = tolower(str[i]);
1499 ret[i] = 0;
1500 }
1501 else SetLastError(WSAENOBUFS);
1502 return ret;
1503 }
1504
1505 /* Utility: get the SO_RCVTIMEO or SO_SNDTIMEO socket option
1506 * from an fd and return the value converted to milli seconds
1507 * or 0 if there is an infinite time out */
1508 static inline INT64 get_rcvsnd_timeo( int fd, BOOL is_recv)
1509 {
1510 struct timeval tv;
1511 socklen_t len = sizeof(tv);
1512 int optname, res;
1513
1514 if (is_recv)
1515 #ifdef SO_RCVTIMEO
1516 optname = SO_RCVTIMEO;
1517 #else
1518 return 0;
1519 #endif
1520 else
1521 #ifdef SO_SNDTIMEO
1522 optname = SO_SNDTIMEO;
1523 #else
1524 return 0;
1525 #endif
1526
1527 res = getsockopt(fd, SOL_SOCKET, optname, &tv, &len);
1528 if (res < 0)
1529 return 0;
1530 return (UINT64)tv.tv_sec * 1000 + tv.tv_usec / 1000;
1531 }
1532
1533 /* utility: given an fd, will block until one of the events occurs */
1534 static inline int do_block( int fd, int events, int timeout )
1535 {
1536 struct pollfd pfd;
1537 int ret;
1538
1539 pfd.fd = fd;
1540 pfd.events = events;
1541
1542 while ((ret = poll(&pfd, 1, timeout)) < 0)
1543 {
1544 if (errno != EINTR)
1545 return -1;
1546 }
1547 if( ret == 0 )
1548 return 0;
1549 return pfd.revents;
1550 }
1551
1552 static int
1553 convert_af_w2u(int windowsaf) {
1554 unsigned int i;
1555
1556 for (i = 0; i < ARRAY_SIZE(ws_af_map); i++)
1557 if (ws_af_map[i][0] == windowsaf)
1558 return ws_af_map[i][1];
1559 FIXME("unhandled Windows address family %d\n", windowsaf);
1560 return -1;
1561 }
1562
1563 static int
1564 convert_af_u2w(int unixaf) {
1565 unsigned int i;
1566
1567 for (i = 0; i < ARRAY_SIZE(ws_af_map); i++)
1568 if (ws_af_map[i][1] == unixaf)
1569 return ws_af_map[i][0];
1570 FIXME("unhandled UNIX address family %d\n", unixaf);
1571 return -1;
1572 }
1573
1574 static int
1575 convert_proto_w2u(int windowsproto) {
1576 unsigned int i;
1577
1578 for (i = 0; i < ARRAY_SIZE(ws_proto_map); i++)
1579 if (ws_proto_map[i][0] == windowsproto)
1580 return ws_proto_map[i][1];
1581
1582 /* check for extended IPX */
1583 if (IS_IPX_PROTO(windowsproto))
1584 return windowsproto;
1585
1586 FIXME("unhandled Windows socket protocol %d\n", windowsproto);
1587 return -1;
1588 }
1589
1590 static int
1591 convert_proto_u2w(int unixproto) {
1592 unsigned int i;
1593
1594 for (i = 0; i < ARRAY_SIZE(ws_proto_map); i++)
1595 if (ws_proto_map[i][1] == unixproto)
1596 return ws_proto_map[i][0];
1597
1598 /* if value is inside IPX range just return it - the kernel simply
1599 * echoes the value used in the socket() function */
1600 if (IS_IPX_PROTO(unixproto))
1601 return unixproto;
1602
1603 FIXME("unhandled UNIX socket protocol %d\n", unixproto);
1604 return -1;
1605 }
1606
1607 static int
1608 convert_socktype_w2u(int windowssocktype) {
1609 unsigned int i;
1610
1611 for (i = 0; i < ARRAY_SIZE(ws_socktype_map); i++)
1612 if (ws_socktype_map[i][0] == windowssocktype)
1613 return ws_socktype_map[i][1];
1614 FIXME("unhandled Windows socket type %d\n", windowssocktype);
1615 return -1;
1616 }
1617
1618 static int
1619 convert_socktype_u2w(int unixsocktype) {
1620 unsigned int i;
1621
1622 for (i = 0; i < ARRAY_SIZE(ws_socktype_map); i++)
1623 if (ws_socktype_map[i][1] == unixsocktype)
1624 return ws_socktype_map[i][0];
1625 FIXME("unhandled UNIX socket type %d\n", unixsocktype);
1626 return -1;
1627 }
1628
1629 static int convert_poll_w2u(int events)
1630 {
1631 int i, ret;
1632 for (i = ret = 0; events && i < ARRAY_SIZE(ws_poll_map); i++)
1633 {
1634 if (ws_poll_map[i][0] & events)
1635 {
1636 ret |= ws_poll_map[i][1];
1637 events &= ~ws_poll_map[i][0];
1638 }
1639 }
1640
1641 if (events)
1642 FIXME("Unsupported WSAPoll() flags 0x%x\n", events);
1643 return ret;
1644 }
1645
1646 static int convert_poll_u2w(int events)
1647 {
1648 int i, ret;
1649 for (i = ret = 0; events && i < ARRAY_SIZE(ws_poll_map); i++)
1650 {
1651 if (ws_poll_map[i][1] & events)
1652 {
1653 ret |= ws_poll_map[i][0];
1654 events &= ~ws_poll_map[i][1];
1655 }
1656 }
1657
1658 if (events)
1659 FIXME("Unsupported poll() flags 0x%x\n", events);
1660 return ret;
1661 }
1662
1663 static int set_ipx_packettype(int sock, int ptype)
1664 {
1665 #ifdef HAS_IPX
1666 int fd = get_sock_fd( sock, 0, NULL ), ret = 0;
1667 TRACE("trying to set IPX_PTYPE: %d (fd: %d)\n", ptype, fd);
1668
1669 if (fd == -1) return SOCKET_ERROR;
1670
1671 /* We try to set the ipx type on ipx socket level. */
1672 #ifdef SOL_IPX
1673 if(setsockopt(fd, SOL_IPX, IPX_TYPE, &ptype, sizeof(ptype)) == -1)
1674 {
1675 ERR("IPX: could not set ipx option type; expect weird behaviour\n");
1676 ret = SOCKET_ERROR;
1677 }
1678 #else
1679 {
1680 struct ipx val;
1681 /* Should we retrieve val using a getsockopt call and then
1682 * set the modified one? */
1683 val.ipx_pt = ptype;
1684 setsockopt(fd, 0, SO_DEFAULT_HEADERS, &val, sizeof(struct ipx));
1685 }
1686 #endif
1687 release_sock_fd( sock, fd );
1688 return ret;
1689 #else
1690 WARN("IPX support is not enabled, can't set packet type\n");
1691 return SOCKET_ERROR;
1692 #endif
1693 }
1694
1695 /* ----------------------------------- API -----
1696 *
1697 * Init / cleanup / error checking.
1698 */
1699
1700 /***********************************************************************
1701 * WSAStartup (WS2_32.115)
1702 */
1703 int WINAPI WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)
1704 {
1705 TRACE("verReq=%x\n", wVersionRequested);
1706
1707 if (LOBYTE(wVersionRequested) < 1)
1708 return WSAVERNOTSUPPORTED;
1709
1710 if (!lpWSAData) return WSAEINVAL;
1711
1712 num_startup++;
1713
1714 /* that's the whole of the negotiation for now */
1715 lpWSAData->wVersion = wVersionRequested;
1716 /* return winsock information */
1717 lpWSAData->wHighVersion = 0x0202;
1718 strcpy(lpWSAData->szDescription, "WinSock 2.0" );
1719 strcpy(lpWSAData->szSystemStatus, "Running" );
1720 lpWSAData->iMaxSockets = WS_MAX_SOCKETS_PER_PROCESS;
1721 lpWSAData->iMaxUdpDg = WS_MAX_UDP_DATAGRAM;
1722 /* don't do anything with lpWSAData->lpVendorInfo */
1723 /* (some apps don't allocate the space for this field) */
1724
1725 TRACE("succeeded starts: %d\n", num_startup);
1726 return 0;
1727 }
1728
1729
1730 /***********************************************************************
1731 * WSACleanup (WS2_32.116)
1732 */
1733 INT WINAPI WSACleanup(void)
1734 {
1735 if (num_startup) {
1736 num_startup--;
1737 TRACE("pending cleanups: %d\n", num_startup);
1738 return 0;
1739 }
1740 SetLastError(WSANOTINITIALISED);
1741 return SOCKET_ERROR;
1742 }
1743
1744
1745 /***********************************************************************
1746 * WSAGetLastError (WS2_32.111)
1747 */
1748 INT WINAPI WSAGetLastError(void)
1749 {
1750 return GetLastError();
1751 }
1752
1753 /***********************************************************************
1754 * WSASetLastError (WS2_32.112)
1755 */
1756 void WINAPI WSASetLastError(INT iError) {
1757 SetLastError(iError);
1758 }
1759
1760 static struct WS_hostent *check_buffer_he(int size)
1761 {
1762 struct per_thread_data * ptb = get_per_thread_data();
1763 if (ptb->he_buffer)
1764 {
1765 if (ptb->he_len >= size ) return ptb->he_buffer;
1766 HeapFree( GetProcessHeap(), 0, ptb->he_buffer );
1767 }
1768 ptb->he_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->he_len = size) );
1769 if (!ptb->he_buffer) SetLastError(WSAENOBUFS);
1770 return ptb->he_buffer;
1771 }
1772
1773 static struct WS_servent *check_buffer_se(int size)
1774 {
1775 struct per_thread_data * ptb = get_per_thread_data();
1776 if (ptb->se_buffer)
1777 {
1778 if (ptb->se_len >= size ) return ptb->se_buffer;
1779 HeapFree( GetProcessHeap(), 0, ptb->se_buffer );
1780 }
1781 ptb->se_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->se_len = size) );
1782 if (!ptb->se_buffer) SetLastError(WSAENOBUFS);
1783 return ptb->se_buffer;
1784 }
1785
1786 static struct WS_protoent *check_buffer_pe(int size)
1787 {
1788 struct per_thread_data * ptb = get_per_thread_data();
1789 if (ptb->pe_buffer)
1790 {
1791 if (ptb->pe_len >= size ) return ptb->pe_buffer;
1792 HeapFree( GetProcessHeap(), 0, ptb->pe_buffer );
1793 }
1794 ptb->pe_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->pe_len = size) );
1795 if (!ptb->pe_buffer) SetLastError(WSAENOBUFS);
1796 return ptb->pe_buffer;
1797 }
1798
1799 /* ----------------------------------- i/o APIs */
1800
1801 static inline BOOL supported_pf(int pf)
1802 {
1803 switch (pf)
1804 {
1805 case WS_AF_INET:
1806 case WS_AF_INET6:
1807 return TRUE;
1808 #ifdef HAS_IPX
1809 case WS_AF_IPX:
1810 return TRUE;
1811 #endif
1812 #ifdef HAS_IRDA
1813 case WS_AF_IRDA:
1814 return TRUE;
1815 #endif
1816 default:
1817 return FALSE;
1818 }
1819 }
1820
1821 static inline BOOL supported_protocol(int protocol)
1822 {
1823 int i;
1824 for (i = 0; i < ARRAY_SIZE(valid_protocols); i++)
1825 if (protocol == valid_protocols[i])
1826 return TRUE;
1827 return FALSE;
1828 }
1829
1830 /**********************************************************************/
1831
1832 /* Returns the length of the converted address if successful, 0 if it was too
1833 * small to start with or unknown family or invalid address buffer.
1834 */
1835 static unsigned int ws_sockaddr_ws2u(const struct WS_sockaddr* wsaddr, int wsaddrlen,
1836 union generic_unix_sockaddr *uaddr)
1837 {
1838 unsigned int uaddrlen = 0;
1839
1840 if (!wsaddr)
1841 return 0;
1842
1843 switch (wsaddr->sa_family)
1844 {
1845 #ifdef HAS_IPX
1846 case WS_AF_IPX:
1847 {
1848 const struct WS_sockaddr_ipx* wsipx=(const struct WS_sockaddr_ipx*)wsaddr;
1849 struct sockaddr_ipx* uipx = (struct sockaddr_ipx *)uaddr;
1850
1851 if (wsaddrlen<sizeof(struct WS_sockaddr_ipx))
1852 return 0;
1853
1854 uaddrlen = sizeof(struct sockaddr_ipx);
1855 memset( uaddr, 0, uaddrlen );
1856 uipx->sipx_family=AF_IPX;
1857 uipx->sipx_port=wsipx->sa_socket;
1858 /* copy sa_netnum and sa_nodenum to sipx_network and sipx_node
1859 * in one go
1860 */
1861 memcpy(&uipx->sipx_network,wsipx->sa_netnum,sizeof(uipx->sipx_network)+sizeof(uipx->sipx_node));
1862 #ifdef IPX_FRAME_NONE
1863 uipx->sipx_type=IPX_FRAME_NONE;
1864 #endif
1865 break;
1866 }
1867 #endif
1868 case WS_AF_INET6: {
1869 struct sockaddr_in6* uin6 = (struct sockaddr_in6 *)uaddr;
1870 const struct WS_sockaddr_in6* win6 = (const struct WS_sockaddr_in6*)wsaddr;
1871
1872 /* Note: Windows has 2 versions of the sockaddr_in6 struct, one with
1873 * scope_id, one without.
1874 */
1875 if (wsaddrlen >= sizeof(struct WS_sockaddr_in6_old)) {
1876 uaddrlen = sizeof(struct sockaddr_in6);
1877 memset( uaddr, 0, uaddrlen );
1878 uin6->sin6_family = AF_INET6;
1879 uin6->sin6_port = win6->sin6_port;
1880 uin6->sin6_flowinfo = win6->sin6_flowinfo;
1881 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
1882 if (wsaddrlen >= sizeof(struct WS_sockaddr_in6)) uin6->sin6_scope_id = win6->sin6_scope_id;
1883 #endif
1884 memcpy(&uin6->sin6_addr,&win6->sin6_addr,16); /* 16 bytes = 128 address bits */
1885 break;
1886 }
1887 FIXME("bad size %d for WS_sockaddr_in6\n",wsaddrlen);
1888 return 0;
1889 }
1890 case WS_AF_INET: {
1891 struct sockaddr_in* uin = (struct sockaddr_in *)uaddr;
1892 const struct WS_sockaddr_in* win = (const struct WS_sockaddr_in*)wsaddr;
1893
1894 if (wsaddrlen<sizeof(struct WS_sockaddr_in))
1895 return 0;
1896 uaddrlen = sizeof(struct sockaddr_in);
1897 memset( uaddr, 0, uaddrlen );
1898 uin->sin_family = AF_INET;
1899 uin->sin_port = win->sin_port;
1900 memcpy(&uin->sin_addr,&win->sin_addr,4); /* 4 bytes = 32 address bits */
1901 break;
1902 }
1903 #ifdef HAS_IRDA
1904 case WS_AF_IRDA: {
1905 struct sockaddr_irda *uin = (struct sockaddr_irda *)uaddr;
1906 const SOCKADDR_IRDA *win = (const SOCKADDR_IRDA *)wsaddr;
1907
1908 if (wsaddrlen < sizeof(SOCKADDR_IRDA))
1909 return 0;
1910 uaddrlen = sizeof(struct sockaddr_irda);
1911 memset( uaddr, 0, uaddrlen );
1912 uin->sir_family = AF_IRDA;
1913 if (!strncmp( win->irdaServiceName, "LSAP-SEL", strlen( "LSAP-SEL" ) ))
1914 {
1915 unsigned int lsap_sel = 0;
1916
1917 sscanf( win->irdaServiceName, "LSAP-SEL%u", &lsap_sel );
1918 uin->sir_lsap_sel = lsap_sel;
1919 }
1920 else
1921 {
1922 uin->sir_lsap_sel = LSAP_ANY;
1923 memcpy( uin->sir_name, win->irdaServiceName, 25 );
1924 }
1925 memcpy( &uin->sir_addr, win->irdaDeviceID, sizeof(uin->sir_addr) );
1926 break;
1927 }
1928 #endif
1929 case WS_AF_UNSPEC: {
1930 /* Try to determine the needed space by the passed windows sockaddr space */
1931 switch (wsaddrlen) {
1932 default: /* likely an ipv4 address */
1933 case sizeof(struct WS_sockaddr_in):
1934 uaddrlen = sizeof(struct sockaddr_in);
1935 break;
1936 #ifdef HAS_IPX
1937 case sizeof(struct WS_sockaddr_ipx):
1938 uaddrlen = sizeof(struct sockaddr_ipx);
1939 break;
1940 #endif
1941 #ifdef HAS_IRDA
1942 case sizeof(SOCKADDR_IRDA):
1943 uaddrlen = sizeof(struct sockaddr_irda);
1944 break;
1945 #endif
1946 case sizeof(struct WS_sockaddr_in6):
1947 case sizeof(struct WS_sockaddr_in6_old):
1948 uaddrlen = sizeof(struct sockaddr_in6);
1949 break;
1950 }
1951 memset( uaddr, 0, uaddrlen );
1952 break;
1953 }
1954 default:
1955 FIXME("Unknown address family %d, return NULL.\n", wsaddr->sa_family);
1956 return 0;
1957 }
1958 return uaddrlen;
1959 }
1960
1961 static BOOL is_sockaddr_bound(const struct sockaddr *uaddr, int uaddrlen)
1962 {
1963 switch (uaddr->sa_family)
1964 {
1965 #ifdef HAS_IPX
1966 case AF_IPX:
1967 {
1968 static const struct sockaddr_ipx emptyAddr;
1969 struct sockaddr_ipx *ipx = (struct sockaddr_ipx*) uaddr;
1970 return ipx->sipx_port
1971 || memcmp(&ipx->sipx_network, &emptyAddr.sipx_network, sizeof(emptyAddr.sipx_network))
1972 || memcmp(&ipx->sipx_node, &emptyAddr.sipx_node, sizeof(emptyAddr.sipx_node));
1973 }
1974 #endif
1975 case AF_INET6:
1976 {
1977 static const struct sockaddr_in6 emptyAddr;
1978 const struct sockaddr_in6 *in6 = (const struct sockaddr_in6*) uaddr;
1979 return in6->sin6_port || memcmp(&in6->sin6_addr, &emptyAddr.sin6_addr, sizeof(struct in6_addr));
1980 }
1981 case AF_INET:
1982 {
1983 static const struct sockaddr_in emptyAddr;
1984 const struct sockaddr_in *in = (const struct sockaddr_in*) uaddr;
1985 return in->sin_port || memcmp(&in->sin_addr, &emptyAddr.sin_addr, sizeof(struct in_addr));
1986 }
1987 case AF_UNSPEC:
1988 return FALSE;
1989 default:
1990 FIXME("unknown address family %d\n", uaddr->sa_family);
1991 return TRUE;
1992 }
1993 }
1994
1995 /* Returns -1 if getsockname fails, 0 if not bound, 1 otherwise */
1996 static int is_fd_bound(int fd, union generic_unix_sockaddr *uaddr, socklen_t *uaddrlen)
1997 {
1998 union generic_unix_sockaddr inaddr;
1999 socklen_t inlen;
2000 int res;
2001
2002 if (!uaddr) uaddr = &inaddr;
2003 if (!uaddrlen) uaddrlen = &inlen;
2004
2005 *uaddrlen = sizeof(inaddr);
2006 res = getsockname(fd, &uaddr->addr, uaddrlen);
2007 if (!res) res = is_sockaddr_bound(&uaddr->addr, *uaddrlen);
2008 return res;
2009 }
2010
2011 /* Returns 0 if successful, -1 if the buffer is too small */
2012 static int ws_sockaddr_u2ws(const struct sockaddr* uaddr, struct WS_sockaddr* wsaddr, int* wsaddrlen)
2013 {
2014 int res;
2015
2016 switch(uaddr->sa_family)
2017 {
2018 #ifdef HAS_IPX
2019 case AF_IPX:
2020 {
2021 const struct sockaddr_ipx* uipx=(const struct sockaddr_ipx*)uaddr;
2022 struct WS_sockaddr_ipx* wsipx=(struct WS_sockaddr_ipx*)wsaddr;
2023
2024 res=-1;
2025 switch (*wsaddrlen) /* how much can we copy? */
2026 {
2027 default:
2028 res=0; /* enough */
2029 *wsaddrlen = sizeof(*wsipx);
2030 wsipx->sa_socket=uipx->sipx_port;
2031 /* fall through */
2032 case 13:
2033 case 12:
2034 memcpy(wsipx->sa_nodenum,uipx->sipx_node,sizeof(wsipx->sa_nodenum));
2035 /* fall through */
2036 case 11:
2037 case 10:
2038 case 9:
2039 case 8:
2040 case 7:
2041 case 6:
2042 memcpy(wsipx->sa_netnum,&uipx->sipx_network,sizeof(wsipx->sa_netnum));
2043 /* fall through */
2044 case 5:
2045 case 4:
2046 case 3:
2047 case 2:
2048 wsipx->sa_family=WS_AF_IPX;
2049 /* fall through */
2050 case 1:
2051 case 0:
2052 /* way too small */
2053 break;
2054 }
2055 }
2056 break;
2057 #endif
2058 #ifdef HAS_IRDA
2059 case AF_IRDA: {
2060 const struct sockaddr_irda *uin = (const struct sockaddr_irda *)uaddr;
2061 SOCKADDR_IRDA *win = (SOCKADDR_IRDA *)wsaddr;
2062
2063 if (*wsaddrlen < sizeof(SOCKADDR_IRDA))
2064 return -1;
2065 win->irdaAddressFamily = WS_AF_IRDA;
2066 memcpy( win->irdaDeviceID, &uin->sir_addr, sizeof(win->irdaDeviceID) );
2067 if (uin->sir_lsap_sel != LSAP_ANY)
2068 sprintf( win->irdaServiceName, "LSAP-SEL%u", uin->sir_lsap_sel );
2069 else
2070 memcpy( win->irdaServiceName, uin->sir_name,
2071 sizeof(win->irdaServiceName) );
2072 return 0;
2073 }
2074 #endif
2075 case AF_INET6: {
2076 const struct sockaddr_in6* uin6 = (const struct sockaddr_in6*)uaddr;
2077 struct WS_sockaddr_in6_old* win6old = (struct WS_sockaddr_in6_old*)wsaddr;
2078
2079 if (*wsaddrlen < sizeof(struct WS_sockaddr_in6_old))
2080 return -1;
2081 win6old->sin6_family = WS_AF_INET6;
2082 win6old->sin6_port = uin6->sin6_port;
2083 win6old->sin6_flowinfo = uin6->sin6_flowinfo;
2084 memcpy(&win6old->sin6_addr,&uin6->sin6_addr,16); /* 16 bytes = 128 address bits */
2085 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
2086 if (*wsaddrlen >= sizeof(struct WS_sockaddr_in6)) {
2087 struct WS_sockaddr_in6* win6 = (struct WS_sockaddr_in6*)wsaddr;
2088 win6->sin6_scope_id = uin6->sin6_scope_id;
2089 *wsaddrlen = sizeof(struct WS_sockaddr_in6);
2090 }
2091 else
2092 *wsaddrlen = sizeof(struct WS_sockaddr_in6_old);
2093 #else
2094 *wsaddrlen = sizeof(struct WS_sockaddr_in6_old);
2095 #endif
2096 return 0;
2097 }
2098 case AF_INET: {
2099 const struct sockaddr_in* uin = (const struct sockaddr_in*)uaddr;
2100 struct WS_sockaddr_in* win = (struct WS_sockaddr_in*)wsaddr;
2101
2102 if (*wsaddrlen < sizeof(struct WS_sockaddr_in))
2103 return -1;
2104 win->sin_family = WS_AF_INET;
2105 win->sin_port = uin->sin_port;
2106 memcpy(&win->sin_addr,&uin->sin_addr,4); /* 4 bytes = 32 address bits */
2107 memset(win->sin_zero, 0, 8); /* Make sure the null padding is null */
2108 *wsaddrlen = sizeof(struct WS_sockaddr_in);
2109 return 0;
2110 }
2111 case AF_UNSPEC: {
2112 memset(wsaddr,0,*wsaddrlen);
2113 return 0;
2114 }
2115 default:
2116 FIXME("Unknown address family %d\n", uaddr->sa_family);
2117 return -1;
2118 }
2119 return res;
2120 }
2121
2122 static INT WS_DuplicateSocket(BOOL unicode, SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo)
2123 {
2124 HANDLE hProcess;
2125 int size;
2126 WSAPROTOCOL_INFOW infow;
2127
2128 TRACE("(unicode %d, socket %04lx, processid %x, buffer %p)\n",
2129 unicode, s, dwProcessId, lpProtocolInfo);
2130
2131 if (!ws_protocol_info(s, unicode, &infow, &size))
2132 return SOCKET_ERROR;
2133
2134 if (!(hProcess = OpenProcess(PROCESS_DUP_HANDLE, FALSE, dwProcessId)))
2135 {
2136 SetLastError(WSAEINVAL);
2137 return SOCKET_ERROR;
2138 }
2139
2140 if (!lpProtocolInfo)
2141 {
2142 CloseHandle(hProcess);
2143 SetLastError(WSAEFAULT);
2144 return SOCKET_ERROR;
2145 }
2146
2147 /* I don't know what the real Windoze does next, this is a hack */
2148 /* ...we could duplicate and then use ConvertToGlobalHandle on the duplicate, then let
2149 * the target use the global duplicate, or we could copy a reference to us to the structure
2150 * and let the target duplicate it from us, but let's do it as simple as possible */
2151 memcpy(lpProtocolInfo, &infow, size);
2152 DuplicateHandle(GetCurrentProcess(), SOCKET2HANDLE(s),
2153 hProcess, (LPHANDLE)&lpProtocolInfo->dwServiceFlags3,
2154 0, FALSE, DUPLICATE_SAME_ACCESS);
2155 CloseHandle(hProcess);
2156 lpProtocolInfo->dwServiceFlags4 = 0xff00ff00; /* magic */
2157 return 0;
2158 }
2159
2160 /*****************************************************************************
2161 * WS_EnterSingleProtocolW [internal]
2162 *
2163 * enters the protocol information of one given protocol into the given
2164 * buffer.
2165 *
2166 * RETURNS
2167 * TRUE if a protocol was entered into the buffer.
2168 *
2169 * BUGS
2170 * - only implemented for IPX, SPX, SPXII, TCP, UDP
2171 * - there is no check that the operating system supports the returned
2172 * protocols
2173 */
2174 static BOOL WS_EnterSingleProtocolW( INT protocol, WSAPROTOCOL_INFOW* info )
2175 {
2176 memset( info, 0, sizeof(WSAPROTOCOL_INFOW) );
2177 info->iProtocol = protocol;
2178
2179 switch (protocol)
2180 {
2181 case WS_IPPROTO_TCP:
2182 info->dwServiceFlags1 = XP1_IFS_HANDLES | XP1_EXPEDITED_DATA |
2183 XP1_GRACEFUL_CLOSE | XP1_GUARANTEED_ORDER |
2184 XP1_GUARANTEED_DELIVERY;
2185 info->ProviderId = ProviderIdIP;
2186 info->dwCatalogEntryId = 0x3e9;
2187 info->dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO;
2188 info->ProtocolChain.ChainLen = 1;
2189 info->iVersion = 2;
2190 info->iAddressFamily = WS_AF_INET;
2191 info->iMaxSockAddr = 0x10;
2192 info->iMinSockAddr = 0x10;
2193 info->iSocketType = WS_SOCK_STREAM;
2194 strcpyW( info->szProtocol, NameTcpW );
2195 break;
2196
2197 case WS_IPPROTO_UDP:
2198 info->dwServiceFlags1 = XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST |
2199 XP1_SUPPORT_MULTIPOINT | XP1_MESSAGE_ORIENTED |
2200 XP1_CONNECTIONLESS;
2201 info->ProviderId = ProviderIdIP;
2202 info->dwCatalogEntryId = 0x3ea;
2203 info->dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO;
2204 info->ProtocolChain.ChainLen = 1;
2205 info->iVersion = 2;
2206 info->iAddressFamily = WS_AF_INET;
2207 info->iMaxSockAddr = 0x10;
2208 info->iMinSockAddr = 0x10;
2209 info->iSocketType = WS_SOCK_DGRAM;
2210 info->dwMessageSize = 0xffbb;
2211 strcpyW( info->szProtocol, NameUdpW );
2212 break;
2213
2214 case WS_NSPROTO_IPX:
2215 info->dwServiceFlags1 = XP1_PARTIAL_MESSAGE | XP1_SUPPORT_BROADCAST |
2216 XP1_SUPPORT_MULTIPOINT | XP1_MESSAGE_ORIENTED |
2217 XP1_CONNECTIONLESS;
2218 info->ProviderId = ProviderIdIPX;
2219 info->dwCatalogEntryId = 0x406;
2220 info->dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO;
2221 info->ProtocolChain.ChainLen = 1;
2222 info->iVersion = 2;
2223 info->iAddressFamily = WS_AF_IPX;
2224 info->iMaxSockAddr = 0x10;
2225 info->iMinSockAddr = 0x0e;
2226 info->iSocketType = WS_SOCK_DGRAM;
2227 info->iProtocolMaxOffset = 0xff;
2228 info->dwMessageSize = 0x240;
2229 strcpyW( info->szProtocol, NameIpxW );
2230 break;
2231
2232 case WS_NSPROTO_SPX:
2233 info->dwServiceFlags1 = XP1_IFS_HANDLES | XP1_PSEUDO_STREAM |
2234 XP1_MESSAGE_ORIENTED | XP1_GUARANTEED_ORDER |
2235 XP1_GUARANTEED_DELIVERY;
2236 info->ProviderId = ProviderIdSPX;
2237 info->dwCatalogEntryId = 0x407;
2238 info->dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO;
2239 info->ProtocolChain.ChainLen = 1;
2240 info->iVersion = 2;
2241 info->iAddressFamily = WS_AF_IPX;
2242 info->iMaxSockAddr = 0x10;
2243 info->iMinSockAddr = 0x0e;
2244 info->iSocketType = WS_SOCK_SEQPACKET;
2245 info->dwMessageSize = 0xffffffff;
2246 strcpyW( info->szProtocol, NameSpxW );
2247 break;
2248
2249 case WS_NSPROTO_SPXII:
2250 info->dwServiceFlags1 = XP1_IFS_HANDLES | XP1_GRACEFUL_CLOSE |
2251 XP1_PSEUDO_STREAM | XP1_MESSAGE_ORIENTED |
2252 XP1_GUARANTEED_ORDER | XP1_GUARANTEED_DELIVERY;
2253 info->ProviderId = ProviderIdSPX;
2254 info->dwCatalogEntryId = 0x409;
2255 info->dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO;
2256 info->ProtocolChain.ChainLen = 1;
2257 info->iVersion = 2;
2258 info->iAddressFamily = WS_AF_IPX;
2259 info->iMaxSockAddr = 0x10;
2260 info->iMinSockAddr = 0x0e;
2261 info->iSocketType = WS_SOCK_SEQPACKET;
2262 info->dwMessageSize = 0xffffffff;
2263 strcpyW( info->szProtocol, NameSpxIIW );
2264 break;
2265
2266 default:
2267 FIXME("unknown Protocol <0x%08x>\n", protocol);
2268 return FALSE;
2269 }
2270 return TRUE;
2271 }
2272
2273 /*****************************************************************************
2274 * WS_EnterSingleProtocolA [internal]
2275 *
2276 * see function WS_EnterSingleProtocolW
2277 *
2278 */
2279 static BOOL WS_EnterSingleProtocolA( INT protocol, WSAPROTOCOL_INFOA* info )
2280 {
2281 WSAPROTOCOL_INFOW infow;
2282 INT ret;
2283 memset( info, 0, sizeof(WSAPROTOCOL_INFOA) );
2284
2285 ret = WS_EnterSingleProtocolW( protocol, &infow );
2286 if (ret)
2287 {
2288 /* convert the structure from W to A */
2289 memcpy( info, &infow, FIELD_OFFSET( WSAPROTOCOL_INFOA, szProtocol ) );
2290 WideCharToMultiByte( CP_ACP, 0, infow.szProtocol, -1,
2291 info->szProtocol, WSAPROTOCOL_LEN+1, NULL, NULL );
2292 }
2293
2294 return ret;
2295 }
2296
2297 static INT WS_EnumProtocols( BOOL unicode, const INT *protocols, LPWSAPROTOCOL_INFOW buffer, LPDWORD len )
2298 {
2299 INT i = 0, items = 0;
2300 DWORD size = 0;
2301 union _info
2302 {
2303 LPWSAPROTOCOL_INFOA a;
2304 LPWSAPROTOCOL_INFOW w;
2305 } info;
2306 info.w = buffer;
2307
2308 if (!protocols) protocols = valid_protocols;
2309
2310 while (protocols[i])
2311 {
2312 if(supported_protocol(protocols[i++]))
2313 items++;
2314 }
2315
2316 size = items * (unicode ? sizeof(WSAPROTOCOL_INFOW) : sizeof(WSAPROTOCOL_INFOA));
2317
2318 TRACE("unicode %d, protocols %p, buffer %p, length %p %d, items %d, required %d\n",
2319 unicode, protocols, buffer, len, len ? *len : 0, items, size);
2320
2321 if (*len < size || !buffer)
2322 {
2323 *len = size;
2324 SetLastError(WSAENOBUFS);
2325 return SOCKET_ERROR;
2326 }
2327
2328 for (i = items = 0; protocols[i]; i++)
2329 {
2330 if (!supported_protocol(protocols[i])) continue;
2331 if (unicode)
2332 {
2333 if (WS_EnterSingleProtocolW( protocols[i], &info.w[items] ))
2334 items++;
2335 }
2336 else
2337 {
2338 if (WS_EnterSingleProtocolA( protocols[i], &info.a[items] ))
2339 items++;
2340 }
2341 }
2342 return items;
2343 }
2344
2345 static BOOL ws_protocol_info(SOCKET s, int unicode, WSAPROTOCOL_INFOW *buffer, int *size)
2346 {
2347 NTSTATUS status;
2348 int address_family;
2349 int socket_type;
2350 int protocol;
2351
2352 *size = unicode ? sizeof(WSAPROTOCOL_INFOW) : sizeof(WSAPROTOCOL_INFOA);
2353 memset(buffer, 0, *size);
2354
2355 SERVER_START_REQ( get_socket_info )
2356 {
2357 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
2358 status = wine_server_call( req );
2359 if (!status)
2360 {
2361 address_family = convert_af_u2w(reply->family);
2362 socket_type = convert_socktype_u2w(reply->type);
2363 protocol = convert_proto_u2w(reply->protocol);
2364 }
2365 }
2366 SERVER_END_REQ;
2367
2368 if (status)
2369 {
2370 unsigned int err = NtStatusToWSAError( status );
2371 SetLastError( err == WSAEBADF ? WSAENOTSOCK : err );
2372 return FALSE;
2373 }
2374
2375 if (unicode)
2376 WS_EnterSingleProtocolW( protocol, buffer);
2377 else
2378 WS_EnterSingleProtocolA( protocol, (WSAPROTOCOL_INFOA *)buffer);
2379 buffer->iAddressFamily = address_family;
2380 buffer->iSocketType = socket_type;
2381 buffer->iProtocol = protocol;
2382
2383 return TRUE;
2384 }
2385
2386 /**************************************************************************
2387 * Functions for handling overlapped I/O
2388 **************************************************************************/
2389
2390 /* user APC called upon async completion */
2391 static void WINAPI ws2_async_apc( void *arg, IO_STATUS_BLOCK *iosb, ULONG reserved )
2392 {
2393 struct ws2_async *wsa = arg;
2394
2395 if (wsa->completion_func) wsa->completion_func( NtStatusToWSAError(iosb->u.Status),
2396 iosb->Information, wsa->user_overlapped,
2397 wsa->flags );
2398 release_async_io( &wsa->io );
2399 }
2400
2401 /***********************************************************************
2402 * WS2_recv (INTERNAL)
2403 *
2404 * Workhorse for both synchronous and asynchronous recv() operations.
2405 */
2406 static int WS2_recv( int fd, struct ws2_async *wsa, int flags )
2407 {
2408 #ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
2409 char pktbuf[512];
2410 #endif
2411 struct msghdr hdr;
2412 union generic_unix_sockaddr unix_sockaddr;
2413 int n;
2414
2415 hdr.msg_name = NULL;
2416
2417 if (wsa->addr)
2418 {
2419 hdr.msg_namelen = sizeof(unix_sockaddr);
2420 hdr.msg_name = &unix_sockaddr;
2421 }
2422 else
2423 hdr.msg_namelen = 0;
2424
2425 hdr.msg_iov = wsa->iovec + wsa->first_iovec;
2426 hdr.msg_iovlen = wsa->n_iovecs - wsa->first_iovec;
2427 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
2428 hdr.msg_accrights = NULL;
2429 hdr.msg_accrightslen = 0;
2430 #else
2431 hdr.msg_control = pktbuf;
2432 hdr.msg_controllen = sizeof(pktbuf);
2433 hdr.msg_flags = 0;
2434 #endif
2435
2436 while ((n = __wine_locked_recvmsg( fd, &hdr, flags )) == -1)
2437 {
2438 if (errno != EINTR)
2439 return -1;
2440 }
2441
2442 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
2443 if (wsa->control)
2444 {
2445 ERR("Message control headers cannot be properly supported on this system.\n");
2446 wsa->control->len = 0;
2447 }
2448 #else
2449 if (wsa->control && !convert_control_headers(&hdr, wsa->control))
2450 {
2451 WARN("Application passed insufficient room for control headers.\n");
2452 *wsa->lpFlags |= WS_MSG_CTRUNC;
2453 errno = EMSGSIZE;
2454 return -1;
2455 }
2456 #endif
2457
2458 /* if this socket is connected and lpFrom is not NULL, Linux doesn't give us
2459 * msg_name and msg_namelen from recvmsg, but it does set msg_namelen to zero.
2460 *
2461 * quoting linux 2.6 net/ipv4/tcp.c:
2462 * "According to UNIX98, msg_name/msg_namelen are ignored
2463 * on connected socket. I was just happy when found this 8) --ANK"
2464 *
2465 * likewise MSDN says that lpFrom and lpFromlen are ignored for
2466 * connection-oriented sockets, so don't try to update lpFrom.
2467 */
2468 if (wsa->addr && hdr.msg_namelen)
2469 ws_sockaddr_u2ws( &unix_sockaddr.addr, wsa->addr, wsa->addrlen.ptr );
2470
2471 return n;
2472 }
2473
2474 /***********************************************************************
2475 * WS2_async_recv (INTERNAL)
2476 *
2477 * Handler for overlapped recv() operations.
2478 */
2479 static NTSTATUS WS2_async_recv( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
2480 {
2481 struct ws2_async *wsa = user;
2482 int result = 0, fd;
2483
2484 switch (status)
2485 {
2486 case STATUS_ALERTED:
2487 if ((status = wine_server_handle_to_fd( wsa->hSocket, FILE_READ_DATA, &fd, NULL ) ))
2488 break;
2489
2490 result = WS2_recv( fd, wsa, convert_flags(wsa->flags) );
2491 wine_server_release_fd( wsa->hSocket, fd );
2492 if (result >= 0)
2493 {
2494 status = STATUS_SUCCESS;
2495 _enable_event( wsa->hSocket, FD_READ, 0, 0 );
2496 }
2497 else
2498 {
2499 if (errno == EAGAIN)
2500 {
2501 status = STATUS_PENDING;
2502 _enable_event( wsa->hSocket, FD_READ, 0, 0 );
2503 }
2504 else
2505 {
2506 result = 0;
2507 status = wsaErrStatus();
2508 }
2509 }
2510 break;
2511 }
2512 if (status != STATUS_PENDING)
2513 {
2514 iosb->u.Status = status;
2515 iosb->Information = result;
2516 if (!wsa->completion_func)
2517 release_async_io( &wsa->io );
2518 }
2519 return status;
2520 }
2521
2522 /***********************************************************************
2523 * WS2_async_accept_recv (INTERNAL)
2524 *
2525 * This function is used to finish the read part of an accept request. It is
2526 * needed to place the completion on the correct socket (listener).
2527 */
2528 static NTSTATUS WS2_async_accept_recv( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
2529 {
2530 struct ws2_accept_async *wsa = user;
2531
2532 status = WS2_async_recv( wsa->read, iosb, status );
2533 if (status == STATUS_PENDING)
2534 return status;
2535
2536 if (wsa->cvalue)
2537 WS_AddCompletion( HANDLE2SOCKET(wsa->listen_socket), wsa->cvalue, iosb->u.Status, iosb->Information, TRUE );
2538
2539 release_async_io( &wsa->io );
2540 return status;
2541 }
2542
2543 /***********************************************************************
2544 * WS2_async_accept (INTERNAL)
2545 *
2546 * This is the function called to satisfy the AcceptEx callback
2547 */
2548 static NTSTATUS WS2_async_accept( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
2549 {
2550 struct ws2_accept_async *wsa = user;
2551 int len;
2552 char *addr;
2553
2554 TRACE("status: 0x%x listen: %p, accept: %p\n", status, wsa->listen_socket, wsa->accept_socket);
2555
2556 if (status == STATUS_ALERTED)
2557 {
2558 SERVER_START_REQ( accept_into_socket )
2559 {
2560 req->lhandle = wine_server_obj_handle( wsa->listen_socket );
2561 req->ahandle = wine_server_obj_handle( wsa->accept_socket );
2562 status = wine_server_call( req );
2563 }
2564 SERVER_END_REQ;
2565
2566 if (NtStatusToWSAError( status ) == WSAEWOULDBLOCK)
2567 return STATUS_PENDING;
2568
2569 if (status == STATUS_INVALID_HANDLE)
2570 {
2571 FIXME("AcceptEx accepting socket closed but request was not cancelled\n");
2572 status = STATUS_CANCELLED;
2573 }
2574 }
2575 else if (status == STATUS_HANDLES_CLOSED)
2576 status = STATUS_CANCELLED; /* strange windows behavior */
2577
2578 if (status != STATUS_SUCCESS)
2579 goto finish;
2580
2581 /* WS2 Spec says size param is extra 16 bytes long...what do we put in it? */
2582 addr = ((char *)wsa->buf) + wsa->data_len;
2583 len = wsa->local_len - sizeof(int);
2584 WS_getsockname(HANDLE2SOCKET(wsa->accept_socket),
2585 (struct WS_sockaddr *)(addr + sizeof(int)), &len);
2586 *(int *)addr = len;
2587
2588 addr += wsa->local_len;
2589 len = wsa->remote_len - sizeof(int);
2590 WS_getpeername(HANDLE2SOCKET(wsa->accept_socket),
2591 (struct WS_sockaddr *)(addr + sizeof(int)), &len);
2592 *(int *)addr = len;
2593
2594 if (!wsa->read)
2595 goto finish;
2596
2597 wsa->io.callback = WS2_async_accept_recv;
2598 status = register_async( ASYNC_TYPE_READ, wsa->accept_socket, &wsa->io,
2599 wsa->user_overlapped->hEvent, NULL, NULL, iosb);
2600
2601 if (status != STATUS_PENDING)
2602 goto finish;
2603
2604 /* The APC has finished but no completion should be sent for the operation yet, additional processing
2605 * needs to be performed by WS2_async_accept_recv() first. */
2606 return STATUS_MORE_PROCESSING_REQUIRED;
2607
2608 finish:
2609 iosb->u.Status = status;
2610 iosb->Information = 0;
2611
2612 if (wsa->read) release_async_io( &wsa->read->io );
2613 release_async_io( &wsa->io );
2614 return status;
2615 }
2616
2617 /***********************************************************************
2618 * WS2_send (INTERNAL)
2619 *
2620 * Workhorse for both synchronous and asynchronous send() operations.
2621 */
2622 static int WS2_send( int fd, struct ws2_async *wsa, int flags )
2623 {
2624 struct msghdr hdr;
2625 union generic_unix_sockaddr unix_addr;
2626 int n, ret;
2627
2628 hdr.msg_name = NULL;
2629 hdr.msg_namelen = 0;
2630
2631 if (wsa->addr)
2632 {
2633 hdr.msg_name = &unix_addr;
2634 hdr.msg_namelen = ws_sockaddr_ws2u( wsa->addr, wsa->addrlen.val, &unix_addr );
2635 if ( !hdr.msg_namelen )
2636 {
2637 errno = EFAULT;
2638 return -1;
2639 }
2640
2641 #if defined(HAS_IPX) && defined(SOL_IPX)
2642 if(wsa->addr->sa_family == WS_AF_IPX)
2643 {
2644 struct sockaddr_ipx* uipx = (struct sockaddr_ipx*)hdr.msg_name;
2645 int val=0;
2646 socklen_t len = sizeof(int);
2647
2648 /* The packet type is stored at the ipx socket level; At least the linux kernel seems
2649 * to do something with it in case hdr.msg_name is NULL. Nonetheless can we use it to store
2650 * the packet type and then we can retrieve it using getsockopt. After that we can set the
2651 * ipx type in the sockaddr_opx structure with the stored value.
2652 */
2653 if(getsockopt(fd, SOL_IPX, IPX_TYPE, &val, &len) != -1)
2654 uipx->sipx_type = val;
2655 }
2656 #endif
2657 }
2658
2659 hdr.msg_iov = wsa->iovec + wsa->first_iovec;
2660 hdr.msg_iovlen = wsa->n_iovecs - wsa->first_iovec;
2661 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
2662 hdr.msg_accrights = NULL;
2663 hdr.msg_accrightslen = 0;
2664 #else
2665 hdr.msg_control = NULL;
2666 hdr.msg_controllen = 0;
2667 hdr.msg_flags = 0;
2668 #endif
2669
2670 while ((ret = sendmsg(fd, &hdr, flags)) == -1)
2671 {
2672 if (errno == EISCONN)
2673 {
2674 hdr.msg_name = 0;
2675 hdr.msg_namelen = 0;
2676 continue;
2677 }
2678 if (errno != EINTR)
2679 return -1;
2680 }
2681
2682 n = ret;
2683 while (wsa->first_iovec < wsa->n_iovecs && wsa->iovec[wsa->first_iovec].iov_len <= n)
2684 n -= wsa->iovec[wsa->first_iovec++].iov_len;
2685 if (wsa->first_iovec < wsa->n_iovecs)
2686 {
2687 wsa->iovec[wsa->first_iovec].iov_base = (char*)wsa->iovec[wsa->first_iovec].iov_base + n;
2688 wsa->iovec[wsa->first_iovec].iov_len -= n;
2689 }
2690 return ret;
2691 }
2692
2693 /***********************************************************************
2694 * WS2_async_send (INTERNAL)
2695 *
2696 * Handler for overlapped send() operations.
2697 */
2698 static NTSTATUS WS2_async_send( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
2699 {
2700 struct ws2_async *wsa = user;
2701 int result = 0, fd;
2702
2703 switch (status)
2704 {
2705 case STATUS_ALERTED:
2706 if ( wsa->n_iovecs <= wsa->first_iovec )
2707 {
2708 /* Nothing to do */
2709 status = STATUS_SUCCESS;
2710 break;
2711 }
2712 if ((status = wine_server_handle_to_fd( wsa->hSocket, FILE_WRITE_DATA, &fd, NULL ) ))
2713 break;
2714
2715 /* check to see if the data is ready (non-blocking) */
2716 result = WS2_send( fd, wsa, convert_flags(wsa->flags) );
2717 wine_server_release_fd( wsa->hSocket, fd );
2718
2719 if (result >= 0)
2720 {
2721 if (wsa->first_iovec < wsa->n_iovecs)
2722 status = STATUS_PENDING;
2723 else
2724 status = STATUS_SUCCESS;
2725
2726 iosb->Information += result;
2727 }
2728 else if (errno == EAGAIN)
2729 {
2730 status = STATUS_PENDING;
2731 }
2732 else
2733 {
2734 status = wsaErrStatus();
2735 }
2736 break;
2737 }
2738 if (status != STATUS_PENDING)
2739 {
2740 iosb->u.Status = status;
2741 if (!wsa->completion_func)
2742 release_async_io( &wsa->io );
2743 }
2744 return status;
2745 }
2746
2747 /***********************************************************************
2748 * WS2_async_shutdown (INTERNAL)
2749 *
2750 * Handler for shutdown() operations on overlapped sockets.
2751 */
2752 static NTSTATUS WS2_async_shutdown( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
2753 {
2754 struct ws2_async_shutdown *wsa = user;
2755 int fd, err = 1;
2756
2757 switch (status)
2758 {
2759 case STATUS_ALERTED:
2760 if ((status = wine_server_handle_to_fd( wsa->hSocket, 0, &fd, NULL ) ))
2761 break;
2762
2763 switch ( wsa->type )
2764 {
2765 case ASYNC_TYPE_READ: err = shutdown( fd, 0 ); break;
2766 case ASYNC_TYPE_WRITE: err = shutdown( fd, 1 ); break;
2767 }
2768 status = err ? wsaErrStatus() : STATUS_SUCCESS;
2769 wine_server_release_fd( wsa->hSocket, fd );
2770 break;
2771 }
2772 iosb->u.Status = status;
2773 iosb->Information = 0;
2774 release_async_io( &wsa->io );
2775 return status;
2776 }
2777
2778 /***********************************************************************
2779 * WS2_register_async_shutdown (INTERNAL)
2780 *
2781 * Helper function for WS_shutdown() on overlapped sockets.
2782 */
2783 static int WS2_register_async_shutdown( SOCKET s, int type )
2784 {
2785 struct ws2_async_shutdown *wsa;
2786 NTSTATUS status;
2787
2788 TRACE("socket %04lx type %d\n", s, type);
2789
2790 wsa = (struct ws2_async_shutdown *)alloc_async_io( sizeof(*wsa), WS2_async_shutdown );
2791 if ( !wsa )
2792 return WSAEFAULT;
2793
2794 wsa->hSocket = SOCKET2HANDLE(s);
2795 wsa->type = type;
2796
2797 status = register_async( type, wsa->hSocket, &wsa->io, 0, NULL, NULL, &wsa->iosb );
2798 if (status != STATUS_PENDING)
2799 {
2800 HeapFree( GetProcessHeap(), 0, wsa );
2801 return NtStatusToWSAError( status );
2802 }
2803 return 0;
2804 }
2805
2806 /***********************************************************************
2807 * accept (WS2_32.1)
2808 */
2809 SOCKET WINAPI WS_accept(SOCKET s, struct WS_sockaddr *addr, int *addrlen32)
2810 {
2811 DWORD err;
2812 SOCKET as;
2813 int fd;
2814 BOOL is_blocking;
2815
2816 TRACE("socket %04lx\n", s );
2817 err = sock_is_blocking(s, &is_blocking);
2818 if (err)
2819 goto error;
2820
2821 for (;;)
2822 {
2823 /* try accepting first (if there is a deferred connection) */
2824 SERVER_START_REQ( accept_socket )
2825 {
2826 req->lhandle = wine_server_obj_handle( SOCKET2HANDLE(s) );
2827 req->access = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
2828 req->attributes = OBJ_INHERIT;
2829 err = NtStatusToWSAError( wine_server_call( req ));
2830 as = HANDLE2SOCKET( wine_server_ptr_handle( reply->handle ));
2831 }
2832 SERVER_END_REQ;
2833 if (!err)
2834 {
2835 if (addr && addrlen32 && WS_getpeername(as, addr, addrlen32))
2836 {
2837 WS_closesocket(as);
2838 return SOCKET_ERROR;
2839 }
2840 TRACE("\taccepted %04lx\n", as);
2841 return as;
2842 }
2843 if (!is_blocking) break;
2844 if (err != WSAEWOULDBLOCK) break;
2845 fd = get_sock_fd( s, FILE_READ_DATA, NULL );
2846 /* block here */
2847 do_block(fd, POLLIN, -1);
2848 _sync_sock_state(s); /* let wineserver notice connection */
2849 release_sock_fd( s, fd );
2850 }
2851
2852 error:
2853 WARN(" -> ERROR %d\n", err);
2854 SetLastError(err);
2855 return INVALID_SOCKET;
2856 }
2857
2858 /***********************************************************************
2859 * AcceptEx
2860 */
2861 static BOOL WINAPI WS2_AcceptEx(SOCKET listener, SOCKET acceptor, PVOID dest, DWORD dest_len,
2862 DWORD local_addr_len, DWORD rem_addr_len, LPDWORD received,
2863 LPOVERLAPPED overlapped)
2864 {
2865 DWORD status;
2866 struct ws2_accept_async *wsa;
2867 int fd;
2868
2869 TRACE("(%04lx, %04lx, %p, %d, %d, %d, %p, %p)\n", listener, acceptor, dest, dest_len, local_addr_len,
2870 rem_addr_len, received, overlapped);
2871
2872 if (!overlapped)
2873 {
2874 SetLastError(WSA_INVALID_PARAMETER);
2875 return FALSE;
2876 }
2877 overlapped->Internal = STATUS_PENDING;
2878
2879 if (!dest)
2880 {
2881 SetLastError(WSAEINVAL);
2882 return FALSE;
2883 }
2884
2885 if (!rem_addr_len)
2886 {
2887 SetLastError(WSAEFAULT);
2888 return FALSE;
2889 }
2890
2891 fd = get_sock_fd( listener, FILE_READ_DATA, NULL );
2892 if (fd == -1) return FALSE;
2893 release_sock_fd( listener, fd );
2894
2895 fd = get_sock_fd( acceptor, FILE_READ_DATA, NULL );
2896 if (fd == -1) return FALSE;
2897 release_sock_fd( acceptor, fd );
2898
2899 wsa = (struct ws2_accept_async *)alloc_async_io( sizeof(*wsa), WS2_async_accept );
2900 if(!wsa)
2901 {
2902 SetLastError(WSAEFAULT);
2903 return FALSE;
2904 }
2905
2906 wsa->listen_socket = SOCKET2HANDLE(listener);
2907 wsa->accept_socket = SOCKET2HANDLE(acceptor);
2908 wsa->user_overlapped = overlapped;
2909 wsa->cvalue = !((ULONG_PTR)overlapped->hEvent & 1) ? (ULONG_PTR)overlapped : 0;
2910 wsa->buf = dest;
2911 wsa->data_len = dest_len;
2912 wsa->local_len = local_addr_len;
2913 wsa->remote_len = rem_addr_len;
2914 wsa->read = NULL;
2915
2916 if (wsa->data_len)
2917 {
2918 /* set up a read request if we need it */
2919 wsa->read = (struct ws2_async *)alloc_async_io( offsetof(struct ws2_async, iovec[1]), WS2_async_accept_recv );
2920 if (!wsa->read)
2921 {
2922 HeapFree( GetProcessHeap(), 0, wsa );
2923 SetLastError(WSAEFAULT);
2924 return FALSE;
2925 }
2926
2927 wsa->read->hSocket = wsa->accept_socket;
2928 wsa->read->flags = 0;
2929 wsa->read->lpFlags = &wsa->read->flags;
2930 wsa->read->addr = NULL;
2931 wsa->read->addrlen.ptr = NULL;
2932 wsa->read->control = NULL;
2933 wsa->read->n_iovecs = 1;
2934 wsa->read->first_iovec = 0;
2935 wsa->read->completion_func = NULL;
2936 wsa->read->iovec[0].iov_base = wsa->buf;
2937 wsa->read->iovec[0].iov_len = wsa->data_len;
2938 }
2939
2940 status = register_async( ASYNC_TYPE_READ, SOCKET2HANDLE(listener), &wsa->io,
2941 overlapped->hEvent, NULL, (void *)wsa->cvalue, (IO_STATUS_BLOCK *)overlapped );
2942
2943 if(status != STATUS_PENDING)
2944 {
2945 HeapFree( GetProcessHeap(), 0, wsa->read );
2946 HeapFree( GetProcessHeap(), 0, wsa );
2947 }
2948
2949 SetLastError( NtStatusToWSAError(status) );
2950 return FALSE;
2951 }
2952
2953 /***********************************************************************
2954 * WS2_ReadFile (INTERNAL)
2955 *
2956 * Perform an APC-safe ReadFile operation
2957 */
2958 static NTSTATUS WS2_ReadFile(HANDLE hFile, PIO_STATUS_BLOCK io_status, char* buffer, ULONG length,
2959 PLARGE_INTEGER offset)
2960 {
2961 int result = -1, unix_handle;
2962 unsigned int options;
2963 NTSTATUS status;
2964
2965 TRACE( "(%p,%p,0x%08x)\n", hFile, buffer,length );
2966
2967 status = wine_server_handle_to_fd( hFile, FILE_READ_DATA, &unix_handle, &options );
2968 if (status) return status;
2969
2970 while (result == -1)
2971 {
2972 if (offset->QuadPart != FILE_USE_FILE_POINTER_POSITION)
2973 result = pread( unix_handle, buffer, length, offset->QuadPart );
2974 else
2975 result = read( unix_handle, buffer, length );
2976 if (errno != EINTR)
2977 break;
2978 }
2979
2980 if (!result)
2981 status = (length ? STATUS_END_OF_FILE : STATUS_SUCCESS);
2982 else if (result != -1)
2983 status = STATUS_SUCCESS;
2984 else if (errno != EAGAIN)
2985 status = wsaErrStatus();
2986 else
2987 status = STATUS_PENDING;
2988
2989 wine_server_release_fd( hFile, unix_handle );
2990 TRACE("= 0x%08x (%d)\n", status, result);
2991 if (status == STATUS_SUCCESS || status == STATUS_END_OF_FILE)
2992 {
2993 io_status->u.Status = status;
2994 io_status->Information = result;
2995 }
2996
2997 return status;
2998 }
2999
3000 /***********************************************************************
3001 * WS2_transmitfile_getbuffer (INTERNAL)
3002 *
3003 * Pick the appropriate buffer for a TransmitFile send operation.
3004 */
3005 static NTSTATUS WS2_transmitfile_getbuffer( int fd, struct ws2_transmitfile_async *wsa )
3006 {
3007 /* send any incomplete writes from a previous iteration */
3008 if (wsa->write.first_iovec < wsa->write.n_iovecs)
3009 return STATUS_PENDING;
3010
3011 /* process the header (if applicable) */
3012 if (wsa->buffers.Head)
3013 {
3014 wsa->write.first_iovec = 0;
3015 wsa->write.n_iovecs = 1;
3016 wsa->write.iovec[0].iov_base = wsa->buffers.Head;
3017 wsa->write.iovec[0].iov_len = wsa->buffers.HeadLength;
3018 wsa->buffers.Head = NULL;
3019 return STATUS_PENDING;
3020 }
3021
3022 /* process the main file */
3023 if (wsa->file)
3024 {
3025 DWORD bytes_per_send = wsa->bytes_per_send;
3026 IO_STATUS_BLOCK iosb;
3027 NTSTATUS status;
3028
3029 iosb.Information = 0;
3030 /* when the size of the transfer is limited ensure that we don't go past that limit */
3031 if (wsa->file_bytes != 0)
3032 bytes_per_send = min(bytes_per_send, wsa->file_bytes - wsa->file_read);
3033 status = WS2_ReadFile( wsa->file, &iosb, wsa->buffer, bytes_per_send, &wsa->offset );
3034 if (wsa->offset.QuadPart != FILE_USE_FILE_POINTER_POSITION)
3035 wsa->offset.QuadPart += iosb.Information;
3036 if (status == STATUS_END_OF_FILE)
3037 wsa->file = NULL; /* continue on to the footer */
3038 else if (status != STATUS_SUCCESS)
3039 return status;
3040 else
3041 {
3042 if (iosb.Information)
3043 {
3044 wsa->write.first_iovec = 0;
3045 wsa->write.n_iovecs = 1;
3046 wsa->write.iovec[0].iov_base = wsa->buffer;
3047 wsa->write.iovec[0].iov_len = iosb.Information;
3048 wsa->file_read += iosb.Information;
3049 }
3050
3051 if (wsa->file_bytes != 0 && wsa->file_read >= wsa->file_bytes)
3052 wsa->file = NULL;
3053
3054 return STATUS_PENDING;
3055 }
3056 }
3057
3058 /* send the footer (if applicable) */
3059 if (wsa->buffers.Tail)
3060 {
3061 wsa->write.first_iovec = 0;
3062 wsa->write.n_iovecs = 1;
3063 wsa->write.iovec[0].iov_base = wsa->buffers.Tail;
3064 wsa->write.iovec[0].iov_len = wsa->buffers.TailLength;
3065 wsa->buffers.Tail = NULL;
3066 return STATUS_PENDING;
3067 }
3068
3069 return STATUS_SUCCESS;
3070 }
3071
3072 /***********************************************************************
3073 * WS2_transmitfile_base (INTERNAL)
3074 *
3075 * Shared implementation for both synchronous and asynchronous TransmitFile.
3076 */
3077 static NTSTATUS WS2_transmitfile_base( int fd, struct ws2_transmitfile_async *wsa )
3078 {
3079 NTSTATUS status;
3080
3081 status = WS2_transmitfile_getbuffer( fd, wsa );
3082 if (status == STATUS_PENDING)
3083 {
3084 IO_STATUS_BLOCK *iosb = (IO_STATUS_BLOCK *)wsa->write.user_overlapped;
3085 int n;
3086
3087 n = WS2_send( fd, &wsa->write, convert_flags(wsa->write.flags) );
3088 if (n >= 0)
3089 {
3090 if (iosb) iosb->Information += n;
3091 }
3092 else if (errno != EAGAIN)
3093 return wsaErrStatus();
3094 }
3095
3096 return status;
3097 }
3098
3099 /***********************************************************************
3100 * WS2_async_transmitfile (INTERNAL)
3101 *
3102 * Asynchronous callback for overlapped TransmitFile operations.
3103 */
3104 static NTSTATUS WS2_async_transmitfile( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
3105 {
3106 struct ws2_transmitfile_async *wsa = user;
3107 int fd;
3108
3109 if (status == STATUS_ALERTED)
3110 {
3111 if (!(status = wine_server_handle_to_fd( wsa->write.hSocket, FILE_WRITE_DATA, &fd, NULL )))
3112 {
3113 status = WS2_transmitfile_base( fd, wsa );
3114 wine_server_release_fd( wsa->write.hSocket, fd );
3115 }
3116 if (status == STATUS_PENDING)
3117 return status;
3118 }
3119
3120 iosb->u.Status = status;
3121 release_async_io( &wsa->io );
3122 return status;
3123 }
3124
3125 /***********************************************************************
3126 * TransmitFile
3127 */
3128 static BOOL WINAPI WS2_TransmitFile( SOCKET s, HANDLE h, DWORD file_bytes, DWORD bytes_per_send,
3129 LPOVERLAPPED overlapped, LPTRANSMIT_FILE_BUFFERS buffers,
3130 DWORD flags )
3131 {
3132 union generic_unix_sockaddr uaddr;
3133 socklen_t uaddrlen = sizeof(uaddr);
3134 struct ws2_transmitfile_async *wsa;
3135 NTSTATUS status;
3136 int fd;
3137
3138 TRACE("(%lx, %p, %d, %d, %p, %p, %d)\n", s, h, file_bytes, bytes_per_send, overlapped,
3139 buffers, flags );
3140
3141 fd = get_sock_fd( s, FILE_WRITE_DATA, NULL );
3142 if (fd == -1) return FALSE;
3143
3144 if (getpeername( fd, &uaddr.addr, &uaddrlen ) != 0)
3145 {
3146 release_sock_fd( s, fd );
3147 WSASetLastError( WSAENOTCONN );
3148 return FALSE;
3149 }
3150 if (flags)
3151 FIXME("Flags are not currently supported (0x%x).\n", flags);
3152
3153 if (h && GetFileType( h ) != FILE_TYPE_DISK)
3154 {
3155 FIXME("Non-disk file handles are not currently supported.\n");
3156 release_sock_fd( s, fd );
3157 WSASetLastError( WSAEOPNOTSUPP );
3158 return FALSE;
3159 }
3160
3161 /* set reasonable defaults when requested */
3162 if (!bytes_per_send)
3163 bytes_per_send = (1 << 16); /* Depends on OS version: PAGE_SIZE, 2*PAGE_SIZE, or 2^16 */
3164
3165 if (!(wsa = (struct ws2_transmitfile_async *)alloc_async_io( sizeof(*wsa) + bytes_per_send,
3166 WS2_async_transmitfile )))
3167 {
3168 release_sock_fd( s, fd );
3169 WSASetLastError( WSAEFAULT );
3170 return FALSE;
3171 }
3172 if (buffers)
3173 wsa->buffers = *buffers;
3174 else
3175 memset(&wsa->buffers, 0x0, sizeof(wsa->buffers));
3176 wsa->buffer = (char *)(wsa + 1);
3177 wsa->file = h;
3178 wsa->file_read = 0;
3179 wsa->file_bytes = file_bytes;
3180 wsa->bytes_per_send = bytes_per_send;
3181 wsa->flags = flags;
3182 wsa->offset.QuadPart = FILE_USE_FILE_POINTER_POSITION;
3183 wsa->write.hSocket = SOCKET2HANDLE(s);
3184 wsa->write.addr = NULL;
3185 wsa->write.addrlen.val = 0;
3186 wsa->write.flags = 0;
3187 wsa->write.lpFlags = &wsa->flags;
3188 wsa->write.control = NULL;
3189 wsa->write.n_iovecs = 0;
3190 wsa->write.first_iovec = 0;
3191 wsa->write.user_overlapped = overlapped;
3192 if (overlapped)
3193 {
3194 IO_STATUS_BLOCK *iosb = (IO_STATUS_BLOCK *)overlapped;
3195 int status;
3196
3197 wsa->offset.u.LowPart = overlapped->u.s.Offset;
3198 wsa->offset.u.HighPart = overlapped->u.s.OffsetHigh;
3199 iosb->u.Status = STATUS_PENDING;
3200 iosb->Information = 0;
3201 status = register_async( ASYNC_TYPE_WRITE, SOCKET2HANDLE(s), &wsa->io,
3202 overlapped->hEvent, NULL, NULL, iosb );
3203 if(status != STATUS_PENDING) HeapFree( GetProcessHeap(), 0, wsa );
3204 release_sock_fd( s, fd );
3205 WSASetLastError( NtStatusToWSAError(status) );
3206 return FALSE;
3207 }
3208
3209 do
3210 {
3211 status = WS2_transmitfile_base( fd, wsa );
3212 if (status == STATUS_PENDING)
3213 {
3214 /* block here */
3215 do_block(fd, POLLOUT, -1);
3216 _sync_sock_state(s); /* let wineserver notice connection */
3217 }
3218 }
3219 while (status == STATUS_PENDING);
3220 release_sock_fd( s, fd );
3221
3222 if (status != STATUS_SUCCESS)
3223 WSASetLastError( NtStatusToWSAError(status) );
3224 HeapFree( GetProcessHeap(), 0, wsa );
3225 return (status == STATUS_SUCCESS);
3226 }
3227
3228 /***********************************************************************
3229 * GetAcceptExSockaddrs
3230 */
3231 static void WINAPI WS2_GetAcceptExSockaddrs(PVOID buffer, DWORD data_size, DWORD local_size, DWORD remote_size,
3232 struct WS_sockaddr **local_addr, LPINT local_addr_len,
3233 struct WS_sockaddr **remote_addr, LPINT remote_addr_len)
3234 {
3235 char *cbuf = buffer;
3236 TRACE("(%p, %d, %d, %d, %p, %p, %p, %p)\n", buffer, data_size, local_size, remote_size, local_addr,
3237 local_addr_len, remote_addr, remote_addr_len );
3238 cbuf += data_size;
3239
3240 *local_addr_len = *(int *) cbuf;
3241 *local_addr = (struct WS_sockaddr *)(cbuf + sizeof(int));
3242
3243 cbuf += local_size;
3244
3245 *remote_addr_len = *(int *) cbuf;
3246 *remote_addr = (struct WS_sockaddr *)(cbuf + sizeof(int));
3247 }
3248
3249 /***********************************************************************
3250 * WSASendMsg
3251 */
3252 int WINAPI WSASendMsg( SOCKET s, LPWSAMSG msg, DWORD dwFlags, LPDWORD lpNumberOfBytesSent,
3253 LPWSAOVERLAPPED lpOverlapped,
3254 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
3255 {
3256 if (!msg)
3257 {
3258 SetLastError( WSAEFAULT );
3259 return SOCKET_ERROR;
3260 }
3261
3262 return WS2_sendto( s, msg->lpBuffers, msg->dwBufferCount, lpNumberOfBytesSent,
3263 dwFlags, msg->name, msg->namelen,
3264 lpOverlapped, lpCompletionRoutine );
3265 }
3266
3267 /***********************************************************************
3268 * WSARecvMsg
3269 *
3270 * Perform a receive operation that is capable of returning message
3271 * control headers. It is important to note that the WSAMSG parameter
3272 * must remain valid throughout the operation, even when an overlapped
3273 * receive is performed.
3274 */
3275 static int WINAPI WS2_WSARecvMsg( SOCKET s, LPWSAMSG msg, LPDWORD lpNumberOfBytesRecvd,
3276 LPWSAOVERLAPPED lpOverlapped,
3277 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
3278 {
3279 if (!msg)
3280 {
3281 SetLastError( WSAEFAULT );
3282 return SOCKET_ERROR;
3283 }
3284
3285 return WS2_recv_base( s, msg->lpBuffers, msg->dwBufferCount, lpNumberOfBytesRecvd,
3286 &msg->dwFlags, msg->name, &msg->namelen,
3287 lpOverlapped, lpCompletionRoutine, &msg->Control );
3288 }
3289
3290 /***********************************************************************
3291 * interface_bind (INTERNAL)
3292 *
3293 * Take bind() calls on any name corresponding to a local network adapter and restrict the given socket to
3294 * operating only on the specified interface. This restriction consists of two components:
3295 * 1) An outgoing packet restriction suggesting the egress interface for all packets.
3296 * 2) An incoming packet restriction dropping packets not meant for the interface.
3297 * If the function succeeds in placing these restrictions (returns TRUE) then the name for the bind() may
3298 * safely be changed to INADDR_ANY, permitting the transmission and receipt of broadcast packets on the
3299 * socket. This behavior is only relevant to UDP sockets and is needed for applications that expect to be able
3300 * to receive broadcast packets on a socket that is bound to a specific network interface.
3301 */
3302 static BOOL interface_bind( SOCKET s, int fd, struct sockaddr *addr )
3303 {
3304 struct sockaddr_in *in_sock = (struct sockaddr_in *) addr;
3305 in_addr_t bind_addr = in_sock->sin_addr.s_addr;
3306 PIP_ADAPTER_INFO adapters = NULL, adapter;
3307 BOOL ret = FALSE;
3308 DWORD adap_size;
3309 int enable = 1;
3310
3311 if (bind_addr == htonl(INADDR_ANY) || bind_addr == htonl(INADDR_LOOPBACK))
3312 return FALSE; /* Not binding to a network adapter, special interface binding unnecessary. */
3313 if (_get_fd_type(fd) != SOCK_DGRAM)
3314 return FALSE; /* Special interface binding is only necessary for UDP datagrams. */
3315 if (GetAdaptersInfo(NULL, &adap_size) != ERROR_BUFFER_OVERFLOW)
3316 goto cleanup;
3317 adapters = HeapAlloc(GetProcessHeap(), 0, adap_size);
3318 if (adapters == NULL || GetAdaptersInfo(adapters, &adap_size) != NO_ERROR)
3319 goto cleanup;
3320 /* Search the IPv4 adapter list for the appropriate binding interface */
3321 for (adapter = adapters; adapter != NULL; adapter = adapter->Next)
3322 {
3323 in_addr_t adapter_addr = (in_addr_t) inet_addr(adapter->IpAddressList.IpAddress.String);
3324
3325 if (bind_addr == adapter_addr)
3326 {
3327 #if defined(IP_BOUND_IF)
3328 /* IP_BOUND_IF sets both the incoming and outgoing restriction at once */
3329 if (setsockopt(fd, IPPROTO_IP, IP_BOUND_IF, &adapter->Index, sizeof(adapter->Index)) != 0)
3330 goto cleanup;
3331 ret = TRUE;
3332 #elif defined(LINUX_BOUND_IF)
3333 in_addr_t ifindex = (in_addr_t) htonl(adapter->Index);
3334 struct interface_filter specific_interface_filter;
3335 struct sock_fprog filter_prog;
3336
3337 if (setsockopt(fd, IPPROTO_IP, IP_UNICAST_IF, &ifindex, sizeof(ifindex)) != 0)
3338 goto cleanup; /* Failed to suggest egress interface */
3339 specific_interface_filter = generic_interface_filter;
3340 specific_interface_filter.iface_rule.k = adapter->Index;
3341 specific_interface_filter.ip_rule.k = htonl(adapter_addr);
3342 filter_prog.len = sizeof(generic_interface_filter)/sizeof(struct sock_filter);
3343 filter_prog.filter = (struct sock_filter *) &specific_interface_filter;
3344 if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog, sizeof(filter_prog)) != 0)
3345 goto cleanup; /* Failed to specify incoming packet filter */
3346 ret = TRUE;
3347 #else
3348 FIXME("Broadcast packets on interface-bound sockets are not currently supported on this platform, "
3349 "receiving broadcast packets will not work on socket %04lx.\n", s);
3350 #endif
3351 if (ret)
3352 {
3353 EnterCriticalSection(&cs_if_addr_cache);
3354 if (if_addr_cache_size <= adapter->Index)
3355 {
3356 unsigned int new_size;
3357 in_addr_t *new;
3358
3359 new_size = max(if_addr_cache_size * 2, adapter->Index + 1);
3360 if (!(new = heap_realloc(if_addr_cache, sizeof(*if_addr_cache) * new_size)))
3361 {
3362 ERR("No memory.\n");
3363 ret = FALSE;
3364 LeaveCriticalSection(&cs_if_addr_cache);
3365 break;
3366 }
3367 memset(new + if_addr_cache_size, 0, sizeof(*if_addr_cache)
3368 * (new_size - if_addr_cache_size));
3369 if_addr_cache = new;
3370 if_addr_cache_size = new_size;
3371 }
3372 if (if_addr_cache[adapter->Index] && if_addr_cache[adapter->Index] != adapter_addr)
3373 WARN("Adapter addr for iface index %u has changed.\n", adapter->Index);
3374
3375 if_addr_cache[adapter->Index] = adapter_addr;
3376 LeaveCriticalSection(&cs_if_addr_cache);
3377 }
3378 break;
3379 }
3380 }
3381 /* Will soon be switching to INADDR_ANY: permit address reuse */
3382 if (ret && setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)) == 0)
3383 TRACE("Socket %04lx bound to interface index %d\n", s, adapter->Index);
3384 else
3385 ret = FALSE;
3386
3387 cleanup:
3388 if(!ret)
3389 ERR("Failed to bind to interface, receiving broadcast packets will not work on socket %04lx.\n", s);
3390 HeapFree(GetProcessHeap(), 0, adapters);
3391 return ret;
3392 }
3393
3394 /***********************************************************************
3395 * bind (WS2_32.2)
3396 */
3397 int WINAPI WS_bind(SOCKET s, const struct WS_sockaddr* name, int namelen)
3398 {
3399 int fd = get_sock_fd( s, 0, NULL );
3400 int res = SOCKET_ERROR;
3401
3402 TRACE("socket %04lx, ptr %p %s, length %d\n", s, name, debugstr_sockaddr(name), namelen);
3403
3404 if (fd != -1)
3405 {
3406 if (!name || (name->sa_family && !supported_pf(name->sa_family)))
3407 {
3408 SetLastError(WSAEAFNOSUPPORT);
3409 }
3410 else
3411 {
3412 union generic_unix_sockaddr uaddr;
3413 unsigned int uaddrlen = ws_sockaddr_ws2u(name, namelen, &uaddr);
3414 if (!uaddrlen)
3415 {
3416 SetLastError(WSAEFAULT);
3417 }
3418 else
3419 {
3420 if (name->sa_family == WS_AF_INET)
3421 {
3422 struct sockaddr_in *in4 = (struct sockaddr_in*) &uaddr;
3423 if (memcmp(&in4->sin_addr, magic_loopback_addr, 4) == 0)
3424 {
3425 /* Trying to bind to the default host interface, using
3426 * INADDR_ANY instead*/
3427 WARN("Trying to bind to magic IP address, using "
3428 "INADDR_ANY instead.\n");
3429 in4->sin_addr.s_addr = htonl(INADDR_ANY);
3430 }
3431 else if (interface_bind(s, fd, &uaddr.addr))
3432 in4->sin_addr.s_addr = htonl(INADDR_ANY);
3433 }
3434 if (bind(fd, &uaddr.addr, uaddrlen) < 0)
3435 {
3436 int loc_errno = errno;
3437 WARN("\tfailure - errno = %i\n", errno);
3438 errno = loc_errno;
3439 switch (errno)
3440 {
3441 case EADDRNOTAVAIL:
3442 SetLastError(WSAEINVAL);
3443 break;
3444 case EADDRINUSE:
3445 {
3446 int optval = 0;
3447 socklen_t optlen = sizeof(optval);
3448 /* Windows >= 2003 will return different results depending on
3449 * SO_REUSEADDR, WSAEACCES may be returned representing that
3450 * the socket hijacking protection prevented the bind */
3451 if (!getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&optval, &optlen) && optval)
3452 {
3453 SetLastError(WSAEACCES);
3454 break;
3455 }
3456 /* fall through */
3457 }
3458 default:
3459 SetLastError(wsaErrno());
3460 break;
3461 }
3462 }
3463 else
3464 {
3465 res=0; /* success */
3466 }
3467 }
3468 }
3469 release_sock_fd( s, fd );
3470 }
3471 return res;
3472 }
3473
3474 /***********************************************************************
3475 * closesocket (WS2_32.3)
3476 */
3477 int WINAPI WS_closesocket(SOCKET s)
3478 {
3479 int res = SOCKET_ERROR, fd;
3480 if (num_startup)
3481 {
3482 fd = get_sock_fd(s, FILE_READ_DATA, NULL);
3483 if (fd >= 0)
3484 {
3485 release_sock_fd(s, fd);
3486 if (CloseHandle(SOCKET2HANDLE(s)))
3487 res = 0;
3488 }
3489 }
3490 else
3491 SetLastError(WSANOTINITIALISED);
3492 TRACE("(socket %04lx) -> %d\n", s, res);
3493 return res;
3494 }
3495
3496 static int do_connect(int fd, const struct WS_sockaddr* name, int namelen)
3497 {
3498 union generic_unix_sockaddr uaddr;
3499 unsigned int uaddrlen = ws_sockaddr_ws2u(name, namelen, &uaddr);
3500
3501 if (!uaddrlen)
3502 return WSAEFAULT;
3503
3504 if (name->sa_family == WS_AF_INET)
3505 {
3506 struct sockaddr_in *in4 = (struct sockaddr_in*) &uaddr;
3507 if (memcmp(&in4->sin_addr, magic_loopback_addr, 4) == 0)
3508 {
3509 /* Trying to connect to magic replace-loopback address,
3510 * assuming we really want to connect to localhost */
3511 TRACE("Trying to connect to magic IP address, using "
3512 "INADDR_LOOPBACK instead.\n");
3513 in4->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
3514 }
3515 }
3516
3517 if (connect(fd, &uaddr.addr, uaddrlen) == 0)
3518 return 0;
3519
3520 return wsaErrno();
3521 }
3522
3523 /***********************************************************************
3524 * connect (WS2_32.4)
3525 */
3526 int WINAPI WS_connect(SOCKET s, const struct WS_sockaddr* name, int namelen)
3527 {
3528 int fd = get_sock_fd( s, FILE_READ_DATA, NULL );
3529
3530 TRACE("socket %04lx, ptr %p %s, length %d\n", s, name, debugstr_sockaddr(name), namelen);
3531
3532 if (fd != -1)
3533 {
3534 BOOL is_blocking;
3535 int ret = do_connect(fd, name, namelen);
3536 if (ret == 0)
3537 goto connect_success;
3538
3539 if (ret == WSAEINPROGRESS)
3540 {
3541 /* tell wineserver that a connection is in progress */
3542 _enable_event(SOCKET2HANDLE(s), FD_CONNECT|FD_READ|FD_WRITE,
3543 FD_CONNECT,
3544 FD_WINE_CONNECTED|FD_WINE_LISTENING);
3545 ret = sock_is_blocking( s, &is_blocking );
3546 if (!ret)
3547 {
3548 if (is_blocking)
3549 {
3550 do_block(fd, POLLIN | POLLOUT, -1);
3551 _sync_sock_state(s); /* let wineserver notice connection */
3552 /* retrieve any error codes from it */
3553 if (!(ret = get_sock_error(s, FD_CONNECT_BIT))) goto connect_success;
3554 }
3555 else ret = WSAEWOULDBLOCK;
3556 }
3557 }
3558 release_sock_fd( s, fd );
3559 SetLastError(ret);
3560 }
3561 return SOCKET_ERROR;
3562
3563 connect_success:
3564 release_sock_fd( s, fd );
3565 _enable_event(SOCKET2HANDLE(s), FD_CONNECT|FD_READ|FD_WRITE,
3566 FD_WINE_CONNECTED|FD_READ|FD_WRITE,
3567 FD_CONNECT|FD_WINE_LISTENING);
3568 TRACE("\tconnected %04lx\n", s);
3569 return 0;
3570 }
3571
3572 /***********************************************************************
3573 * WSAConnect (WS2_32.30)
3574 */
3575 int WINAPI WSAConnect( SOCKET s, const struct WS_sockaddr* name, int namelen,
3576 LPWSABUF lpCallerData, LPWSABUF lpCalleeData,
3577 LPQOS lpSQOS, LPQOS lpGQOS )
3578 {
3579 if ( lpCallerData || lpCalleeData || lpSQOS || lpGQOS )
3580 FIXME("unsupported parameters!\n");
3581 return WS_connect( s, name, namelen );
3582 }
3583
3584 /***********************************************************************
3585 * ConnectEx
3586 */
3587 static BOOL WINAPI WS2_ConnectEx(SOCKET s, const struct WS_sockaddr* name, int namelen,
3588 PVOID sendBuf, DWORD sendBufLen, LPDWORD sent, LPOVERLAPPED ov)
3589 {
3590 int fd, ret, status;
3591
3592 if (!ov)
3593 {
3594 SetLastError( ERROR_INVALID_PARAMETER );
3595 return FALSE;
3596 }
3597
3598 fd = get_sock_fd( s, FILE_READ_DATA, NULL );
3599 if (fd == -1) return FALSE;
3600
3601 TRACE("socket %04lx, ptr %p %s, length %d, sendptr %p, len %d, ov %p\n",
3602 s, name, debugstr_sockaddr(name), namelen, sendBuf, sendBufLen, ov);
3603
3604 ret = is_fd_bound(fd, NULL, NULL);
3605 if (ret <= 0)
3606 {
3607 SetLastError(ret == -1 ? wsaErrno() : WSAEINVAL);
3608 release_sock_fd( s, fd );
3609 return FALSE;
3610 }
3611
3612 ret = do_connect(fd, name, namelen);
3613 if (ret == 0)
3614 {
3615 WSABUF wsabuf;
3616
3617 _enable_event(SOCKET2HANDLE(s), FD_CONNECT|FD_READ|FD_WRITE,
3618 FD_WINE_CONNECTED|FD_READ|FD_WRITE,
3619 FD_CONNECT|FD_WINE_LISTENING);
3620
3621 wsabuf.len = sendBufLen;
3622 wsabuf.buf = (char*) sendBuf;
3623
3624 /* WSASend takes care of completion if need be */
3625 if (WSASend(s, &wsabuf, sendBuf ? 1 : 0, sent, 0, ov, NULL) != SOCKET_ERROR)
3626 goto connection_success;
3627 }
3628 else if (ret == WSAEINPROGRESS)
3629 {
3630 struct ws2_async *wsa;
3631 ULONG_PTR cvalue = (((ULONG_PTR)ov->hEvent & 1) == 0) ? (ULONG_PTR)ov : 0;
3632
3633 _enable_event(SOCKET2HANDLE(s), FD_CONNECT|FD_READ|FD_WRITE,
3634 FD_CONNECT,
3635 FD_WINE_CONNECTED|FD_WINE_LISTENING);
3636
3637 /* Indirectly call WSASend */
3638 if (!(wsa = (struct ws2_async *)alloc_async_io( offsetof( struct ws2_async, iovec[1] ), WS2_async_send )))
3639 {
3640 SetLastError(WSAEFAULT);
3641 }
3642 else
3643 {
3644 IO_STATUS_BLOCK *iosb = (IO_STATUS_BLOCK *)ov;
3645 iosb->u.Status = STATUS_PENDING;
3646 iosb->Information = 0;
3647
3648 wsa->hSocket = SOCKET2HANDLE(s);
3649 wsa->addr = NULL;
3650 wsa->addrlen.val = 0;
3651 wsa->flags = 0;
3652 wsa->lpFlags = &wsa->flags;
3653 wsa->control = NULL;
3654 wsa->n_iovecs = sendBuf ? 1 : 0;
3655 wsa->first_iovec = 0;
3656 wsa->completion_func = NULL;
3657 wsa->iovec[0].iov_base = sendBuf;
3658 wsa->iovec[0].iov_len = sendBufLen;
3659
3660 status = register_async( ASYNC_TYPE_WRITE, wsa->hSocket, &wsa->io, ov->hEvent,
3661 NULL, (void *)cvalue, iosb );
3662 if (status != STATUS_PENDING) HeapFree(GetProcessHeap(), 0, wsa);
3663
3664 /* If the connect already failed */
3665 if (status == STATUS_PIPE_DISCONNECTED)
3666 {
3667 ov->Internal = sock_error_to_ntstatus( get_sock_error( s, FD_CONNECT_BIT ));
3668 ov->InternalHigh = 0;
3669 if (cvalue) WS_AddCompletion( s, cvalue, ov->Internal, ov->InternalHigh, FALSE );
3670 if (ov->hEvent) NtSetEvent( ov->hEvent, NULL );
3671 status = STATUS_PENDING;
3672 }
3673 SetLastError( NtStatusToWSAError(status) );
3674 }
3675 }
3676 else
3677 {
3678 SetLastError(ret);
3679 }
3680
3681 release_sock_fd( s, fd );
3682 return FALSE;
3683
3684 connection_success:
3685 release_sock_fd( s, fd );
3686 return TRUE;
3687 }
3688
3689 /***********************************************************************
3690 * DisconnectEx
3691 */
3692 static BOOL WINAPI WS2_DisconnectEx( SOCKET s, LPOVERLAPPED ov, DWORD flags, DWORD reserved )
3693 {
3694 TRACE( "socket %04lx, ov %p, flags 0x%x, reserved 0x%x\n", s, ov, flags, reserved );
3695
3696 if (flags & TF_REUSE_SOCKET)
3697 FIXME( "Reusing socket not supported yet\n" );
3698
3699 if (ov)
3700 {
3701 ov->Internal = STATUS_PENDING;
3702 ov->InternalHigh = 0;
3703 }
3704
3705 return !WS_shutdown( s, SD_BOTH );
3706 }
3707
3708 /***********************************************************************
3709 * getpeername (WS2_32.5)
3710 */
3711 int WINAPI WS_getpeername(SOCKET s, struct WS_sockaddr *name, int *namelen)
3712 {
3713 int fd;
3714 int res;
3715
3716 TRACE("socket %04lx, ptr %p, len %08x\n", s, name, namelen ? *namelen : 0);
3717
3718 fd = get_sock_fd( s, 0, NULL );
3719 res = SOCKET_ERROR;
3720
3721 if (fd != -1)
3722 {
3723 union generic_unix_sockaddr uaddr;
3724 socklen_t uaddrlen = sizeof(uaddr);
3725
3726 if (getpeername(fd, &uaddr.addr, &uaddrlen) == 0)
3727 {
3728 if (!name || !namelen)
3729 SetLastError(WSAEFAULT);
3730 else if (ws_sockaddr_u2ws(&uaddr.addr, name, namelen) != 0)
3731 /* The buffer was too small */
3732 SetLastError(WSAEFAULT);
3733 else
3734 {
3735 res = 0;
3736 TRACE("=> %s\n", debugstr_sockaddr(name));
3737 }
3738 }
3739 else
3740 SetLastError(wsaErrno());
3741 release_sock_fd( s, fd );
3742 }
3743 return res;
3744 }
3745
3746 /* When binding to an UDP address with filter support the getsockname call on the socket
3747 * will always return 0.0.0.0 instead of the filtered interface address. This function
3748 * checks if the socket is interface-bound on UDP and return the correct address.
3749 * This is required because applications often do a bind() with port zero followed by a
3750 * getsockname() to retrieve the port and address acquired.
3751 */
3752 static void interface_bind_check(int fd, struct sockaddr_in *addr)
3753 {
3754 #if !defined(IP_BOUND_IF) && !defined(LINUX_BOUND_IF)
3755 return;
3756 #else
3757 unsigned int ifindex;
3758 int ret;
3759 socklen_t len;
3760
3761 /* Check for IPv4, address 0.0.0.0 and UDP socket */
3762 if (addr->sin_family != AF_INET || addr->sin_addr.s_addr != 0)
3763 return;
3764 if (_get_fd_type(fd) != SOCK_DGRAM)
3765 return;
3766
3767 len = sizeof(ifindex);
3768 #if defined(IP_BOUND_IF)
3769 ret = getsockopt(fd, IPPROTO_IP, IP_BOUND_IF, &ifindex, &len);
3770 #elif defined(LINUX_BOUND_IF)
3771 ret = getsockopt(fd, IPPROTO_IP, IP_UNICAST_IF, &ifindex, &len);
3772 if (!ret) ifindex = ntohl(ifindex);
3773 #endif
3774 if (!ret && ifindex)
3775 {
3776 EnterCriticalSection(&cs_if_addr_cache);
3777 if (ifindex < if_addr_cache_size)
3778 addr->sin_addr.s_addr = if_addr_cache[ifindex];
3779 else
3780 ERR("No cache entry for ifindex %u.\n", ifindex);
3781 LeaveCriticalSection(&cs_if_addr_cache);
3782 }
3783 #endif
3784 }
3785
3786 /***********************************************************************
3787 * getsockname (WS2_32.6)
3788 */
3789 int WINAPI WS_getsockname(SOCKET s, struct WS_sockaddr *name, int *namelen)
3790 {
3791 int fd;
3792 int res;
3793
3794 TRACE("socket %04lx, ptr %p, len %08x\n", s, name, namelen ? *namelen : 0);
3795
3796 /* Check if what we've received is valid. Should we use IsBadReadPtr? */
3797 if( (name == NULL) || (namelen == NULL) )
3798 {
3799 SetLastError( WSAEFAULT );
3800 return SOCKET_ERROR;
3801 }
3802
3803 fd = get_sock_fd( s, 0, NULL );
3804 res = SOCKET_ERROR;
3805
3806 if (fd != -1)
3807 {
3808 union generic_unix_sockaddr uaddr;
3809 socklen_t uaddrlen;
3810 int bound = is_fd_bound(fd, &uaddr, &uaddrlen);
3811
3812 if (bound <= 0)
3813 {
3814 SetLastError(bound == -1 ? wsaErrno() : WSAEINVAL);
3815 }
3816 else if (ws_sockaddr_u2ws(&uaddr.addr, name, namelen) != 0)
3817 {
3818 /* The buffer was too small */
3819 SetLastError(WSAEFAULT);
3820 }
3821 else
3822 {
3823 interface_bind_check(fd, (struct sockaddr_in*) &uaddr);
3824 if (ws_sockaddr_u2ws(&uaddr.addr, name, namelen) != 0)
3825 {
3826 /* The buffer was too small */
3827 SetLastError(WSAEFAULT);
3828 }
3829 else
3830 {
3831 res = 0;
3832 TRACE("=> %s\n", debugstr_sockaddr(name));
3833 }
3834 }
3835 release_sock_fd( s, fd );
3836 }
3837 return res;
3838 }
3839
3840 /***********************************************************************
3841 * getsockopt (WS2_32.7)
3842 */
3843 INT WINAPI WS_getsockopt(SOCKET s, INT level,
3844 INT optname, char *optval, INT *optlen)
3845 {
3846 int fd;
3847 INT ret = 0;
3848
3849 TRACE("(socket %04lx, %s, optval %s, optlen %p (%d))\n", s,
3850 debugstr_sockopt(level, optname), debugstr_optval(optval, 0),
3851 optlen, optlen ? *optlen : 0);
3852
3853 switch(level)
3854 {
3855 case WS_SOL_SOCKET:
3856 {
3857 switch(optname)
3858 {
3859 /* Handle common cases. The special cases are below, sorted
3860 * alphabetically */
3861 case WS_SO_BROADCAST:
3862 case WS_SO_DEBUG:
3863 case WS_SO_KEEPALIVE:
3864 case WS_SO_OOBINLINE:
3865 case WS_SO_RCVBUF:
3866 case WS_SO_REUSEADDR:
3867 case WS_SO_SNDBUF:
3868 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
3869 return SOCKET_ERROR;
3870 convert_sockopt(&level, &optname);
3871 if (getsockopt(fd, level, optname, optval, (socklen_t *)optlen) != 0 )
3872 {
3873 SetLastError(wsaErrno());
3874 ret = SOCKET_ERROR;
3875 }
3876 release_sock_fd( s, fd );
3877 return ret;
3878 case WS_SO_ACCEPTCONN:
3879 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
3880 return SOCKET_ERROR;
3881 if (getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN, optval, (socklen_t *)optlen) != 0 )
3882 {
3883 SetLastError(wsaErrno());
3884 ret = SOCKET_ERROR;
3885 }
3886 else
3887 {
3888 /* BSD returns != 0 while Windows return exact == 1 */
3889 if (*(int *)optval) *(int *)optval = 1;
3890 }
3891 release_sock_fd( s, fd );
3892 return ret;
3893 case WS_SO_BSP_STATE:
3894 {
3895 int req_size, addr_size;
3896 WSAPROTOCOL_INFOW infow;
3897 CSADDR_INFO *csinfo;
3898
3899 ret = ws_protocol_info(s, TRUE, &infow, &addr_size);
3900 if (ret)
3901 {
3902 if (infow.iAddressFamily == WS_AF_INET)
3903 addr_size = sizeof(struct sockaddr_in);
3904 else if (infow.iAddressFamily == WS_AF_INET6)
3905 addr_size = sizeof(struct sockaddr_in6);
3906 else
3907 {
3908 FIXME("Family %d is unsupported for SO_BSP_STATE\n", infow.iAddressFamily);
3909 SetLastError(WSAEAFNOSUPPORT);
3910 return SOCKET_ERROR;
3911 }
3912
3913 req_size = sizeof(CSADDR_INFO) + addr_size * 2;
3914 if (*optlen < req_size)
3915 {
3916 ret = 0;
3917 SetLastError(WSAEFAULT);
3918 }
3919 else
3920 {
3921 union generic_unix_sockaddr uaddr;
3922 socklen_t uaddrlen;
3923
3924 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
3925 return SOCKET_ERROR;
3926
3927 csinfo = (CSADDR_INFO*) optval;
3928
3929 /* Check if the sock is bound */
3930 if (is_fd_bound(fd, &uaddr, &uaddrlen) == 1)
3931 {
3932 csinfo->LocalAddr.lpSockaddr =
3933 (LPSOCKADDR) (optval + sizeof(CSADDR_INFO));
3934 ws_sockaddr_u2ws(&uaddr.addr, csinfo->LocalAddr.lpSockaddr, &addr_size);
3935 csinfo->LocalAddr.iSockaddrLength = addr_size;
3936 }
3937 else
3938 {
3939 csinfo->LocalAddr.lpSockaddr = NULL;
3940 csinfo->LocalAddr.iSockaddrLength = 0;
3941 }
3942
3943 /* Check if the sock is connected */
3944 if (!getpeername(fd, &uaddr.addr, &uaddrlen) &&
3945 is_sockaddr_bound(&uaddr.addr, uaddrlen))
3946 {
3947 csinfo->RemoteAddr.lpSockaddr =
3948 (LPSOCKADDR) (optval + sizeof(CSADDR_INFO) + addr_size);
3949 ws_sockaddr_u2ws(&uaddr.addr, csinfo->RemoteAddr.lpSockaddr, &addr_size);
3950 csinfo->RemoteAddr.iSockaddrLength = addr_size;
3951 }
3952 else
3953 {
3954 csinfo->RemoteAddr.lpSockaddr = NULL;
3955 csinfo->RemoteAddr.iSockaddrLength = 0;
3956 }
3957
3958 csinfo->iSocketType = infow.iSocketType;
3959 csinfo->iProtocol = infow.iProtocol;
3960 release_sock_fd( s, fd );
3961 }
3962 }
3963 return ret ? 0 : SOCKET_ERROR;
3964 }
3965 case WS_SO_DONTLINGER:
3966 {
3967 struct linger lingval;
3968 socklen_t len = sizeof(struct linger);
3969
3970 if (!optlen || *optlen < sizeof(BOOL)|| !optval)
3971 {
3972 SetLastError(WSAEFAULT);
3973 return SOCKET_ERROR;
3974 }
3975 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
3976 return SOCKET_ERROR;
3977
3978 if (getsockopt(fd, SOL_SOCKET, SO_LINGER, &lingval, &len) != 0 )
3979 {
3980 SetLastError(wsaErrno());
3981 ret = SOCKET_ERROR;
3982 }
3983 else
3984 {
3985 *(BOOL *)optval = !lingval.l_onoff;
3986 *optlen = sizeof(BOOL);
3987 }
3988
3989 release_sock_fd( s, fd );
3990 return ret;
3991 }
3992
3993 case WS_SO_CONNECT_TIME:
3994 {
3995 static int pretendtime = 0;
3996 struct WS_sockaddr addr;
3997 int len = sizeof(addr);
3998
3999 if (!optlen || *optlen < sizeof(DWORD) || !optval)
4000 {
4001 SetLastError(WSAEFAULT);
4002 return SOCKET_ERROR;
4003 }
4004 if (WS_getpeername(s, &addr, &len) == SOCKET_ERROR)
4005 *(DWORD *)optval = ~0u;
4006 else
4007 {
4008 if (!pretendtime) FIXME("WS_SO_CONNECT_TIME - faking results\n");
4009 *(DWORD *)optval = pretendtime++;
4010 }
4011 *optlen = sizeof(DWORD);
4012 return ret;
4013 }
4014 /* As mentioned in setsockopt, Windows ignores this, so we
4015 * always return true here */
4016 case WS_SO_DONTROUTE:
4017 if (!optlen || *optlen < sizeof(BOOL) || !optval)
4018 {
4019 SetLastError(WSAEFAULT);
4020 return SOCKET_ERROR;
4021 }
4022 *(BOOL *)optval = TRUE;
4023 *optlen = sizeof(BOOL);
4024 return 0;
4025
4026 case WS_SO_ERROR:
4027 {
4028 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
4029 return SOCKET_ERROR;
4030 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, optval, (socklen_t *)optlen) != 0 )
4031 {
4032 SetLastError(wsaErrno());
4033 ret = SOCKET_ERROR;
4034 }
4035 release_sock_fd( s, fd );
4036
4037 /* The wineserver may have swallowed the error before us */
4038 if (!ret && *(int*) optval == 0)
4039 {
4040 int i, events[FD_MAX_EVENTS];
4041 _get_sock_errors(s, events);
4042 for (i = 0; i < FD_MAX_EVENTS; i++)
4043 {
4044 if(events[i])
4045 {
4046 TRACE("returning SO_ERROR %d from wine server\n", events[i]);
4047 *(int*) optval = events[i];
4048 break;
4049 }
4050 }
4051 }
4052 return ret;
4053 }
4054
4055 case WS_SO_LINGER:
4056 {
4057 struct linger lingval;
4058 socklen_t len = sizeof(struct linger);
4059
4060 /* struct linger and LINGER have different sizes */
4061 if (!optlen || *optlen < sizeof(LINGER) || !optval)
4062 {
4063 SetLastError(WSAEFAULT);
4064 return SOCKET_ERROR;
4065 }
4066 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
4067 return SOCKET_ERROR;
4068
4069 if (_get_fd_type(fd) == SOCK_DGRAM)
4070 {
4071 SetLastError(WSAENOPROTOOPT);
4072 ret = SOCKET_ERROR;
4073 }
4074 else if (getsockopt(fd, SOL_SOCKET, SO_LINGER, &lingval, &len) != 0)
4075 {
4076 SetLastError(wsaErrno());
4077 ret = SOCKET_ERROR;
4078 }
4079 else
4080 {
4081 ((LINGER *)optval)->l_onoff = lingval.l_onoff;
4082 ((LINGER *)optval)->l_linger = lingval.l_linger;
4083 *optlen = sizeof(struct linger);
4084 }
4085
4086 release_sock_fd( s, fd );
4087 return ret;
4088 }
4089
4090 case WS_SO_MAX_MSG_SIZE:
4091 if (!optlen || *optlen < sizeof(int) || !optval)
4092 {
4093 SetLastError(WSAEFAULT);
4094 return SOCKET_ERROR;
4095 }
4096 TRACE("getting global SO_MAX_MSG_SIZE = 65507\n");
4097 *(int *)optval = 65507;
4098 *optlen = sizeof(int);
4099 return 0;
4100
4101 /* SO_OPENTYPE does not require a valid socket handle. */
4102 case WS_SO_OPENTYPE:
4103 if (!optlen || *optlen < sizeof(int) || !optval)
4104 {
4105 SetLastError(WSAEFAULT);
4106 return SOCKET_ERROR;
4107 }
4108 *(int *)optval = get_per_thread_data()->opentype;
4109 *optlen = sizeof(int);
4110 TRACE("getting global SO_OPENTYPE = 0x%x\n", *((int*)optval) );
4111 return 0;
4112 case WS_SO_PROTOCOL_INFOA:
4113 case WS_SO_PROTOCOL_INFOW:
4114 {
4115 int size;
4116 WSAPROTOCOL_INFOW infow;
4117
4118 ret = ws_protocol_info(s, optname == WS_SO_PROTOCOL_INFOW, &infow, &size);
4119 if (ret)
4120 {
4121 if (!optlen || !optval || *optlen < size)
4122 {
4123 if(optlen) *optlen = size;
4124 ret = 0;
4125 SetLastError(WSAEFAULT);
4126 }
4127 else
4128 memcpy(optval, &infow, size);
4129 }
4130 return ret ? 0 : SOCKET_ERROR;
4131 }
4132 case WS_SO_RCVTIMEO:
4133 case WS_SO_SNDTIMEO:
4134 {
4135 INT64 timeout;
4136
4137 if (!optlen || *optlen < sizeof(int)|| !optval)
4138 {
4139 SetLastError(WSAEFAULT);
4140 return SOCKET_ERROR;
4141 }
4142 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
4143 return SOCKET_ERROR;
4144
4145 timeout = get_rcvsnd_timeo(fd, optname == WS_SO_RCVTIMEO);
4146 *(int *)optval = timeout <= UINT_MAX ? timeout : UINT_MAX;
4147
4148 release_sock_fd( s, fd );
4149 return ret;
4150 }
4151 case WS_SO_TYPE:
4152 {
4153 int sock_type;
4154 if (!optlen || *optlen < sizeof(int) || !optval)
4155 {
4156 SetLastError(WSAEFAULT);
4157 return SOCKET_ERROR;
4158 }
4159 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
4160 return SOCKET_ERROR;
4161
4162 sock_type = _get_fd_type(fd);
4163 if (sock_type == -1)
4164 {
4165 SetLastError(wsaErrno());
4166 ret = SOCKET_ERROR;
4167 }
4168 else
4169 (*(int *)optval) = convert_socktype_u2w(sock_type);
4170
4171 release_sock_fd( s, fd );
4172 return ret;
4173 }
4174 default:
4175 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
4176 SetLastError(WSAENOPROTOOPT);
4177 return SOCKET_ERROR;
4178 } /* end switch(optname) */
4179 }/* end case WS_SOL_SOCKET */
4180 #ifdef HAS_IPX
4181 case WS_NSPROTO_IPX:
4182 {
4183 struct WS_sockaddr_ipx addr;
4184 IPX_ADDRESS_DATA *data;
4185 int namelen;
4186 switch(optname)
4187 {
4188 case WS_IPX_PTYPE:
4189 if ((fd = get_sock_fd( s, 0, NULL )) == -1) return SOCKET_ERROR;
4190 #ifdef SOL_IPX
4191 if(getsockopt(fd, SOL_IPX, IPX_TYPE, optval, (socklen_t *)optlen) == -1)
4192 {
4193 ret = SOCKET_ERROR;
4194 }
4195 #else
4196 {
4197 struct ipx val;
4198 socklen_t len=sizeof(struct ipx);
4199 if(getsockopt(fd, 0, SO_DEFAULT_HEADERS, &val, &len) == -1 )
4200 ret = SOCKET_ERROR;
4201 else
4202 *optval = (int)val.ipx_pt;
4203 }
4204 #endif
4205 TRACE("ptype: %d (fd: %d)\n", *(int*)optval, fd);
4206 release_sock_fd( s, fd );
4207 return ret;
4208
4209 case WS_IPX_ADDRESS:
4210 /*
4211 * On a Win2000 system with one network card there are usually
4212 * three ipx devices one with a speed of 28.8kbps, 10Mbps and 100Mbps.
4213 * Using this call you can then retrieve info about this all.
4214 * In case of Linux it is a bit different. Usually you have
4215 * only "one" device active and further it is not possible to
4216 * query things like the linkspeed.
4217 */
4218 FIXME("IPX_ADDRESS\n");
4219 namelen = sizeof(struct WS_sockaddr_ipx);
4220 memset(&addr, 0, sizeof(struct WS_sockaddr_ipx));
4221 WS_getsockname(s, (struct WS_sockaddr*)&addr, &namelen);
4222
4223 data = (IPX_ADDRESS_DATA*)optval;
4224 memcpy(data->nodenum,addr.sa_nodenum,sizeof(data->nodenum));
4225 memcpy(data->netnum,addr.sa_netnum,sizeof(data->netnum));
4226 data->adapternum = 0;
4227 data->wan = FALSE; /* We are not on a wan for now .. */
4228 data->status = FALSE; /* Since we are not on a wan, the wan link isn't up */
4229 data->maxpkt = 1467; /* This value is the default one, at least on Win2k/WinXP */
4230 data->linkspeed = 100000; /* Set the line speed in 100bit/s to 10 Mbit;
4231 * note 1MB = 1000kB in this case */
4232 return 0;
4233
4234 case WS_IPX_MAX_ADAPTER_NUM:
4235 FIXME("IPX_MAX_ADAPTER_NUM\n");
4236 *(int*)optval = 1; /* As noted under IPX_ADDRESS we have just one card. */
4237 return 0;
4238
4239 default:
4240 FIXME("IPX optname:%x\n", optname);
4241 return SOCKET_ERROR;
4242 }/* end switch(optname) */
4243 } /* end case WS_NSPROTO_IPX */
4244 #endif
4245
4246 #ifdef HAS_IRDA
4247 #define MAX_IRDA_DEVICES 10
4248
4249 case WS_SOL_IRLMP:
4250 switch(optname)
4251 {
4252 case WS_IRLMP_ENUMDEVICES:
4253 {
4254 char buf[sizeof(struct irda_device_list) +
4255 (MAX_IRDA_DEVICES - 1) * sizeof(struct irda_device_info)];
4256 int res;
4257 socklen_t len = sizeof(buf);
4258
4259 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
4260 return SOCKET_ERROR;
4261 res = getsockopt( fd, SOL_IRLMP, IRLMP_ENUMDEVICES, buf, &len );
4262 release_sock_fd( s, fd );
4263 if (res < 0)
4264 {
4265 SetLastError(wsaErrno());
4266 return SOCKET_ERROR;
4267 }
4268 else
4269 {
4270 struct irda_device_list *src = (struct irda_device_list *)buf;
4271 DEVICELIST *dst = (DEVICELIST *)optval;
4272 INT needed = sizeof(DEVICELIST);
4273 unsigned int i;
4274
4275 if (src->len > 0)
4276 needed += (src->len - 1) * sizeof(IRDA_DEVICE_INFO);
4277 if (*optlen < needed)
4278 {
4279 SetLastError(WSAEFAULT);
4280 return SOCKET_ERROR;
4281 }
4282 *optlen = needed;
4283 TRACE("IRLMP_ENUMDEVICES: %d devices found:\n", src->len);
4284 dst->numDevice = src->len;
4285 for (i = 0; i < src->len; i++)
4286 {
4287 TRACE("saddr = %08x, daddr = %08x, info = %s, hints = %02x%02x\n",
4288 src->dev[i].saddr, src->dev[i].daddr,
4289 src->dev[i].info, src->dev[i].hints[0],
4290 src->dev[i].hints[1]);
4291 memcpy( dst->Device[i].irdaDeviceID,
4292 &src->dev[i].daddr,
4293 sizeof(dst->Device[i].irdaDeviceID) ) ;
4294 memcpy( dst->Device[i].irdaDeviceName,
4295 src->dev[i].info,
4296 sizeof(dst->Device[i].irdaDeviceName) ) ;
4297 memcpy( &dst->Device[i].irdaDeviceHints1,
4298 &src->dev[i].hints[0],
4299 sizeof(dst->Device[i].irdaDeviceHints1) ) ;
4300 memcpy( &dst->Device[i].irdaDeviceHints2,
4301 &src->dev[i].hints[1],
4302 sizeof(dst->Device[i].irdaDeviceHints2) ) ;
4303 dst->Device[i].irdaCharSet = src->dev[i].charset;
4304 }
4305 return 0;
4306 }
4307 }
4308 default:
4309 FIXME("IrDA optname:0x%x\n", optname);
4310 return SOCKET_ERROR;
4311 }
4312 break; /* case WS_SOL_IRLMP */
4313 #undef MAX_IRDA_DEVICES
4314 #endif
4315
4316 /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */
4317 case WS_IPPROTO_TCP:
4318 switch(optname)
4319 {
4320 case WS_TCP_NODELAY:
4321 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
4322 return SOCKET_ERROR;
4323 convert_sockopt(&level, &optname);
4324 if (getsockopt(fd, level, optname, optval, (socklen_t *)optlen) != 0 )
4325 {
4326 SetLastError(wsaErrno());
4327 ret = SOCKET_ERROR;
4328 }
4329 release_sock_fd( s, fd );
4330 return ret;
4331 }
4332 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
4333 return SOCKET_ERROR;
4334
4335 case WS_IPPROTO_IP:
4336 switch(optname)
4337 {
4338 case WS_IP_ADD_MEMBERSHIP:
4339 case WS_IP_DROP_MEMBERSHIP:
4340 #ifdef IP_HDRINCL
4341 case WS_IP_HDRINCL:
4342 #endif
4343 case WS_IP_MULTICAST_IF:
4344 case WS_IP_MULTICAST_LOOP:
4345 case WS_IP_MULTICAST_TTL:
4346 case WS_IP_OPTIONS:
4347 #if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
4348 case WS_IP_PKTINFO:
4349 #endif
4350 case WS_IP_TOS:
4351 case WS_IP_TTL:
4352 #ifdef IP_UNICAST_IF
4353 case WS_IP_UNICAST_IF:
4354 #endif
4355 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
4356 return SOCKET_ERROR;
4357 convert_sockopt(&level, &optname);
4358 if (getsockopt(fd, level, optname, optval, (socklen_t *)optlen) != 0 )
4359 {
4360 SetLastError(wsaErrno());
4361 ret = SOCKET_ERROR;
4362 }
4363 release_sock_fd( s, fd );
4364 return ret;
4365 case WS_IP_DONTFRAGMENT:
4366 return get_dont_fragment(s, IPPROTO_IP, (BOOL *)optval) ? 0 : SOCKET_ERROR;
4367 }
4368 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
4369 return SOCKET_ERROR;
4370
4371 case WS_IPPROTO_IPV6:
4372 switch(optname)
4373 {
4374 #ifdef IPV6_ADD_MEMBERSHIP
4375 case WS_IPV6_ADD_MEMBERSHIP:
4376 #endif
4377 #ifdef IPV6_DROP_MEMBERSHIP
4378 case WS_IPV6_DROP_MEMBERSHIP:
4379 #endif
4380 case WS_IPV6_MULTICAST_IF:
4381 case WS_IPV6_MULTICAST_HOPS:
4382 case WS_IPV6_MULTICAST_LOOP:
4383 case WS_IPV6_UNICAST_HOPS:
4384 case WS_IPV6_V6ONLY:
4385 #ifdef IPV6_UNICAST_IF
4386 case WS_IPV6_UNICAST_IF:
4387 #endif
4388 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
4389 return SOCKET_ERROR;
4390 convert_sockopt(&level, &optname);
4391 if (getsockopt(fd, level, optname, optval, (socklen_t *)optlen) != 0 )
4392 {
4393 SetLastError(wsaErrno());
4394 ret = SOCKET_ERROR;
4395 }
4396 release_sock_fd( s, fd );
4397 return ret;
4398 case WS_IPV6_DONTFRAG:
4399 return get_dont_fragment(s, IPPROTO_IPV6, (BOOL *)optval) ? 0 : SOCKET_ERROR;
4400 }
4401 FIXME("Unknown IPPROTO_IPV6 optname 0x%08x\n", optname);
4402 return SOCKET_ERROR;
4403
4404 default:
4405 WARN("Unknown level: 0x%08x\n", level);
4406 SetLastError(WSAEINVAL);
4407 return SOCKET_ERROR;
4408 } /* end switch(level) */
4409 }
4410
4411 /***********************************************************************
4412 * htonl (WS2_32.8)
4413 */
4414 WS_u_long WINAPI WS_htonl(WS_u_long hostlong)
4415 {
4416 return htonl(hostlong);
4417 }
4418
4419
4420 /***********************************************************************
4421 * htons (WS2_32.9)
4422 */
4423 WS_u_short WINAPI WS_htons(WS_u_short hostshort)
4424 {
4425 return htons(hostshort);
4426 }
4427
4428 /***********************************************************************
4429 * WSAHtonl (WS2_32.46)
4430 * From MSDN description of error codes, this function should also
4431 * check if WinSock has been initialized and the socket is a valid
4432 * socket. But why? This function only translates a host byte order
4433 * u_long into a network byte order u_long...
4434 */
4435 int WINAPI WSAHtonl(SOCKET s, WS_u_long hostlong, WS_u_long *lpnetlong)
4436 {
4437 if (lpnetlong)
4438 {
4439 *lpnetlong = htonl(hostlong);
4440 return 0;
4441 }
4442 SetLastError(WSAEFAULT);
4443 return SOCKET_ERROR;
4444 }
4445
4446 /***********************************************************************
4447 * WSAHtons (WS2_32.47)
4448 * From MSDN description of error codes, this function should also
4449 * check if WinSock has been initialized and the socket is a valid
4450 * socket. But why? This function only translates a host byte order
4451 * u_short into a network byte order u_short...
4452 */
4453 int WINAPI WSAHtons(SOCKET s, WS_u_short hostshort, WS_u_short *lpnetshort)
4454 {
4455
4456 if (lpnetshort)
4457 {
4458 *lpnetshort = htons(hostshort);
4459 return 0;
4460 }
4461 SetLastError(WSAEFAULT);
4462 return SOCKET_ERROR;
4463 }
4464
4465
4466 /***********************************************************************
4467 * inet_addr (WS2_32.11)
4468 */
4469 WS_u_long WINAPI WS_inet_addr(const char *cp)
4470 {
4471 if (!cp) return INADDR_NONE;
4472 return inet_addr(cp);
4473 }
4474
4475
4476 /***********************************************************************
4477 * ntohl (WS2_32.14)
4478 */
4479 WS_u_long WINAPI WS_ntohl(WS_u_long netlong)
4480 {
4481 return ntohl(netlong);
4482 }
4483
4484
4485 /***********************************************************************
4486 * ntohs (WS2_32.15)
4487 */
4488 WS_u_short WINAPI WS_ntohs(WS_u_short netshort)
4489 {
4490 return ntohs(netshort);
4491 }
4492
4493
4494 /***********************************************************************
4495 * inet_ntoa (WS2_32.12)
4496 */
4497 char* WINAPI WS_inet_ntoa(struct WS_in_addr in)
4498 {
4499 unsigned int long_ip = ntohl(in.WS_s_addr);
4500 struct per_thread_data *data = get_per_thread_data();
4501
4502 sprintf( data->ntoa_buffer, "%u.%u.%u.%u",
4503 (long_ip >> 24) & 0xff,
4504 (long_ip >> 16) & 0xff,
4505 (long_ip >> 8) & 0xff,
4506 long_ip & 0xff);
4507
4508 return data->ntoa_buffer;
4509 }
4510
4511 static const char *debugstr_wsaioctl(DWORD code)
4512 {
4513 const char *name = NULL, *buf_type, *family;
4514
4515 #define IOCTL_NAME(x) case x: name = #x; break
4516 switch (code)
4517 {
4518 IOCTL_NAME(WS_FIONBIO);
4519 IOCTL_NAME(WS_FIONREAD);
4520 IOCTL_NAME(WS_SIOCATMARK);
4521 /* IOCTL_NAME(WS_SIO_ACQUIRE_PORT_RESERVATION); */
4522 IOCTL_NAME(WS_SIO_ADDRESS_LIST_CHANGE);
4523 IOCTL_NAME(WS_SIO_ADDRESS_LIST_QUERY);
4524 IOCTL_NAME(WS_SIO_ASSOCIATE_HANDLE);
4525 /* IOCTL_NAME(WS_SIO_ASSOCIATE_PORT_RESERVATION);
4526 IOCTL_NAME(WS_SIO_BASE_HANDLE);
4527 IOCTL_NAME(WS_SIO_BSP_HANDLE);
4528 IOCTL_NAME(WS_SIO_BSP_HANDLE_SELECT);
4529 IOCTL_NAME(WS_SIO_BSP_HANDLE_POLL);
4530 IOCTL_NAME(WS_SIO_CHK_QOS); */
4531 IOCTL_NAME(WS_SIO_ENABLE_CIRCULAR_QUEUEING);
4532 IOCTL_NAME(WS_SIO_FIND_ROUTE);
4533 IOCTL_NAME(WS_SIO_FLUSH);
4534 IOCTL_NAME(WS_SIO_GET_BROADCAST_ADDRESS);
4535 IOCTL_NAME(WS_SIO_GET_EXTENSION_FUNCTION_POINTER);
4536 IOCTL_NAME(WS_SIO_GET_GROUP_QOS);
4537 IOCTL_NAME(WS_SIO_GET_INTERFACE_LIST);
4538 /* IOCTL_NAME(WS_SIO_GET_INTERFACE_LIST_EX); */
4539 IOCTL_NAME(WS_SIO_GET_QOS);
4540 IOCTL_NAME(WS_SIO_IDEAL_SEND_BACKLOG_CHANGE);
4541 IOCTL_NAME(WS_SIO_IDEAL_SEND_BACKLOG_QUERY);
4542 IOCTL_NAME(WS_SIO_KEEPALIVE_VALS);
4543 IOCTL_NAME(WS_SIO_MULTIPOINT_LOOPBACK);
4544 IOCTL_NAME(WS_SIO_MULTICAST_SCOPE);
4545 /* IOCTL_NAME(WS_SIO_QUERY_RSS_SCALABILITY_INFO);
4546 IOCTL_NAME(WS_SIO_QUERY_WFP_ALE_ENDPOINT_HANDLE); */
4547 IOCTL_NAME(WS_SIO_RCVALL);
4548 IOCTL_NAME(WS_SIO_RCVALL_IGMPMCAST);
4549 IOCTL_NAME(WS_SIO_RCVALL_MCAST);
4550 /* IOCTL_NAME(WS_SIO_RELEASE_PORT_RESERVATION); */
4551 IOCTL_NAME(WS_SIO_ROUTING_INTERFACE_CHANGE);
4552 IOCTL_NAME(WS_SIO_ROUTING_INTERFACE_QUERY);
4553 IOCTL_NAME(WS_SIO_SET_COMPATIBILITY_MODE);
4554 IOCTL_NAME(WS_SIO_SET_GROUP_QOS);
4555 IOCTL_NAME(WS_SIO_SET_QOS);
4556 IOCTL_NAME(WS_SIO_TRANSLATE_HANDLE);
4557 IOCTL_NAME(WS_SIO_UDP_CONNRESET);
4558 }
4559 #undef IOCTL_NAME
4560
4561 if (name)
4562 return name + 3;
4563
4564 /* If this is not a known code split its bits */
4565 switch(code & 0x18000000)
4566 {
4567 case WS_IOC_WS2:
4568 family = "IOC_WS2";
4569 break;
4570 case WS_IOC_PROTOCOL:
4571 family = "IOC_PROTOCOL";
4572 break;
4573 case WS_IOC_VENDOR:
4574 family = "IOC_VENDOR";
4575 break;
4576 default: /* WS_IOC_UNIX */
4577 {
4578 BYTE size = (code >> 16) & WS_IOCPARM_MASK;
4579 char x = (code & 0xff00) >> 8;
4580 BYTE y = code & 0xff;
4581 char args[14];
4582
4583 switch (code & (WS_IOC_VOID|WS_IOC_INOUT))
4584 {
4585 case WS_IOC_VOID:
4586 buf_type = "_IO";
4587 sprintf(args, "%d, %d", x, y);
4588 break;
4589 case WS_IOC_IN:
4590 buf_type = "_IOW";
4591 sprintf(args, "'%c', %d, %d", x, y, size);
4592 break;
4593 case WS_IOC_OUT:
4594 buf_type = "_IOR";
4595 sprintf(args, "'%c', %d, %d", x, y, size);
4596 break;
4597 default:
4598 buf_type = "?";
4599 sprintf(args, "'%c', %d, %d", x, y, size);
4600 break;
4601 }
4602 return wine_dbg_sprintf("%s(%s)", buf_type, args);
4603 }
4604 }
4605
4606 /* We are different from WS_IOC_UNIX. */
4607 switch (code & (WS_IOC_VOID|WS_IOC_INOUT))
4608 {
4609 case WS_IOC_VOID:
4610 buf_type = "_WSAIO";
4611 break;
4612 case WS_IOC_INOUT:
4613 buf_type = "_WSAIORW";
4614 break;
4615 case WS_IOC_IN:
4616 buf_type = "_WSAIOW";
4617 break;
4618 case WS_IOC_OUT:
4619 buf_type = "_WSAIOR";
4620 break;
4621 default:
4622 buf_type = "?";
4623 break;
4624 }
4625
4626 return wine_dbg_sprintf("%s(%s, %d)", buf_type, family,
4627 (USHORT)(code & 0xffff));
4628 }
4629
4630 /* do an ioctl call through the server */
4631 static DWORD server_ioctl_sock( SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size,
4632 LPVOID out_buff, DWORD out_size, LPDWORD ret_size,
4633 LPWSAOVERLAPPED overlapped,
4634 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
4635 {
4636 HANDLE event = overlapped ? overlapped->hEvent : 0;
4637 HANDLE handle = SOCKET2HANDLE( s );
4638 struct ws2_async *wsa = NULL;
4639 IO_STATUS_BLOCK *io = (PIO_STATUS_BLOCK)overlapped, iosb;
4640 void *cvalue = NULL;
4641 NTSTATUS status;
4642
4643 if (completion)
4644 {
4645 if (!(wsa = (struct ws2_async *)alloc_async_io( sizeof(*wsa), NULL )))
4646 return WSA_NOT_ENOUGH_MEMORY;
4647 wsa->hSocket = handle;
4648 wsa->user_overlapped = overlapped;
4649 wsa->completion_func = completion;
4650 if (!io) io = &wsa->local_iosb;
4651 cvalue = wsa;
4652 }
4653 else if (!io)
4654 io = &iosb;
4655 else if (!((ULONG_PTR)overlapped->hEvent & 1))
4656 cvalue = overlapped;
4657
4658 status = NtDeviceIoControlFile( handle, event, wsa ? ws2_async_apc : NULL, cvalue, io, code,
4659 in_buff, in_size, out_buff, out_size );
4660 if (status == STATUS_NOT_SUPPORTED)
4661 {
4662 FIXME("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
4663 code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
4664 }
4665 else if (status == STATUS_SUCCESS)
4666 *ret_size = io->Information; /* "Information" is the size written to the output buffer */
4667
4668 if (status != STATUS_PENDING) RtlFreeHeap( GetProcessHeap(), 0, wsa );
4669
4670 return NtStatusToWSAError( status );
4671 }
4672
4673 /**********************************************************************
4674 * WSAIoctl (WS2_32.50)
4675 *
4676 */
4677 INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID out_buff,
4678 DWORD out_size, LPDWORD ret_size, LPWSAOVERLAPPED overlapped,
4679 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
4680 {
4681 int fd;
4682 DWORD status = 0, total = 0;
4683
4684 TRACE("%04lx, %s, %p, %d, %p, %d, %p, %p, %p\n",
4685 s, debugstr_wsaioctl(code), in_buff, in_size, out_buff, out_size, ret_size, overlapped, completion);
4686
4687 switch (code)
4688 {
4689 case WS_FIONBIO:
4690 if (in_size != sizeof(WS_u_long) || IS_INTRESOURCE(in_buff))
4691 {
4692 SetLastError(WSAEFAULT);
4693 return SOCKET_ERROR;
4694 }
4695 TRACE("-> FIONBIO (%x)\n", *(WS_u_long*)in_buff);
4696 if (_get_sock_mask(s))
4697 {
4698 /* AsyncSelect()'ed sockets are always nonblocking */
4699 if (!*(WS_u_long *)in_buff) status = WSAEINVAL;
4700 break;
4701 }
4702 if (*(WS_u_long *)in_buff)
4703 _enable_event(SOCKET2HANDLE(s), 0, FD_WINE_NONBLOCKING, 0);
4704 else
4705 _enable_event(SOCKET2HANDLE(s), 0, 0, FD_WINE_NONBLOCKING);
4706 break;
4707
4708 case WS_FIONREAD:
4709 {
4710 #if defined(linux)
4711 int listening = 0;
4712 socklen_t len = sizeof(listening);
4713 #endif
4714 if (out_size != sizeof(WS_u_long) || IS_INTRESOURCE(out_buff))
4715 {
4716 SetLastError(WSAEFAULT);
4717 return SOCKET_ERROR;
4718 }
4719 if ((fd = get_sock_fd( s, 0, NULL )) == -1) return SOCKET_ERROR;
4720
4721 #if defined(linux)
4722 /* On Linux, FIONREAD on listening socket always fails (see tcp(7)).
4723 However, it succeeds on native. */
4724 if (!getsockopt( fd, SOL_SOCKET, SO_ACCEPTCONN, &listening, &len ) && listening)
4725 (*(WS_u_long *) out_buff) = 0;
4726 else
4727 #endif
4728 if (ioctl(fd, FIONREAD, out_buff ) == -1)
4729 status = wsaErrno();
4730 release_sock_fd( s, fd );
4731 break;
4732 }
4733
4734 case WS_SIOCATMARK:
4735 {
4736 unsigned int oob = 0, atmark = 0;
4737 socklen_t oobsize = sizeof(int);
4738 if (out_size != sizeof(WS_u_long) || IS_INTRESOURCE(out_buff))
4739 {
4740 SetLastError(WSAEFAULT);
4741 return SOCKET_ERROR;
4742 }
4743 if ((fd = get_sock_fd( s, 0, NULL )) == -1) return SOCKET_ERROR;
4744 /* SO_OOBINLINE sockets must always return TRUE to SIOCATMARK */
4745 if ((getsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &oob, &oobsize ) == -1)
4746 || (!oob && ioctl(fd, SIOCATMARK, &atmark ) == -1))
4747 status = wsaErrno();
4748 else
4749 {
4750 /* The SIOCATMARK value read from ioctl() is reversed
4751 * because BSD returns TRUE if it's in the OOB mark
4752 * while Windows returns TRUE if there are NO OOB bytes.
4753 */
4754 (*(WS_u_long *) out_buff) = oob || !atmark;
4755 }
4756
4757 release_sock_fd( s, fd );
4758 break;
4759 }
4760
4761 case WS_FIOASYNC:
4762 WARN("Warning: WS1.1 shouldn't be using async I/O\n");
4763 SetLastError(WSAEINVAL);
4764 return SOCKET_ERROR;
4765
4766 case WS_SIO_GET_INTERFACE_LIST:
4767 {
4768 INTERFACE_INFO* intArray = out_buff;
4769 DWORD size, numInt = 0, apiReturn;
4770
4771 TRACE("-> SIO_GET_INTERFACE_LIST request\n");
4772
4773 if (!out_buff || !ret_size)
4774 {
4775 SetLastError(WSAEFAULT);
4776 return SOCKET_ERROR;
4777 }
4778
4779 fd = get_sock_fd( s, 0, NULL );
4780 if (fd == -1) return SOCKET_ERROR;
4781
4782 apiReturn = GetAdaptersInfo(NULL, &size);
4783 if (apiReturn == ERROR_BUFFER_OVERFLOW)
4784 {
4785 PIP_ADAPTER_INFO table = HeapAlloc(GetProcessHeap(),0,size);
4786
4787 if (table)
4788 {
4789 if (GetAdaptersInfo(table, &size) == NO_ERROR)
4790 {
4791 PIP_ADAPTER_INFO ptr;
4792
4793 for (ptr = table, numInt = 0; ptr; ptr = ptr->Next)
4794 {
4795 unsigned int addr, mask, bcast;
4796 struct ifreq ifInfo;
4797
4798 /* Skip interfaces without an IPv4 address. */
4799 if (ptr->IpAddressList.IpAddress.String[0] == '\0')
4800 continue;
4801
4802 if ((numInt + 1)*sizeof(INTERFACE_INFO)/sizeof(IP_ADAPTER_INFO) > out_size)
4803 {
4804 WARN("Buffer too small = %u, out_size = %u\n", numInt + 1, out_size);
4805 status = WSAEFAULT;
4806 break;
4807 }
4808
4809 /* Socket Status Flags */
4810 lstrcpynA(ifInfo.ifr_name, ptr->AdapterName, IFNAMSIZ);
4811 if (ioctl(fd, SIOCGIFFLAGS, &ifInfo) < 0)
4812 {
4813 ERR("Error obtaining status flags for socket!\n");
4814 status = WSAEINVAL;
4815 break;
4816 }
4817 else
4818 {
4819 /* set flags; the values of IFF_* are not the same
4820 under Linux and Windows, therefore must generate
4821 new flags */
4822 intArray->iiFlags = 0;
4823 if (ifInfo.ifr_flags & IFF_BROADCAST)
4824 intArray->iiFlags |= WS_IFF_BROADCAST;
4825 #ifdef IFF_POINTOPOINT
4826 if (ifInfo.ifr_flags & IFF_POINTOPOINT)
4827 intArray->iiFlags |= WS_IFF_POINTTOPOINT;
4828 #endif
4829 if (ifInfo.ifr_flags & IFF_LOOPBACK)
4830 intArray->iiFlags |= WS_IFF_LOOPBACK;
4831 if (ifInfo.ifr_flags & IFF_UP)
4832 intArray->iiFlags |= WS_IFF_UP;
4833 if (ifInfo.ifr_flags & IFF_MULTICAST)
4834 intArray->iiFlags |= WS_IFF_MULTICAST;
4835 }
4836
4837 addr = inet_addr(ptr->IpAddressList.IpAddress.String);
4838 mask = inet_addr(ptr->IpAddressList.IpMask.String);
4839 bcast = addr | ~mask;
4840 intArray->iiAddress.AddressIn.sin_family = WS_AF_INET;
4841 intArray->iiAddress.AddressIn.sin_port = 0;
4842 intArray->iiAddress.AddressIn.sin_addr.WS_s_addr = addr;
4843
4844 intArray->iiNetmask.AddressIn.sin_family = WS_AF_INET;
4845 intArray->iiNetmask.AddressIn.sin_port = 0;
4846 intArray->iiNetmask.AddressIn.sin_addr.WS_s_addr = mask;
4847
4848 intArray->iiBroadcastAddress.AddressIn.sin_family = WS_AF_INET;
4849 intArray->iiBroadcastAddress.AddressIn.sin_port = 0;
4850 intArray->iiBroadcastAddress.AddressIn.sin_addr.WS_s_addr = bcast;
4851 intArray++;
4852 numInt++;
4853 }
4854 }
4855 else
4856 {
4857 ERR("Unable to get interface table!\n");
4858 status = WSAEINVAL;
4859 }
4860 HeapFree(GetProcessHeap(),0,table);
4861 }
4862 else status = WSAEINVAL;
4863 }
4864 else if (apiReturn != ERROR_NO_DATA)
4865 {
4866 ERR("Unable to get interface table!\n");
4867 status = WSAEINVAL;
4868 }
4869 /* Calculate the size of the array being returned */
4870 total = sizeof(INTERFACE_INFO) * numInt;
4871 release_sock_fd( s, fd );
4872 break;
4873 }
4874
4875 case WS_SIO_ADDRESS_LIST_QUERY:
4876 {
4877 DWORD size;
4878
4879 TRACE("-> SIO_ADDRESS_LIST_QUERY request\n");
4880
4881 if (!ret_size)
4882 {
4883 SetLastError(WSAEFAULT);
4884 return SOCKET_ERROR;
4885 }
4886
4887 if (out_size && out_size < FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]))
4888 {
4889 *ret_size = 0;
4890 SetLastError(WSAEINVAL);
4891 return SOCKET_ERROR;
4892 }
4893
4894 if (GetAdaptersInfo(NULL, &size) == ERROR_BUFFER_OVERFLOW)
4895 {
4896 IP_ADAPTER_INFO *p, *table = HeapAlloc(GetProcessHeap(), 0, size);
4897 SOCKET_ADDRESS_LIST *sa_list;
4898 SOCKADDR_IN *sockaddr;
4899 SOCKET_ADDRESS *sa;
4900 unsigned int i;
4901 DWORD num;
4902
4903 if (!table || GetAdaptersInfo(table, &size))
4904 {
4905 HeapFree(GetProcessHeap(), 0, table);
4906 status = WSAEINVAL;
4907 break;
4908 }
4909
4910 for (p = table, num = 0; p; p = p->Next)
4911 if (p->IpAddressList.IpAddress.String[0]) num++;
4912
4913 total = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[num]) + num * sizeof(*sockaddr);
4914 if (total > out_size || !out_buff)
4915 {
4916 *ret_size = total;
4917 HeapFree(GetProcessHeap(), 0, table);
4918 status = WSAEFAULT;
4919 break;
4920 }
4921
4922 sa_list = out_buff;
4923 sa = sa_list->Address;
4924 sockaddr = (SOCKADDR_IN *)&sa[num];
4925 sa_list->iAddressCount = num;
4926
4927 for (p = table, i = 0; p; p = p->Next)
4928 {
4929 if (!p->IpAddressList.IpAddress.String[0]) continue;
4930
4931 sa[i].lpSockaddr = (SOCKADDR *)&sockaddr[i];
4932 sa[i].iSockaddrLength = sizeof(SOCKADDR);
4933
4934 sockaddr[i].sin_family = WS_AF_INET;
4935 sockaddr[i].sin_port = 0;
4936 sockaddr[i].sin_addr.WS_s_addr = inet_addr(p->IpAddressList.IpAddress.String);
4937 i++;
4938 }
4939
4940 HeapFree(GetProcessHeap(), 0, table);
4941 }
4942 else
4943 {
4944 WARN("unable to get IP address list\n");
4945 status = WSAEINVAL;
4946 }
4947 break;
4948 }
4949
4950 case WS_SIO_FLUSH:
4951 FIXME("SIO_FLUSH: stub.\n");
4952 break;
4953
4954 case WS_SIO_GET_EXTENSION_FUNCTION_POINTER:
4955 {
4956 #define EXTENSION_FUNCTION(x, y) { x, y, #y },
4957 static const struct
4958 {
4959 GUID guid;
4960 void *func_ptr;
4961 const char *name;
4962 } guid_funcs[] = {
4963 EXTENSION_FUNCTION(WSAID_CONNECTEX, WS2_ConnectEx)
4964 EXTENSION_FUNCTION(WSAID_DISCONNECTEX, WS2_DisconnectEx)
4965 EXTENSION_FUNCTION(WSAID_ACCEPTEX, WS2_AcceptEx)
4966 EXTENSION_FUNCTION(WSAID_GETACCEPTEXSOCKADDRS, WS2_GetAcceptExSockaddrs)
4967 EXTENSION_FUNCTION(WSAID_TRANSMITFILE, WS2_TransmitFile)
4968 /* EXTENSION_FUNCTION(WSAID_TRANSMITPACKETS, WS2_TransmitPackets) */
4969 EXTENSION_FUNCTION(WSAID_WSARECVMSG, WS2_WSARecvMsg)
4970 EXTENSION_FUNCTION(WSAID_WSASENDMSG, WSASendMsg)
4971 };
4972 #undef EXTENSION_FUNCTION
4973 BOOL found = FALSE;
4974 unsigned int i;
4975
4976 for (i = 0; i < ARRAY_SIZE(guid_funcs); i++)
4977 {
4978 if (IsEqualGUID(&guid_funcs[i].guid, in_buff))
4979 {
4980 found = TRUE;
4981 break;
4982 }
4983 }
4984
4985 if (found)
4986 {
4987 TRACE("-> got %s\n", guid_funcs[i].name);
4988 *(void **)out_buff = guid_funcs[i].func_ptr;
4989 total = sizeof(void *);
4990 break;
4991 }
4992
4993 FIXME("SIO_GET_EXTENSION_FUNCTION_POINTER %s: stub\n", debugstr_guid(in_buff));
4994 status = WSAEOPNOTSUPP;
4995 break;
4996 }
4997 case WS_SIO_KEEPALIVE_VALS:
4998 {
4999 struct tcp_keepalive *k;
5000 int keepalive, keepidle, keepintvl;
5001
5002 if (!in_buff || in_size < sizeof(struct tcp_keepalive))
5003 {
5004 SetLastError(WSAEFAULT);
5005 return SOCKET_ERROR;
5006 }
5007
5008 k = in_buff;
5009 keepalive = k->onoff ? 1 : 0;
5010 keepidle = max( 1, (k->keepalivetime + 500) / 1000 );
5011 keepintvl = max( 1, (k->keepaliveinterval + 500) / 1000 );
5012
5013 TRACE("onoff: %d, keepalivetime: %d, keepaliveinterval: %d\n", keepalive, keepidle, keepintvl);
5014
5015 fd = get_sock_fd(s, 0, NULL);
5016 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive, sizeof(int)) == -1)
5017 status = WSAEINVAL;
5018 #if defined(TCP_KEEPIDLE) || defined(TCP_KEEPINTVL)
5019 /* these values need to be set only if SO_KEEPALIVE is enabled */
5020 else if(keepalive)
5021 {
5022 #ifndef TCP_KEEPIDLE
5023 FIXME("ignoring keepalive timeout\n");
5024 #else
5025 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, (void *)&keepidle, sizeof(int)) == -1)
5026 status = WSAEINVAL;
5027 else
5028 #endif
5029 #ifdef TCP_KEEPINTVL
5030 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, (void *)&keepintvl, sizeof(int)) == -1)
5031 status = WSAEINVAL;
5032 #else
5033 FIXME("ignoring keepalive interval\n");
5034 #endif
5035 }
5036 #else
5037 else
5038 FIXME("ignoring keepalive interval and timeout\n");
5039 #endif
5040 release_sock_fd(s, fd);
5041 break;
5042 }
5043 case WS_SIO_ROUTING_INTERFACE_QUERY:
5044 {
5045 struct WS_sockaddr *daddr = (struct WS_sockaddr *)in_buff;
5046 struct WS_sockaddr_in *daddr_in = (struct WS_sockaddr_in *)daddr;
5047 struct WS_sockaddr_in *saddr_in = out_buff;
5048 MIB_IPFORWARDROW row;
5049 PMIB_IPADDRTABLE ipAddrTable = NULL;
5050 DWORD size, i, found_index;
5051
5052 TRACE("-> WS_SIO_ROUTING_INTERFACE_QUERY request\n");
5053
5054 if (!in_buff || in_size < sizeof(struct WS_sockaddr) ||
5055 !out_buff || out_size < sizeof(struct WS_sockaddr_in) || !ret_size)
5056 {
5057 SetLastError(WSAEFAULT);
5058 return SOCKET_ERROR;
5059 }
5060 if (daddr->sa_family != WS_AF_INET)
5061 {
5062 FIXME("unsupported address family %d\n", daddr->sa_family);
5063 status = WSAEAFNOSUPPORT;
5064 break;
5065 }
5066 if (GetBestRoute(daddr_in->sin_addr.S_un.S_addr, 0, &row) != NOERROR ||
5067 GetIpAddrTable(NULL, &size, FALSE) != ERROR_INSUFFICIENT_BUFFER)
5068 {
5069 status = WSAEFAULT;
5070 break;
5071 }
5072 ipAddrTable = HeapAlloc(GetProcessHeap(), 0, size);
5073 if (GetIpAddrTable(ipAddrTable, &size, FALSE))
5074 {
5075 HeapFree(GetProcessHeap(), 0, ipAddrTable);
5076 status = WSAEFAULT;
5077 break;
5078 }
5079 for (i = 0, found_index = ipAddrTable->dwNumEntries;
5080 i < ipAddrTable->dwNumEntries; i++)
5081 {
5082 if (ipAddrTable->table[i].dwIndex == row.dwForwardIfIndex)
5083 found_index = i;
5084 }
5085 if (found_index == ipAddrTable->dwNumEntries)
5086 {
5087 ERR("no matching IP address for interface %d\n",
5088 row.dwForwardIfIndex);
5089 HeapFree(GetProcessHeap(), 0, ipAddrTable);
5090 status = WSAEFAULT;
5091 break;
5092 }
5093 saddr_in->sin_family = WS_AF_INET;
5094 saddr_in->sin_addr.S_un.S_addr = ipAddrTable->table[found_index].dwAddr;
5095 saddr_in->sin_port = 0;
5096 total = sizeof(struct WS_sockaddr_in);
5097 HeapFree(GetProcessHeap(), 0, ipAddrTable);
5098 break;
5099 }
5100 case WS_SIO_SET_COMPATIBILITY_MODE:
5101 TRACE("WS_SIO_SET_COMPATIBILITY_MODE ignored\n");
5102 status = WSAEOPNOTSUPP;
5103 break;
5104 case WS_SIO_UDP_CONNRESET:
5105 FIXME("WS_SIO_UDP_CONNRESET stub\n");
5106 break;
5107 case 0x667e: /* Netscape tries hard to use bogus ioctl 0x667e */
5108 SetLastError(WSAEOPNOTSUPP);
5109 return SOCKET_ERROR;
5110 default:
5111 status = WSAEOPNOTSUPP;
5112 break;
5113 }
5114
5115 if (status == WSAEOPNOTSUPP)
5116 {
5117 status = server_ioctl_sock(s, code, in_buff, in_size, out_buff, out_size, &total,
5118 overlapped, completion);
5119 if (status != WSAEOPNOTSUPP)
5120 {
5121 if (status == 0 || status == WSA_IO_PENDING)
5122 TRACE("-> %s request\n", debugstr_wsaioctl(code));
5123 else
5124 ERR("-> %s request failed with status 0x%x\n", debugstr_wsaioctl(code), status);
5125
5126 /* overlapped and completion operations will be handled by the server */
5127 completion = NULL;
5128 overlapped = NULL;
5129 }
5130 else
5131 FIXME("unsupported WS_IOCTL cmd (%s)\n", debugstr_wsaioctl(code));
5132 }
5133
5134 if (completion)
5135 {
5136 FIXME( "completion routine %p not supported\n", completion );
5137 }
5138 else if (overlapped)
5139 {
5140 ULONG_PTR cvalue = (overlapped && ((ULONG_PTR)overlapped->hEvent & 1) == 0) ? (ULONG_PTR)overlapped : 0;
5141 overlapped->Internal = sock_error_to_ntstatus( status );
5142 overlapped->InternalHigh = total;
5143 if (cvalue) WS_AddCompletion( HANDLE2SOCKET(s), cvalue, overlapped->Internal, total, FALSE );
5144 if (overlapped->hEvent) NtSetEvent( overlapped->hEvent, NULL );
5145 }
5146
5147 if (!status)
5148 {
5149 if (ret_size) *ret_size = total;
5150 return 0;
5151 }
5152 SetLastError( status );
5153 return SOCKET_ERROR;
5154 }
5155
5156
5157 /***********************************************************************
5158 * ioctlsocket (WS2_32.10)
5159 */
5160 int WINAPI WS_ioctlsocket(SOCKET s, LONG cmd, WS_u_long *argp)
5161 {
5162 DWORD ret_size;
5163 return WSAIoctl( s, cmd, argp, sizeof(WS_u_long), argp, sizeof(WS_u_long), &ret_size, NULL, NULL );
5164 }
5165
5166 /***********************************************************************
5167 * listen (WS2_32.13)
5168 */
5169 int WINAPI WS_listen(SOCKET s, int backlog)
5170 {
5171 int fd = get_sock_fd( s, FILE_READ_DATA, NULL ), ret = SOCKET_ERROR;
5172
5173 TRACE("socket %04lx, backlog %d\n", s, backlog);
5174 if (fd != -1)
5175 {
5176 int bound = is_fd_bound(fd, NULL, NULL);
5177
5178 if (bound <= 0)
5179 {
5180 SetLastError(bound == -1 ? wsaErrno() : WSAEINVAL);
5181 }
5182 else if (listen(fd, backlog) == 0)
5183 {
5184 _enable_event(SOCKET2HANDLE(s), FD_ACCEPT,
5185 FD_WINE_LISTENING,
5186 FD_CONNECT|FD_WINE_CONNECTED);
5187 ret = 0;
5188 }
5189 else
5190 SetLastError(wsaErrno());
5191 release_sock_fd( s, fd );
5192 }
5193
5194 return ret;
5195 }
5196
5197 /***********************************************************************
5198 * recv (WS2_32.16)
5199 */
5200 int WINAPI WS_recv(SOCKET s, char *buf, int len, int flags)
5201 {
5202 DWORD n, dwFlags = flags;
5203 WSABUF wsabuf;
5204
5205 wsabuf.len = len;
5206 wsabuf.buf = buf;
5207
5208 if ( WS2_recv_base(s, &wsabuf, 1, &n, &dwFlags, NULL, NULL, NULL, NULL, NULL) == SOCKET_ERROR )
5209 return SOCKET_ERROR;
5210 else
5211 return n;
5212 }
5213
5214 /***********************************************************************
5215 * recvfrom (WS2_32.17)
5216 */
5217 int WINAPI WS_recvfrom(SOCKET s, char *buf, INT len, int flags,
5218 struct WS_sockaddr *from, int *fromlen)
5219 {
5220 DWORD n, dwFlags = flags;
5221 WSABUF wsabuf;
5222
5223 wsabuf.len = len;
5224 wsabuf.buf = buf;
5225
5226 if ( WS2_recv_base(s, &wsabuf, 1, &n, &dwFlags, from, fromlen, NULL, NULL, NULL) == SOCKET_ERROR )
5227 return SOCKET_ERROR;
5228 else
5229 return n;
5230 }
5231
5232 /* allocate a poll array for the corresponding fd sets */
5233 static struct pollfd *fd_sets_to_poll( const WS_fd_set *readfds, const WS_fd_set *writefds,
5234 const WS_fd_set *exceptfds, int *count_ptr )
5235 {
5236 unsigned int i, j = 0, count = 0;
5237 struct pollfd *fds;
5238 struct per_thread_data *ptb = get_per_thread_data();
5239
5240 if (readfds) count += readfds->fd_count;
5241 if (writefds) count += writefds->fd_count;
5242 if (exceptfds) count += exceptfds->fd_count;
5243 *count_ptr = count;
5244 if (!count)
5245 {
5246 SetLastError(WSAEINVAL);
5247 return NULL;
5248 }
5249
5250 /* check if the cache can hold all descriptors, if not do the resizing */
5251 if (ptb->fd_count < count)
5252 {
5253 if (!(fds = HeapAlloc(GetProcessHeap(), 0, count * sizeof(fds[0]))))
5254 {
5255 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
5256 return NULL;
5257 }
5258 HeapFree(GetProcessHeap(), 0, ptb->fd_cache);
5259 ptb->fd_cache = fds;
5260 ptb->fd_count = count;
5261 }
5262 else
5263 fds = ptb->fd_cache;
5264
5265 if (readfds)
5266 for (i = 0; i < readfds->fd_count; i++, j++)
5267 {
5268 fds[j].fd = get_sock_fd( readfds->fd_array[i], FILE_READ_DATA, NULL );
5269 if (fds[j].fd == -1) goto failed;
5270 fds[j].revents = 0;
5271 if (is_fd_bound(fds[j].fd, NULL, NULL) == 1)
5272 {
5273 fds[j].events = POLLIN;
5274 }
5275 else
5276 {
5277 release_sock_fd( readfds->fd_array[i], fds[j].fd );
5278 fds[j].fd = -1;
5279 fds[j].events = 0;
5280 }
5281 }
5282 if (writefds)
5283 for (i = 0; i < writefds->fd_count; i++, j++)
5284 {
5285 fds[j].fd = get_sock_fd( writefds->fd_array[i], FILE_WRITE_DATA, NULL );
5286 if (fds[j].fd == -1) goto failed;
5287 fds[j].revents = 0;
5288 if (is_fd_bound(fds[j].fd, NULL, NULL) == 1 ||
5289 _get_fd_type(fds[j].fd) == SOCK_DGRAM)
5290 {
5291 fds[j].events = POLLOUT;
5292 }
5293 else
5294 {
5295 release_sock_fd( writefds->fd_array[i], fds[j].fd );
5296 fds[j].fd = -1;
5297 fds[j].events = 0;
5298 }
5299 }
5300 if (exceptfds)
5301 for (i = 0; i < exceptfds->fd_count; i++, j++)
5302 {
5303 fds[j].fd = get_sock_fd( exceptfds->fd_array[i], 0, NULL );
5304 if (fds[j].fd == -1) goto failed;
5305 fds[j].revents = 0;
5306 if (is_fd_bound(fds[j].fd, NULL, NULL) == 1)
5307 {
5308 int oob_inlined = 0;
5309 socklen_t olen = sizeof(oob_inlined);
5310
5311 fds[j].events = POLLHUP;
5312
5313 /* Check if we need to test for urgent data or not */
5314 getsockopt(fds[j].fd, SOL_SOCKET, SO_OOBINLINE, (char*) &oob_inlined, &olen);
5315 if (!oob_inlined)
5316 fds[j].events |= POLLPRI;
5317 }
5318 else
5319 {
5320 release_sock_fd( exceptfds->fd_array[i], fds[j].fd );
5321 fds[j].fd = -1;
5322 fds[j].events = 0;
5323 }
5324 }
5325 return fds;
5326
5327 failed:
5328 count = j;
5329 j = 0;
5330 if (readfds)
5331 for (i = 0; i < readfds->fd_count && j < count; i++, j++)
5332 if (fds[j].fd != -1) release_sock_fd( readfds->fd_array[i], fds[j].fd );
5333 if (writefds)
5334 for (i = 0; i < writefds->fd_count && j < count; i++, j++)
5335 if (fds[j].fd != -1) release_sock_fd( writefds->fd_array[i], fds[j].fd );
5336 if (exceptfds)
5337 for (i = 0; i < exceptfds->fd_count && j < count; i++, j++)
5338 if (fds[j].fd != -1) release_sock_fd( exceptfds->fd_array[i], fds[j].fd );
5339 return NULL;
5340 }
5341
5342 /* release the file descriptor obtained in fd_sets_to_poll */
5343 /* must be called with the original fd_set arrays, before calling get_poll_results */
5344 static void release_poll_fds( const WS_fd_set *readfds, const WS_fd_set *writefds,
5345 const WS_fd_set *exceptfds, struct pollfd *fds )
5346 {
5347 unsigned int i, j = 0;
5348
5349 if (readfds)
5350 {
5351 for (i = 0; i < readfds->fd_count; i++, j++)
5352 if (fds[j].fd != -1) release_sock_fd( readfds->fd_array[i], fds[j].fd );
5353 }
5354 if (writefds)
5355 {
5356 for (i = 0; i < writefds->fd_count; i++, j++)
5357 if (fds[j].fd != -1) release_sock_fd( writefds->fd_array[i], fds[j].fd );
5358 }
5359 if (exceptfds)
5360 {
5361 for (i = 0; i < exceptfds->fd_count; i++, j++)
5362 {
5363 if (fds[j].fd == -1) continue;
5364 release_sock_fd( exceptfds->fd_array[i], fds[j].fd );
5365 if (fds[j].revents & POLLHUP)
5366 {
5367 int fd = get_sock_fd( exceptfds->fd_array[i], 0, NULL );
5368 if (fd != -1)
5369 release_sock_fd( exceptfds->fd_array[i], fd );
5370 else
5371 fds[j].revents = 0;
5372 }
5373 }
5374 }
5375 }
5376
5377 static int do_poll(struct pollfd *pollfds, int count, int timeout)
5378 {
5379 struct timeval tv1, tv2;
5380 int ret, torig = timeout;
5381
5382 if (timeout > 0) gettimeofday( &tv1, 0 );
5383
5384 while ((ret = poll( pollfds, count, timeout )) < 0)
5385 {
5386 if (errno != EINTR) break;
5387 if (timeout < 0) continue;
5388 if (timeout == 0) return 0;
5389
5390 gettimeofday( &tv2, 0 );
5391
5392 tv2.tv_sec -= tv1.tv_sec;
5393 tv2.tv_usec -= tv1.tv_usec;
5394 if (tv2.tv_usec < 0)
5395 {
5396 tv2.tv_usec += 1000000;
5397 tv2.tv_sec -= 1;
5398 }
5399
5400 timeout = torig - (tv2.tv_sec * 1000) - (tv2.tv_usec + 999) / 1000;
5401 if (timeout <= 0) return 0;
5402 }
5403 return ret;
5404 }
5405
5406 /* map the poll results back into the Windows fd sets */
5407 static int get_poll_results( WS_fd_set *readfds, WS_fd_set *writefds, WS_fd_set *exceptfds,
5408 const struct pollfd *fds )
5409 {
5410 const struct pollfd *poll_writefds = fds + (readfds ? readfds->fd_count : 0);
5411 const struct pollfd *poll_exceptfds = poll_writefds + (writefds ? writefds->fd_count : 0);
5412 unsigned int i, k, total = 0;
5413
5414 if (readfds)
5415 {
5416 for (i = k = 0; i < readfds->fd_count; i++)
5417 {
5418 if (fds[i].revents ||
5419 (readfds == writefds && (poll_writefds[i].revents & POLLOUT) && !(poll_writefds[i].revents & POLLHUP)) ||
5420 (readfds == exceptfds && poll_exceptfds[i].revents))
5421 readfds->fd_array[k++] = readfds->fd_array[i];
5422 }
5423 readfds->fd_count = k;
5424 total += k;
5425 }
5426 if (writefds && writefds != readfds)
5427 {
5428 for (i = k = 0; i < writefds->fd_count; i++)
5429 {
5430 if (((poll_writefds[i].revents & POLLOUT) && !(poll_writefds[i].revents & POLLHUP)) ||
5431 (writefds == exceptfds && poll_exceptfds[i].revents))
5432 writefds->fd_array[k++] = writefds->fd_array[i];
5433 }
5434 writefds->fd_count = k;
5435 total += k;
5436 }
5437 if (exceptfds && exceptfds != readfds && exceptfds != writefds)
5438 {
5439 for (i = k = 0; i < exceptfds->fd_count; i++)
5440 if (poll_exceptfds[i].revents) exceptfds->fd_array[k++] = exceptfds->fd_array[i];
5441 exceptfds->fd_count = k;
5442 total += k;
5443 }
5444 return total;
5445 }
5446
5447 /***********************************************************************
5448 * select (WS2_32.18)
5449 */
5450 int WINAPI WS_select(int nfds, WS_fd_set *ws_readfds,
5451 WS_fd_set *ws_writefds, WS_fd_set *ws_exceptfds,
5452 const struct WS_timeval* ws_timeout)
5453 {
5454 struct pollfd *pollfds;
5455 int count, ret, timeout = -1;
5456
5457 TRACE("read %p, write %p, excp %p timeout %p\n",
5458 ws_readfds, ws_writefds, ws_exceptfds, ws_timeout);
5459
5460 if (!(pollfds = fd_sets_to_poll( ws_readfds, ws_writefds, ws_exceptfds, &count )))
5461 return SOCKET_ERROR;
5462
5463 if (ws_timeout)
5464 timeout = (ws_timeout->tv_sec * 1000) + (ws_timeout->tv_usec + 999) / 1000;
5465
5466 ret = do_poll(pollfds, count, timeout);
5467 release_poll_fds( ws_readfds, ws_writefds, ws_exceptfds, pollfds );
5468
5469 if (ret == -1) SetLastError(wsaErrno());
5470 else ret = get_poll_results( ws_readfds, ws_writefds, ws_exceptfds, pollfds );
5471 return ret;
5472 }
5473
5474 /***********************************************************************
5475 * WSAPoll
5476 */
5477 int WINAPI WSAPoll(WSAPOLLFD *wfds, ULONG count, int timeout)
5478 {
5479 int i, ret;
5480 struct pollfd *ufds;
5481
5482 if (!count)
5483 {
5484 SetLastError(WSAEINVAL);
5485 return SOCKET_ERROR;
5486 }
5487 if (!wfds)
5488 {
5489 SetLastError(WSAEFAULT);
5490 return SOCKET_ERROR;
5491 }
5492
5493 if (!(ufds = HeapAlloc(GetProcessHeap(), 0, count * sizeof(ufds[0]))))
5494 {
5495 SetLastError(WSAENOBUFS);
5496 return SOCKET_ERROR;
5497 }
5498
5499 for (i = 0; i < count; i++)
5500 {
5501 ufds[i].fd = get_sock_fd(wfds[i].fd, 0, NULL);
5502 ufds[i].events = convert_poll_w2u(wfds[i].events);
5503 ufds[i].revents = 0;
5504 }
5505
5506 ret = do_poll(ufds, count, timeout);
5507
5508 for (i = 0; i < count; i++)
5509 {
5510 if (ufds[i].fd != -1)
5511 {
5512 release_sock_fd(wfds[i].fd, ufds[i].fd);
5513 if (ufds[i].revents & POLLHUP)
5514 {
5515 /* Check if the socket still exists */
5516 int fd = get_sock_fd(wfds[i].fd, 0, NULL);
5517 if (fd != -1)
5518 {
5519 wfds[i].revents = WS_POLLHUP;
5520 release_sock_fd(wfds[i].fd, fd);
5521 }
5522 else
5523 wfds[i].revents = WS_POLLNVAL;
5524 }
5525 else
5526 wfds[i].revents = convert_poll_u2w(ufds[i].revents);
5527 }
5528 else
5529 wfds[i].revents = WS_POLLNVAL;
5530 }
5531
5532 HeapFree(GetProcessHeap(), 0, ufds);
5533 return ret;
5534 }
5535
5536 /* helper to send completion messages for client-only i/o operation case */
5537 static void WS_AddCompletion( SOCKET sock, ULONG_PTR CompletionValue, NTSTATUS CompletionStatus,
5538 ULONG Information, BOOL async )
5539 {
5540 SERVER_START_REQ( add_fd_completion )
5541 {
5542 req->handle = wine_server_obj_handle( SOCKET2HANDLE(sock) );
5543 req->cvalue = CompletionValue;
5544 req->status = CompletionStatus;
5545 req->information = Information;
5546 req->async = async;
5547 wine_server_call( req );
5548 }
5549 SERVER_END_REQ;
5550 }
5551
5552
5553 /***********************************************************************
5554 * send (WS2_32.19)
5555 */
5556 int WINAPI WS_send(SOCKET s, const char *buf, int len, int flags)
5557 {
5558 DWORD n;
5559 WSABUF wsabuf;
5560
5561 wsabuf.len = len;
5562 wsabuf.buf = (char*) buf;
5563
5564 if ( WS2_sendto( s, &wsabuf, 1, &n, flags, NULL, 0, NULL, NULL) == SOCKET_ERROR )
5565 return SOCKET_ERROR;
5566 else
5567 return n;
5568 }
5569
5570 /***********************************************************************
5571 * WSASend (WS2_32.72)
5572 */
5573 INT WINAPI WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
5574 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
5575 LPWSAOVERLAPPED lpOverlapped,
5576 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
5577 {
5578 return WS2_sendto( s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags,
5579 NULL, 0, lpOverlapped, lpCompletionRoutine );
5580 }
5581
5582 /***********************************************************************
5583 * WSASendDisconnect (WS2_32.73)
5584 */
5585 INT WINAPI WSASendDisconnect( SOCKET s, LPWSABUF lpBuffers )
5586 {
5587 return WS_shutdown( s, SD_SEND );
5588 }
5589
5590
5591 static int WS2_sendto( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
5592 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
5593 const struct WS_sockaddr *to, int tolen,
5594 LPWSAOVERLAPPED lpOverlapped,
5595 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
5596 {
5597 unsigned int i, options;
5598 int n, fd, err, overlapped, flags;
5599 struct ws2_async *wsa = NULL, localwsa;
5600 int totalLength = 0;
5601 DWORD bytes_sent;
5602 BOOL is_blocking;
5603
5604 TRACE("socket %04lx, wsabuf %p, nbufs %d, flags %d, to %p, tolen %d, ovl %p, func %p\n",
5605 s, lpBuffers, dwBufferCount, dwFlags,
5606 to, tolen, lpOverlapped, lpCompletionRoutine);
5607
5608 fd = get_sock_fd( s, FILE_WRITE_DATA, &options );
5609 TRACE( "fd=%d, options=%x\n", fd, options );
5610
5611 if ( fd == -1 ) return SOCKET_ERROR;
5612
5613 if (!lpOverlapped && !lpNumberOfBytesSent)
5614 {
5615 err = WSAEFAULT;
5616 goto error;
5617 }
5618
5619 overlapped = (lpOverlapped || lpCompletionRoutine) &&
5620 !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT));
5621 if (overlapped || dwBufferCount > 1)
5622 {
5623 if (!(wsa = (struct ws2_async *)alloc_async_io( offsetof(struct ws2_async, iovec[dwBufferCount]),
5624 WS2_async_send )))
5625 {
5626 err = WSAEFAULT;
5627 goto error;
5628 }
5629 }
5630 else
5631 wsa = &localwsa;
5632
5633 wsa->hSocket = SOCKET2HANDLE(s);
5634 wsa->addr = (struct WS_sockaddr *)to;
5635 wsa->addrlen.val = tolen;
5636 wsa->flags = dwFlags;
5637 wsa->lpFlags = &wsa->flags;
5638 wsa->control = NULL;
5639 wsa->n_iovecs = dwBufferCount;
5640 wsa->first_iovec = 0;
5641 for ( i = 0; i < dwBufferCount; i++ )
5642 {
5643 wsa->iovec[i].iov_base = lpBuffers[i].buf;
5644 wsa->iovec[i].iov_len = lpBuffers[i].len;
5645 totalLength += lpBuffers[i].len;
5646 }
5647
5648 flags = convert_flags(dwFlags);
5649 n = WS2_send( fd, wsa, flags );
5650 if (n == -1 && errno != EAGAIN)
5651 {
5652 err = wsaErrno();
5653 goto error;
5654 }
5655
5656 if (overlapped)
5657 {
5658 IO_STATUS_BLOCK *iosb = lpOverlapped ? (IO_STATUS_BLOCK *)lpOverlapped : &wsa->local_iosb;
5659 ULONG_PTR cvalue = (lpOverlapped && ((ULONG_PTR)lpOverlapped->hEvent & 1) == 0) ? (ULONG_PTR)lpOverlapped : 0;
5660
5661 wsa->user_overlapped = lpOverlapped;
5662 wsa->completion_func = lpCompletionRoutine;
5663 release_sock_fd( s, fd );
5664
5665 if (n == -1 || n < totalLength)
5666 {
5667 iosb->u.Status = STATUS_PENDING;
5668 iosb->Information = n == -1 ? 0 : n;
5669
5670 if (wsa->completion_func)
5671 err = register_async( ASYNC_TYPE_WRITE, wsa->hSocket, &wsa->io, NULL,
5672 ws2_async_apc, wsa, iosb );
5673 else
5674 err = register_async( ASYNC_TYPE_WRITE, wsa->hSocket, &wsa->io, lpOverlapped->hEvent,
5675 NULL, (void *)cvalue, iosb );
5676
5677 /* Enable the event only after starting the async. The server will deliver it as soon as
5678 the async is done. */
5679 _enable_event(SOCKET2HANDLE(s), FD_WRITE, 0, 0);
5680
5681 if (err != STATUS_PENDING) HeapFree( GetProcessHeap(), 0, wsa );
5682 SetLastError(NtStatusToWSAError( err ));
5683 return SOCKET_ERROR;
5684 }
5685
5686 iosb->u.Status = STATUS_SUCCESS;
5687 iosb->Information = n;
5688 if (lpNumberOfBytesSent) *lpNumberOfBytesSent = n;
5689 if (!wsa->completion_func)
5690 {
5691 if (cvalue) WS_AddCompletion( s, cvalue, STATUS_SUCCESS, n, FALSE );
5692 if (lpOverlapped->hEvent) SetEvent( lpOverlapped->hEvent );
5693 HeapFree( GetProcessHeap(), 0, wsa );
5694 }
5695 else NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC)ws2_async_apc,
5696 (ULONG_PTR)wsa, (ULONG_PTR)iosb, 0 );
5697 SetLastError(ERROR_SUCCESS);
5698 return 0;
5699 }
5700
5701 if ((err = sock_is_blocking( s, &is_blocking ))) goto error;
5702
5703 if ( is_blocking )
5704 {
5705 /* On a blocking non-overlapped stream socket,
5706 * sending blocks until the entire buffer is sent. */
5707 DWORD timeout_start = GetTickCount();
5708
5709 bytes_sent = n == -1 ? 0 : n;
5710
5711 while (wsa->first_iovec < wsa->n_iovecs)
5712 {
5713 struct pollfd pfd;
5714 int poll_timeout = -1;
5715 INT64 timeout = get_rcvsnd_timeo(fd, FALSE);
5716
5717 if (timeout)
5718 {
5719 timeout -= GetTickCount() - timeout_start;
5720 if (timeout < 0) poll_timeout = 0;
5721 else poll_timeout = timeout <= INT_MAX ? timeout : INT_MAX;
5722 }
5723
5724 pfd.fd = fd;
5725 pfd.events = POLLOUT;
5726
5727 if (!poll_timeout || !poll( &pfd, 1, poll_timeout ))
5728 {
5729 err = WSAETIMEDOUT;
5730 goto error; /* msdn says a timeout in send is fatal */
5731 }
5732
5733 n = WS2_send( fd, wsa, flags );
5734 if (n == -1 && errno != EAGAIN)
5735 {
5736 err = wsaErrno();
5737 goto error;
5738 }
5739
5740 if (n >= 0)
5741 bytes_sent += n;
5742 }
5743 }
5744 else /* non-blocking */
5745 {
5746 if (n < totalLength)
5747 _enable_event(SOCKET2HANDLE(s), FD_WRITE, 0, 0);
5748 if (n == -1)
5749 {
5750 err = WSAEWOULDBLOCK;
5751 goto error;
5752 }
5753 bytes_sent = n;
5754 }
5755
5756 TRACE(" -> %i bytes\n", bytes_sent);
5757
5758 if (lpNumberOfBytesSent) *lpNumberOfBytesSent = bytes_sent;
5759 if (wsa != &localwsa) HeapFree( GetProcessHeap(), 0, wsa );
5760 release_sock_fd( s, fd );
5761 SetLastError(ERROR_SUCCESS);
5762 return 0;
5763
5764 error:
5765 if (wsa != &localwsa) HeapFree( GetProcessHeap(), 0, wsa );
5766 release_sock_fd( s, fd );
5767 WARN(" -> ERROR %d\n", err);
5768 SetLastError(err);
5769 return SOCKET_ERROR;
5770 }
5771
5772 /***********************************************************************
5773 * WSASendTo (WS2_32.74)
5774 */
5775 INT WINAPI WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
5776 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
5777 const struct WS_sockaddr *to, int tolen,
5778 LPWSAOVERLAPPED lpOverlapped,
5779 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
5780 {
5781 return WS2_sendto( s, lpBuffers, dwBufferCount,
5782 lpNumberOfBytesSent, dwFlags,
5783 to, tolen,
5784 lpOverlapped, lpCompletionRoutine );
5785 }
5786
5787 /***********************************************************************
5788 * sendto (WS2_32.20)
5789 */
5790 int WINAPI WS_sendto(SOCKET s, const char *buf, int len, int flags,
5791 const struct WS_sockaddr *to, int tolen)
5792 {
5793 DWORD n;
5794 WSABUF wsabuf;
5795
5796 wsabuf.len = len;
5797 wsabuf.buf = (char*) buf;
5798
5799 if ( WS2_sendto(s, &wsabuf, 1, &n, flags, to, tolen, NULL, NULL) == SOCKET_ERROR )
5800 return SOCKET_ERROR;
5801 else
5802 return n;
5803 }
5804
5805 /***********************************************************************
5806 * setsockopt (WS2_32.21)
5807 */
5808 int WINAPI WS_setsockopt(SOCKET s, int level, int optname,
5809 const char *optval, int optlen)
5810 {
5811 int fd;
5812 int woptval;
5813 struct linger linger;
5814 struct timeval tval;
5815 struct ip_mreq_source mreq_source;
5816
5817 TRACE("(socket %04lx, %s, optval %s, optlen %d)\n", s,
5818 debugstr_sockopt(level, optname), debugstr_optval(optval, optlen),
5819 optlen);
5820
5821 /* some broken apps pass the value directly instead of a pointer to it */
5822 if(optlen && IS_INTRESOURCE(optval))
5823 {
5824 SetLastError(WSAEFAULT);
5825 return SOCKET_ERROR;
5826 }
5827
5828 switch(level)
5829 {
5830 case WS_SOL_SOCKET:
5831 switch(optname)
5832 {
5833 /* Some options need some conversion before they can be sent to
5834 * setsockopt. The conversions are done here, then they will fall through
5835 * to the general case. Special options that are not passed to
5836 * setsockopt follow below that.*/
5837
5838 case WS_SO_DONTLINGER:
5839 if (!optval)
5840 {
5841 SetLastError(WSAEFAULT);
5842 return SOCKET_ERROR;
5843 }
5844 linger.l_onoff = *(const int*)optval == 0;
5845 linger.l_linger = 0;
5846 level = SOL_SOCKET;
5847 optname = SO_LINGER;
5848 optval = (char*)&linger;
5849 optlen = sizeof(struct linger);
5850 break;
5851
5852 case WS_SO_LINGER:
5853 if (!optval)
5854 {
5855 SetLastError(WSAEFAULT);
5856 return SOCKET_ERROR;
5857 }
5858 linger.l_onoff = ((LINGER*)optval)->l_onoff;
5859 linger.l_linger = ((LINGER*)optval)->l_linger;
5860 level = SOL_SOCKET;
5861 optname = SO_LINGER;
5862 optval = (char*)&linger;
5863 optlen = sizeof(struct linger);
5864 break;
5865
5866 case WS_SO_SNDBUF:
5867 if (!*(const int *)optval)
5868 {
5869 FIXME("SO_SNDBUF ignoring request to disable send buffering\n");
5870 #ifdef __APPLE__
5871 return 0;
5872 #endif
5873 }
5874 convert_sockopt(&level, &optname);
5875 break;
5876
5877 case WS_SO_RCVBUF:
5878 if (*(const int*)optval < 2048)
5879 {
5880 WARN("SO_RCVBF for %d bytes is too small: ignored\n", *(const int*)optval );
5881 return 0;
5882 }
5883 /* Fall through */
5884
5885 /* The options listed here don't need any special handling. Thanks to
5886 * the conversion happening above, options from there will fall through
5887 * to this, too.*/
5888 case WS_SO_ACCEPTCONN:
5889 case WS_SO_BROADCAST:
5890 case WS_SO_ERROR:
5891 case WS_SO_KEEPALIVE:
5892 case WS_SO_OOBINLINE:
5893 /* BSD socket SO_REUSEADDR is not 100% compatible to winsock semantics.
5894 * however, using it the BSD way fixes bug 8513 and seems to be what
5895 * most programmers assume, anyway */
5896 case WS_SO_REUSEADDR:
5897 case WS_SO_TYPE:
5898 convert_sockopt(&level, &optname);
5899 break;
5900
5901 /* SO_DEBUG is a privileged operation, ignore it. */
5902 case WS_SO_DEBUG:
5903 TRACE("Ignoring SO_DEBUG\n");
5904 return 0;
5905
5906 /* For some reason the game GrandPrixLegends does set SO_DONTROUTE on its
5907 * socket. According to MSDN, this option is silently ignored.*/
5908 case WS_SO_DONTROUTE:
5909 TRACE("Ignoring SO_DONTROUTE\n");
5910 return 0;
5911
5912 /* Stops two sockets from being bound to the same port. Always happens
5913 * on unix systems, so just drop it. */
5914 case WS_SO_EXCLUSIVEADDRUSE:
5915 TRACE("Ignoring SO_EXCLUSIVEADDRUSE, is always set.\n");
5916 return 0;
5917
5918 /* After a ConnectEx call succeeds, the socket can't be used with half of the
5919 * normal winsock functions on windows. We don't have that problem. */
5920 case WS_SO_UPDATE_CONNECT_CONTEXT:
5921 TRACE("Ignoring SO_UPDATE_CONNECT_CONTEXT, since our sockets are normal\n");
5922 return 0;
5923
5924 /* After a AcceptEx call succeeds, the socket can't be used with half of the
5925 * normal winsock functions on windows. We don't have that problem. */
5926 case WS_SO_UPDATE_ACCEPT_CONTEXT:
5927 TRACE("Ignoring SO_UPDATE_ACCEPT_CONTEXT, since our sockets are normal\n");
5928 return 0;
5929
5930 /* SO_OPENTYPE does not require a valid socket handle. */
5931 case WS_SO_OPENTYPE:
5932 if (!optlen || optlen < sizeof(int) || !optval)
5933 {
5934 SetLastError(WSAEFAULT);
5935 return SOCKET_ERROR;
5936 }
5937 get_per_thread_data()->opentype = *(const int *)optval;
5938 TRACE("setting global SO_OPENTYPE = 0x%x\n", *((const int*)optval) );
5939 return 0;
5940
5941 #ifdef SO_RCVTIMEO
5942 case WS_SO_RCVTIMEO:
5943 #endif
5944 #ifdef SO_SNDTIMEO
5945 case WS_SO_SNDTIMEO:
5946 #endif
5947 #if defined(SO_RCVTIMEO) || defined(SO_SNDTIMEO)
5948 if (optval && optlen == sizeof(UINT32)) {
5949 /* WinSock passes milliseconds instead of struct timeval */
5950 tval.tv_usec = (*(const UINT32*)optval % 1000) * 1000;
5951 tval.tv_sec = *(const UINT32*)optval / 1000;
5952 /* min of 500 milliseconds */
5953 if (tval.tv_sec == 0 && tval.tv_usec && tval.tv_usec < 500000)
5954 tval.tv_usec = 500000;
5955 optlen = sizeof(struct timeval);
5956 optval = (char*)&tval;
5957 } else if (optlen == sizeof(struct timeval)) {
5958 WARN("SO_SND/RCVTIMEO for %d bytes: assuming unixism\n", optlen);
5959 } else {
5960 WARN("SO_SND/RCVTIMEO for %d bytes is weird: ignored\n", optlen);
5961 return 0;
5962 }
5963 convert_sockopt(&level, &optname);
5964 break;
5965 #endif
5966
5967 case WS_SO_RANDOMIZE_PORT:
5968 FIXME("Ignoring WS_SO_RANDOMIZE_PORT\n");
5969 return 0;
5970
5971 case WS_SO_PORT_SCALABILITY:
5972 FIXME("Ignoring WS_SO_PORT_SCALABILITY\n");
5973 return 0;
5974
5975 case WS_SO_REUSE_UNICASTPORT:
5976 FIXME("Ignoring WS_SO_REUSE_UNICASTPORT\n");
5977 return 0;
5978
5979 case WS_SO_REUSE_MULTICASTPORT:
5980 FIXME("Ignoring WS_SO_REUSE_MULTICASTPORT\n");
5981 return 0;
5982
5983 default:
5984 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
5985 SetLastError(WSAENOPROTOOPT);
5986 return SOCKET_ERROR;
5987 }
5988 break; /* case WS_SOL_SOCKET */
5989
5990 #ifdef HAS_IPX
5991 case WS_NSPROTO_IPX:
5992 switch(optname)
5993 {
5994 case WS_IPX_PTYPE:
5995 return set_ipx_packettype(s, *(int*)optval);
5996
5997 case WS_IPX_FILTERPTYPE:
5998 /* Sets the receive filter packet type, at the moment we don't support it */
5999 FIXME("IPX_FILTERPTYPE: %x\n", *optval);
6000 /* Returning 0 is better for now than returning a SOCKET_ERROR */
6001 return 0;
6002
6003 default:
6004 FIXME("opt_name:%x\n", optname);
6005 return SOCKET_ERROR;
6006 }
6007 break; /* case WS_NSPROTO_IPX */
6008 #endif
6009
6010 /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */
6011 case WS_IPPROTO_TCP:
6012 switch(optname)
6013 {
6014 case WS_TCP_NODELAY:
6015 convert_sockopt(&level, &optname);
6016 break;
6017 default:
6018 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
6019 return SOCKET_ERROR;
6020 }
6021 break;
6022
6023 case WS_IPPROTO_IP:
6024 switch(optname)
6025 {
6026 case WS_IP_ADD_SOURCE_MEMBERSHIP:
6027 case WS_IP_DROP_SOURCE_MEMBERSHIP:
6028 case WS_IP_BLOCK_SOURCE:
6029 case WS_IP_UNBLOCK_SOURCE:
6030 {
6031 WS_IP_MREQ_SOURCE* val = (void*)optval;
6032 mreq_source.imr_interface.s_addr = val->imr_interface.S_un.S_addr;
6033 mreq_source.imr_multiaddr.s_addr = val->imr_multiaddr.S_un.S_addr;
6034 mreq_source.imr_sourceaddr.s_addr = val->imr_sourceaddr.S_un.S_addr;
6035
6036 optval = (char*)&mreq_source;
6037 optlen = sizeof(mreq_source);
6038
6039 convert_sockopt(&level, &optname);
6040 break;
6041 }
6042 case WS_IP_ADD_MEMBERSHIP:
6043 case WS_IP_DROP_MEMBERSHIP:
6044 #ifdef IP_HDRINCL
6045 case WS_IP_HDRINCL:
6046 #endif
6047 case WS_IP_MULTICAST_IF:
6048 case WS_IP_MULTICAST_LOOP:
6049 case WS_IP_MULTICAST_TTL:
6050 case WS_IP_OPTIONS:
6051 #if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
6052 case WS_IP_PKTINFO:
6053 #endif
6054 case WS_IP_TOS:
6055 case WS_IP_TTL:
6056 #ifdef IP_UNICAST_IF
6057 case WS_IP_UNICAST_IF:
6058 #endif
6059 convert_sockopt(&level, &optname);
6060 break;
6061 case WS_IP_DONTFRAGMENT:
6062 return set_dont_fragment(s, IPPROTO_IP, *(BOOL *)optval) ? 0 : SOCKET_ERROR;
6063 default:
6064 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
6065 return SOCKET_ERROR;
6066 }
6067 break;
6068
6069 case WS_IPPROTO_IPV6:
6070 switch(optname)
6071 {
6072 #ifdef IPV6_ADD_MEMBERSHIP
6073 case WS_IPV6_ADD_MEMBERSHIP:
6074 #endif
6075 #ifdef IPV6_DROP_MEMBERSHIP
6076 case WS_IPV6_DROP_MEMBERSHIP:
6077 #endif
6078 case WS_IPV6_MULTICAST_IF:
6079 case WS_IPV6_MULTICAST_HOPS:
6080 case WS_IPV6_MULTICAST_LOOP:
6081 case WS_IPV6_UNICAST_HOPS:
6082 #ifdef IPV6_UNICAST_IF
6083 case WS_IPV6_UNICAST_IF:
6084 #endif
6085 convert_sockopt(&level, &optname);
6086 break;
6087 case WS_IPV6_DONTFRAG:
6088 return set_dont_fragment(s, IPPROTO_IPV6, *(BOOL *)optval) ? 0 : SOCKET_ERROR;
6089 case WS_IPV6_PROTECTION_LEVEL:
6090 FIXME("IPV6_PROTECTION_LEVEL is ignored!\n");
6091 return 0;
6092 case WS_IPV6_V6ONLY:
6093 {
6094 union generic_unix_sockaddr uaddr;
6095 socklen_t uaddrlen;
6096 int bound;
6097
6098 fd = get_sock_fd( s, 0, NULL );
6099 if (fd == -1) return SOCKET_ERROR;
6100
6101 bound = is_fd_bound(fd, &uaddr, &uaddrlen);
6102 release_sock_fd( s, fd );
6103 if (bound == 0 && uaddr.addr.sa_family == AF_INET)
6104 {
6105 /* Changing IPV6_V6ONLY succeeds on AF_INET (IPv4) socket
6106 * on Windows (with IPv6 support) if the socket is unbound.
6107 * It is essentially a noop, though Windows does store the value
6108 */
6109 WARN("Silently ignoring IPPROTO_IPV6+IPV6_V6ONLY on AF_INET socket\n");
6110 return 0;
6111 }
6112 level = IPPROTO_IPV6;
6113 optname = IPV6_V6ONLY;
6114 break;
6115 }
6116 default:
6117 FIXME("Unknown IPPROTO_IPV6 optname 0x%08x\n", optname);
6118 return SOCKET_ERROR;
6119 }
6120 break;
6121
6122 default:
6123 WARN("Unknown level: 0x%08x\n", level);
6124 SetLastError(WSAEINVAL);
6125 return SOCKET_ERROR;
6126 } /* end switch(level) */
6127
6128 /* avoid endianness issues if argument is a 16-bit int */
6129 if (optval && optlen < sizeof(int))
6130 {
6131 woptval= *((const INT16 *) optval);
6132 optval= (char*) &woptval;
6133 woptval&= (1 << optlen * 8) - 1;
6134 optlen=sizeof(int);
6135 }
6136 fd = get_sock_fd( s, 0, NULL );
6137 if (fd == -1) return SOCKET_ERROR;
6138
6139 if (setsockopt(fd, level, optname, optval, optlen) == 0)
6140 {
6141 #ifdef __APPLE__
6142 if (level == SOL_SOCKET && optname == SO_REUSEADDR &&
6143 setsockopt(fd, level, SO_REUSEPORT, optval, optlen) != 0)
6144 {
6145 SetLastError(wsaErrno());
6146 release_sock_fd( s, fd );
6147 return SOCKET_ERROR;
6148 }
6149 #endif
6150 release_sock_fd( s, fd );
6151 return 0;
6152 }
6153 TRACE("Setting socket error, %d\n", wsaErrno());
6154 SetLastError(wsaErrno());
6155 release_sock_fd( s, fd );
6156
6157 return SOCKET_ERROR;
6158 }
6159
6160 /***********************************************************************
6161 * shutdown (WS2_32.22)
6162 */
6163 int WINAPI WS_shutdown(SOCKET s, int how)
6164 {
6165 int fd, err = WSAENOTSOCK;
6166 unsigned int options = 0, clear_flags = 0;
6167
6168 fd = get_sock_fd( s, 0, &options );
6169 TRACE("socket %04lx, how 0x%x, options 0x%x\n", s, how, options );
6170
6171 if (fd == -1)
6172 return SOCKET_ERROR;
6173
6174 switch( how )
6175 {
6176 case SD_RECEIVE: /* drop receives */
6177 clear_flags |= FD_READ;
6178 break;
6179 case SD_SEND: /* drop sends */
6180 clear_flags |= FD_WRITE;
6181 break;
6182 case SD_BOTH: /* drop all */
6183 clear_flags |= FD_READ|FD_WRITE;
6184 /*fall through */
6185 default:
6186 clear_flags |= FD_WINE_LISTENING;
6187 }
6188
6189 if (!(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT)))
6190 {
6191 switch ( how )
6192 {
6193 case SD_RECEIVE:
6194 err = WS2_register_async_shutdown( s, ASYNC_TYPE_READ );
6195 break;
6196 case SD_SEND:
6197 err = WS2_register_async_shutdown( s, ASYNC_TYPE_WRITE );
6198 break;
6199 case SD_BOTH:
6200 default:
6201 err = WS2_register_async_shutdown( s, ASYNC_TYPE_READ );
6202 if (!err) err = WS2_register_async_shutdown( s, ASYNC_TYPE_WRITE );
6203 break;
6204 }
6205 if (err) goto error;
6206 }
6207 else /* non-overlapped mode */
6208 {
6209 if ( shutdown( fd, how ) )
6210 {
6211 err = wsaErrno();
6212 goto error;
6213 }
6214 }
6215
6216 release_sock_fd( s, fd );
6217 _enable_event( SOCKET2HANDLE(s), 0, 0, clear_flags );
6218 if ( how > 1) WSAAsyncSelect( s, 0, 0, 0 );
6219 return 0;
6220
6221 error:
6222 release_sock_fd( s, fd );
6223 _enable_event( SOCKET2HANDLE(s), 0, 0, clear_flags );
6224 SetLastError( err );
6225 return SOCKET_ERROR;
6226 }
6227
6228 /***********************************************************************
6229 * socket (WS2_32.23)
6230 */
6231 SOCKET WINAPI WS_socket(int af, int type, int protocol)
6232 {
6233 TRACE("af=%d type=%d protocol=%d\n", af, type, protocol);
6234
6235 return WSASocketW( af, type, protocol, NULL, 0,
6236 get_per_thread_data()->opentype ? 0 : WSA_FLAG_OVERLAPPED );
6237 }
6238
6239
6240 /***********************************************************************
6241 * gethostbyaddr (WS2_32.51)
6242 */
6243 struct WS_hostent* WINAPI WS_gethostbyaddr(const char *addr, int len, int type)
6244 {
6245 struct WS_hostent *retval = NULL;
6246 struct hostent* host;
6247 int unixtype = convert_af_w2u(type);
6248 const char *paddr = addr;
6249 unsigned long loopback;
6250 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
6251 char *extrabuf;
6252 int ebufsize = 1024;
6253 struct hostent hostentry;
6254 int locerr = ENOBUFS;
6255 #endif
6256
6257 /* convert back the magic loopback address if necessary */
6258 if (unixtype == AF_INET && len == 4 && !memcmp(addr, magic_loopback_addr, 4))
6259 {
6260 loopback = htonl(INADDR_LOOPBACK);
6261 paddr = (char*) &loopback;
6262 }
6263
6264 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
6265 host = NULL;
6266 extrabuf=HeapAlloc(GetProcessHeap(),0,ebufsize) ;
6267 while(extrabuf) {
6268 int res = gethostbyaddr_r(paddr, len, unixtype,
6269 &hostentry, extrabuf, ebufsize, &host, &locerr);
6270 if (res != ERANGE) break;
6271 ebufsize *=2;
6272 extrabuf=HeapReAlloc(GetProcessHeap(),0,extrabuf,ebufsize) ;
6273 }
6274 if (host) retval = WS_dup_he(host);
6275 else SetLastError((locerr < 0) ? wsaErrno() : wsaHerrno(locerr));
6276 HeapFree(GetProcessHeap(),0,extrabuf);
6277 #else
6278 EnterCriticalSection( &csWSgetXXXbyYYY );
6279 host = gethostbyaddr(paddr, len, unixtype);
6280 if (host) retval = WS_dup_he(host);
6281 else SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno(h_errno));
6282 LeaveCriticalSection( &csWSgetXXXbyYYY );
6283 #endif
6284 TRACE("ptr %p, len %d, type %d ret %p\n", addr, len, type, retval);
6285 return retval;
6286 }
6287
6288 /***********************************************************************
6289 * WS_compare_routes_by_metric_asc (INTERNAL)
6290 *
6291 * Comparison function for qsort(), for sorting two routes (struct route)
6292 * by metric in ascending order.
6293 */
6294 static int WS_compare_routes_by_metric_asc(const void *left, const void *right)
6295 {
6296 const struct route *a = left, *b = right;
6297 if (a->default_route && b->default_route)
6298 return a->default_route - b->default_route;
6299 if (a->default_route && !b->default_route)
6300 return -1;
6301 if (b->default_route && !a->default_route)
6302 return 1;
6303 return a->metric - b->metric;
6304 }
6305
6306 /***********************************************************************
6307 * WS_get_local_ips (INTERNAL)
6308 *
6309 * Returns the list of local IP addresses by going through the network
6310 * adapters and using the local routing table to sort the addresses
6311 * from highest routing priority to lowest routing priority. This
6312 * functionality is inferred from the description for obtaining local
6313 * IP addresses given in the Knowledge Base Article Q160215.
6314 *
6315 * Please note that the returned hostent is only freed when the thread
6316 * closes and is replaced if another hostent is requested.
6317 */
6318 static struct WS_hostent* WS_get_local_ips( char *hostname )
6319 {
6320 int numroutes = 0, i, j, default_routes = 0;
6321 DWORD n;
6322 PIP_ADAPTER_INFO adapters = NULL, k;
6323 struct WS_hostent *hostlist = NULL;
6324 PMIB_IPFORWARDTABLE routes = NULL;
6325 struct route *route_addrs = NULL;
6326 DWORD adap_size, route_size;
6327
6328 /* Obtain the size of the adapter list and routing table, also allocate memory */
6329 if (GetAdaptersInfo(NULL, &adap_size) != ERROR_BUFFER_OVERFLOW)
6330 return NULL;
6331 if (GetIpForwardTable(NULL, &route_size, FALSE) != ERROR_INSUFFICIENT_BUFFER)
6332 return NULL;
6333 adapters = HeapAlloc(GetProcessHeap(), 0, adap_size);
6334 routes = HeapAlloc(GetProcessHeap(), 0, route_size);
6335 if (adapters == NULL || routes == NULL)
6336 goto cleanup;
6337 /* Obtain the adapter list and the full routing table */
6338 if (GetAdaptersInfo(adapters, &adap_size) != NO_ERROR)
6339 goto cleanup;
6340 if (GetIpForwardTable(routes, &route_size, FALSE) != NO_ERROR)
6341 goto cleanup;
6342 /* Store the interface associated with each route */
6343 for (n = 0; n < routes->dwNumEntries; n++)
6344 {
6345 IF_INDEX ifindex;
6346 DWORD ifmetric, ifdefault = 0;
6347 BOOL exists = FALSE;
6348
6349 /* Check if this is a default route (there may be more than one) */
6350 if (!routes->table[n].dwForwardDest)
6351 ifdefault = ++default_routes;
6352 else if (routes->table[n].u1.ForwardType != MIB_IPROUTE_TYPE_DIRECT)
6353 continue;
6354 ifindex = routes->table[n].dwForwardIfIndex;
6355 ifmetric = routes->table[n].dwForwardMetric1;
6356 /* Only store the lowest valued metric for an interface */
6357 for (j = 0; j < numroutes; j++)
6358 {
6359 if (route_addrs[j].interface == ifindex)
6360 {
6361 if (route_addrs[j].metric > ifmetric)
6362 route_addrs[j].metric = ifmetric;
6363 exists = TRUE;
6364 }
6365 }
6366 if (exists)
6367 continue;
6368 route_addrs = heap_realloc(route_addrs, (numroutes+1)*sizeof(struct route));
6369 if (route_addrs == NULL)
6370 goto cleanup; /* Memory allocation error, fail gracefully */
6371 route_addrs[numroutes].interface = ifindex;
6372 route_addrs[numroutes].metric = ifmetric;
6373 route_addrs[numroutes].default_route = ifdefault;
6374 /* If no IP is found in the next step (for whatever reason)
6375 * then fall back to the magic loopback address.
6376 */
6377 memcpy(&(route_addrs[numroutes].addr.s_addr), magic_loopback_addr, 4);
6378 numroutes++;
6379 }
6380 if (numroutes == 0)
6381 goto cleanup; /* No routes, fall back to the Magic IP */
6382 /* Find the IP address associated with each found interface */
6383 for (i = 0; i < numroutes; i++)
6384 {
6385 for (k = adapters; k != NULL; k = k->Next)
6386 {
6387 char *ip = k->IpAddressList.IpAddress.String;
6388
6389 if (route_addrs[i].interface == k->Index)
6390 route_addrs[i].addr.s_addr = (in_addr_t) inet_addr(ip);
6391 }
6392 }
6393 /* Allocate a hostent and enough memory for all the IPs,
6394 * including the NULL at the end of the list.
6395 */
6396 hostlist = WS_create_he(hostname, 1, 0, numroutes+1, sizeof(struct in_addr));
6397 if (hostlist == NULL)
6398 goto cleanup; /* Failed to allocate a hostent for the list of IPs */
6399 hostlist->h_addr_list[numroutes] = NULL; /* NULL-terminate the address list */
6400 hostlist->h_aliases[0] = NULL; /* NULL-terminate the alias list */
6401 hostlist->h_addrtype = AF_INET;
6402 hostlist->h_length = sizeof(struct in_addr); /* = 4 */
6403 /* Reorder the entries before placing them in the host list. Windows expects
6404 * the IP list in order from highest priority to lowest (the critical thing
6405 * is that most applications expect the first IP to be the default route).
6406 */
6407 if (numroutes > 1)
6408 qsort(route_addrs, numroutes, sizeof(struct route), WS_compare_routes_by_metric_asc);
6409
6410 for (i = 0; i < numroutes; i++)
6411 (*(struct in_addr *) hostlist->h_addr_list[i]) = route_addrs[i].addr;
6412
6413 /* Cleanup all allocated memory except the address list,
6414 * the address list is used by the calling app.
6415 */
6416 cleanup:
6417 HeapFree(GetProcessHeap(), 0, route_addrs);
6418 HeapFree(GetProcessHeap(), 0, adapters);
6419 HeapFree(GetProcessHeap(), 0, routes);
6420 return hostlist;
6421 }
6422
6423 /***********************************************************************
6424 * gethostbyname (WS2_32.52)
6425 */
6426 struct WS_hostent* WINAPI WS_gethostbyname(const char* name)
6427 {
6428 struct WS_hostent *retval = NULL;
6429 struct hostent* host;
6430 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
6431 char *extrabuf;
6432 int ebufsize=1024;
6433 struct hostent hostentry;
6434 int locerr = ENOBUFS;
6435 #endif
6436 char hostname[100];
6437 if(!num_startup) {
6438 SetLastError(WSANOTINITIALISED);
6439 return NULL;
6440 }
6441 if( gethostname( hostname, 100) == -1) {
6442 SetLastError(WSAENOBUFS); /* appropriate ? */
6443 return retval;
6444 }
6445 if( !name || !name[0]) {
6446 name = hostname;
6447 }
6448 /* If the hostname of the local machine is requested then return the
6449 * complete list of local IP addresses */
6450 if(strcmp(name, hostname) == 0)
6451 retval = WS_get_local_ips(hostname);
6452 /* If any other hostname was requested (or the routing table lookup failed)
6453 * then return the IP found by the host OS */
6454 if(retval == NULL)
6455 {
6456 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
6457 host = NULL;
6458 extrabuf=HeapAlloc(GetProcessHeap(),0,ebufsize) ;
6459 while(extrabuf) {
6460 int res = gethostbyname_r(name, &hostentry, extrabuf, ebufsize, &host, &locerr);
6461 if( res != ERANGE) break;
6462 ebufsize *=2;
6463 extrabuf=HeapReAlloc(GetProcessHeap(),0,extrabuf,ebufsize) ;
6464 }
6465 if (!host) SetLastError((locerr < 0) ? wsaErrno() : wsaHerrno(locerr));
6466 #else
6467 EnterCriticalSection( &csWSgetXXXbyYYY );
6468 host = gethostbyname(name);
6469 if (!host) SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno(h_errno));
6470 #endif
6471 if (host) retval = WS_dup_he(host);
6472 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
6473 HeapFree(GetProcessHeap(),0,extrabuf);
6474 #else
6475 LeaveCriticalSection( &csWSgetXXXbyYYY );
6476 #endif
6477 }
6478 if (retval && retval->h_addr_list[0][0] == 127 &&
6479 strcmp(name, "localhost") != 0)
6480 {
6481 /* hostname != "localhost" but has loopback address. replace by our
6482 * special address.*/
6483 memcpy(retval->h_addr_list[0], magic_loopback_addr, 4);
6484 }
6485 TRACE( "%s ret %p\n", debugstr_a(name), retval );
6486 return retval;
6487 }
6488
6489
6490 static const struct { int prot; const char *names[3]; } protocols[] =
6491 {
6492 { 0, { "ip", "IP" }},
6493 { 1, { "icmp", "ICMP" }},
6494 { 3, { "ggp", "GGP" }},
6495 { 6, { "tcp", "TCP" }},
6496 { 8, { "egp", "EGP" }},
6497 { 12, { "pup", "PUP" }},
6498 { 17, { "udp", "UDP" }},
6499 { 20, { "hmp", "HMP" }},
6500 { 22, { "xns-idp", "XNS-IDP" }},
6501 { 27, { "rdp", "RDP" }},
6502 { 41, { "ipv6", "IPv6" }},
6503 { 43, { "ipv6-route", "IPv6-Route" }},
6504 { 44, { "ipv6-frag", "IPv6-Frag" }},
6505 { 50, { "esp", "ESP" }},
6506 { 51, { "ah", "AH" }},
6507 { 58, { "ipv6-icmp", "IPv6-ICMP" }},
6508 { 59, { "ipv6-nonxt", "IPv6-NoNxt" }},
6509 { 60, { "ipv6-opts", "IPv6-Opts" }},
6510 { 66, { "rvd", "RVD" }},
6511 };
6512
6513 /***********************************************************************
6514 * getprotobyname (WS2_32.53)
6515 */
6516 struct WS_protoent* WINAPI WS_getprotobyname(const char* name)
6517 {
6518 struct WS_protoent* retval = NULL;
6519 unsigned int i;
6520
6521 for (i = 0; i < ARRAY_SIZE(protocols); i++)
6522 {
6523 if (_strnicmp( protocols[i].names[0], name, -1 )) continue;
6524 retval = WS_create_pe( protocols[i].names[0], (char **)protocols[i].names + 1,
6525 protocols[i].prot );
6526 break;
6527 }
6528 if (!retval)
6529 {
6530 WARN( "protocol %s not found\n", debugstr_a(name) );
6531 SetLastError(WSANO_DATA);
6532 }
6533 TRACE( "%s ret %p\n", debugstr_a(name), retval );
6534 return retval;
6535 }
6536
6537
6538 /***********************************************************************
6539 * getprotobynumber (WS2_32.54)
6540 */
6541 struct WS_protoent* WINAPI WS_getprotobynumber(int number)
6542 {
6543 struct WS_protoent* retval = NULL;
6544 unsigned int i;
6545
6546 for (i = 0; i < ARRAY_SIZE(protocols); i++)
6547 {
6548 if (protocols[i].prot != number) continue;
6549 retval = WS_create_pe( protocols[i].names[0], (char **)protocols[i].names + 1,
6550 protocols[i].prot );
6551 break;
6552 }
6553 if (!retval)
6554 {
6555 WARN( "protocol %d not found\n", number );
6556 SetLastError(WSANO_DATA);
6557 }
6558 TRACE("%i ret %p\n", number, retval);
6559 return retval;
6560 }
6561
6562
6563 /***********************************************************************
6564 * getservbyname (WS2_32.55)
6565 */
6566 struct WS_servent* WINAPI WS_getservbyname(const char *name, const char *proto)
6567 {
6568 struct WS_servent* retval = NULL;
6569 struct servent* serv;
6570 char *name_str;
6571 char *proto_str = NULL;
6572
6573 if (!(name_str = strdup_lower(name))) return NULL;
6574
6575 if (proto && *proto)
6576 {
6577 if (!(proto_str = strdup_lower(proto)))
6578 {
6579 HeapFree( GetProcessHeap(), 0, name_str );
6580 return NULL;
6581 }
6582 }
6583
6584 EnterCriticalSection( &csWSgetXXXbyYYY );
6585 serv = getservbyname(name_str, proto_str);
6586 if( serv != NULL )
6587 {
6588 retval = WS_dup_se(serv);
6589 }
6590 else SetLastError(WSANO_DATA);
6591 LeaveCriticalSection( &csWSgetXXXbyYYY );
6592 HeapFree( GetProcessHeap(), 0, proto_str );
6593 HeapFree( GetProcessHeap(), 0, name_str );
6594 TRACE( "%s, %s ret %p\n", debugstr_a(name), debugstr_a(proto), retval );
6595 return retval;
6596 }
6597
6598 /***********************************************************************
6599 * freeaddrinfo (WS2_32.@)
6600 */
6601 void WINAPI WS_freeaddrinfo(struct WS_addrinfo *res)
6602 {
6603 while (res) {
6604 struct WS_addrinfo *next;
6605
6606 HeapFree(GetProcessHeap(),0,res->ai_canonname);
6607 HeapFree(GetProcessHeap(),0,res->ai_addr);
6608 next = res->ai_next;
6609 HeapFree(GetProcessHeap(),0,res);
6610 res = next;
6611 }
6612 }
6613
6614 /* helper functions for getaddrinfo()/getnameinfo() */
6615 static int convert_aiflag_w2u(int winflags) {
6616 unsigned int i;
6617 int unixflags = 0;
6618
6619 for (i = 0; i < ARRAY_SIZE(ws_aiflag_map); i++)
6620 if (ws_aiflag_map[i][0] & winflags) {
6621 unixflags |= ws_aiflag_map[i][1];
6622 winflags &= ~ws_aiflag_map[i][0];
6623 }
6624 if (winflags)
6625 FIXME("Unhandled windows AI_xxx flags 0x%x\n", winflags);
6626 return unixflags;
6627 }
6628
6629 static int convert_niflag_w2u(int winflags) {
6630 unsigned int i;
6631 int unixflags = 0;
6632
6633 for (i = 0; i < ARRAY_SIZE(ws_niflag_map); i++)
6634 if (ws_niflag_map[i][0] & winflags) {
6635 unixflags |= ws_niflag_map[i][1];
6636 winflags &= ~ws_niflag_map[i][0];
6637 }
6638 if (winflags)
6639 FIXME("Unhandled windows NI_xxx flags 0x%x\n", winflags);
6640 return unixflags;
6641 }
6642
6643 static int convert_aiflag_u2w(int unixflags) {
6644 unsigned int i;
6645 int winflags = 0;
6646
6647 for (i = 0; i < ARRAY_SIZE(ws_aiflag_map); i++)
6648 if (ws_aiflag_map[i][1] & unixflags) {
6649 winflags |= ws_aiflag_map[i][0];
6650 unixflags &= ~ws_aiflag_map[i][1];
6651 }
6652 if (unixflags)
6653 WARN("Unhandled UNIX AI_xxx flags 0x%x\n", unixflags);
6654 return winflags;
6655 }
6656
6657 static int convert_eai_u2w(int unixret) {
6658 int i;
6659
6660 if (!unixret) return 0;
6661
6662 for (i=0;ws_eai_map[i][0];i++)
6663 if (ws_eai_map[i][1] == unixret)
6664 return ws_eai_map[i][0];
6665
6666 if (unixret == EAI_SYSTEM)
6667 /* There are broken versions of glibc which return EAI_SYSTEM
6668 * and set errno to 0 instead of returning EAI_NONAME.
6669 */
6670 return errno ? sock_get_error( errno ) : WS_EAI_NONAME;
6671
6672 FIXME("Unhandled unix EAI_xxx ret %d\n", unixret);
6673 return unixret;
6674 }
6675
6676 static char *get_fqdn(void)
6677 {
6678 char *ret;
6679 DWORD size = 0;
6680
6681 GetComputerNameExA( ComputerNamePhysicalDnsFullyQualified, NULL, &size );
6682 if (GetLastError() != ERROR_MORE_DATA) return NULL;
6683 if (!(ret = HeapAlloc( GetProcessHeap(), 0, size ))) return NULL;
6684 if (!GetComputerNameExA( ComputerNamePhysicalDnsFullyQualified, ret, &size ))
6685 {
6686 HeapFree( GetProcessHeap(), 0, ret );
6687 return NULL;
6688 }
6689 return ret;
6690 }
6691
6692 /***********************************************************************
6693 * getaddrinfo (WS2_32.@)
6694 */
6695 int WINAPI WS_getaddrinfo(LPCSTR nodename, LPCSTR servname, const struct WS_addrinfo *hints, struct WS_addrinfo **res)
6696 {
6697 #ifdef HAVE_GETADDRINFO
6698 struct addrinfo *unixaires = NULL;
6699 int result;
6700 struct addrinfo unixhints, *punixhints = NULL;
6701 char *dot, *nodeV6 = NULL, *fqdn;
6702 const char *node;
6703 size_t hostname_len = 0;
6704
6705 *res = NULL;
6706 if (!nodename && !servname)
6707 {
6708 SetLastError(WSAHOST_NOT_FOUND);
6709 return WSAHOST_NOT_FOUND;
6710 }
6711
6712 fqdn = get_fqdn();
6713 if (!fqdn) return WSA_NOT_ENOUGH_MEMORY;
6714 dot = strchr(fqdn, '.');
6715 if (dot)
6716 hostname_len = dot - fqdn;
6717
6718 if (!nodename)
6719 node = NULL;
6720 else if (!nodename[0])
6721 node = fqdn;
6722 else
6723 {
6724 node = nodename;
6725
6726 /* Check for [ipv6] or [ipv6]:portnumber, which are supported by Windows */
6727 if (!hints || hints->ai_family == WS_AF_UNSPEC || hints->ai_family == WS_AF_INET6)
6728 {
6729 char *close_bracket;
6730
6731 if (node[0] == '[' && (close_bracket = strchr(node + 1, ']')))
6732 {
6733 nodeV6 = HeapAlloc(GetProcessHeap(), 0, close_bracket - node);
6734 if (!nodeV6)
6735 {
6736 HeapFree(GetProcessHeap(), 0, fqdn);
6737 return WSA_NOT_ENOUGH_MEMORY;
6738 }
6739 lstrcpynA(nodeV6, node + 1, close_bracket - node);
6740 node = nodeV6;
6741 }
6742 }
6743 }
6744
6745 /* servname tweak required by OSX and BSD kernels */
6746 if (servname && !servname[0]) servname = "0";
6747
6748 if (hints) {
6749 punixhints = &unixhints;
6750
6751 memset(&unixhints, 0, sizeof(unixhints));
6752 punixhints->ai_flags = convert_aiflag_w2u(hints->ai_flags);
6753
6754 /* zero is a wildcard, no need to convert */
6755 if (hints->ai_family)
6756 punixhints->ai_family = convert_af_w2u(hints->ai_family);
6757 if (hints->ai_socktype)
6758 punixhints->ai_socktype = convert_socktype_w2u(hints->ai_socktype);
6759 if (hints->ai_protocol)
6760 punixhints->ai_protocol = max(convert_proto_w2u(hints->ai_protocol), 0);
6761
6762 if (punixhints->ai_socktype < 0)
6763 {
6764 SetLastError(WSAESOCKTNOSUPPORT);
6765 HeapFree(GetProcessHeap(), 0, fqdn);
6766 HeapFree(GetProcessHeap(), 0, nodeV6);
6767 return SOCKET_ERROR;
6768 }
6769
6770 /* windows allows invalid combinations of socket type and protocol, unix does not.
6771 * fix the parameters here to make getaddrinfo call always work */
6772 if (punixhints->ai_protocol == IPPROTO_TCP &&
6773 punixhints->ai_socktype != SOCK_STREAM && punixhints->ai_socktype != SOCK_SEQPACKET)
6774 punixhints->ai_socktype = 0;
6775
6776 else if (punixhints->ai_protocol == IPPROTO_UDP && punixhints->ai_socktype != SOCK_DGRAM)
6777 punixhints->ai_socktype = 0;
6778
6779 else if (IS_IPX_PROTO(punixhints->ai_protocol) && punixhints->ai_socktype != SOCK_DGRAM)
6780 punixhints->ai_socktype = 0;
6781
6782 else if (punixhints->ai_protocol == IPPROTO_IPV6)
6783 punixhints->ai_protocol = 0;
6784 }
6785
6786 /* getaddrinfo(3) is thread safe, no need to wrap in CS */
6787 result = getaddrinfo(node, servname, punixhints, &unixaires);
6788
6789 if (result && (!hints || !(hints->ai_flags & WS_AI_NUMERICHOST))
6790 && (!strcmp(fqdn, node) || (!strncmp(fqdn, node, hostname_len) && !node[hostname_len])))
6791 {
6792 /* If it didn't work it means the host name IP is not in /etc/hosts, try again
6793 * by sending a NULL host and avoid sending a NULL servname too because that
6794 * is invalid */
6795 ERR_(winediag)("Failed to resolve your host name IP\n");
6796 result = getaddrinfo(NULL, servname ? servname : "0", punixhints, &unixaires);
6797 }
6798 TRACE("%s, %s %p -> %p %d\n", debugstr_a(nodename), debugstr_a(servname), hints, res, result);
6799 HeapFree(GetProcessHeap(), 0, fqdn);
6800 HeapFree(GetProcessHeap(), 0, nodeV6);
6801
6802 if (!result) {
6803 struct addrinfo *xuai = unixaires;
6804 struct WS_addrinfo **xai = res;
6805
6806 *xai = NULL;
6807 while (xuai) {
6808 struct WS_addrinfo *ai = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(struct WS_addrinfo));
6809 SIZE_T len;
6810
6811 if (!ai)
6812 goto outofmem;
6813
6814 *xai = ai;xai = &ai->ai_next;
6815 ai->ai_flags = convert_aiflag_u2w(xuai->ai_flags);
6816 ai->ai_family = convert_af_u2w(xuai->ai_family);
6817 /* copy whatever was sent in the hints */
6818 if(hints) {
6819 ai->ai_socktype = hints->ai_socktype;
6820 ai->ai_protocol = hints->ai_protocol;
6821 } else {
6822 ai->ai_socktype = convert_socktype_u2w(xuai->ai_socktype);
6823 ai->ai_protocol = convert_proto_u2w(xuai->ai_protocol);
6824 }
6825 if (xuai->ai_canonname) {
6826 TRACE("canon name - %s\n",debugstr_a(xuai->ai_canonname));
6827 ai->ai_canonname = HeapAlloc(GetProcessHeap(),0,strlen(xuai->ai_canonname)+1);
6828 if (!ai->ai_canonname)
6829 goto outofmem;
6830 strcpy(ai->ai_canonname,xuai->ai_canonname);
6831 }
6832 len = xuai->ai_addrlen;
6833 ai->ai_addr = HeapAlloc(GetProcessHeap(),0,len);
6834 if (!ai->ai_addr)
6835 goto outofmem;
6836 ai->ai_addrlen = len;
6837 do {
6838 int winlen = ai->ai_addrlen;
6839
6840 if (!ws_sockaddr_u2ws(xuai->ai_addr, ai->ai_addr, &winlen)) {
6841 ai->ai_addrlen = winlen;
6842 break;
6843 }
6844 len = 2*len;
6845 ai->ai_addr = HeapReAlloc(GetProcessHeap(),0,ai->ai_addr,len);
6846 if (!ai->ai_addr)
6847 goto outofmem;
6848 ai->ai_addrlen = len;
6849 } while (1);
6850 xuai = xuai->ai_next;
6851 }
6852 freeaddrinfo(unixaires);
6853
6854 if (TRACE_ON(winsock))
6855 {
6856 struct WS_addrinfo *ai = *res;
6857 while (ai)
6858 {
6859 TRACE("=> %p, flags %#x, family %d, type %d, protocol %d, len %ld, name %s, addr %s\n",
6860 ai, ai->ai_flags, ai->ai_family, ai->ai_socktype, ai->ai_protocol, ai->ai_addrlen,
6861 ai->ai_canonname, debugstr_sockaddr(ai->ai_addr));
6862 ai = ai->ai_next;
6863 }
6864 }
6865 } else
6866 result = convert_eai_u2w(result);
6867
6868 SetLastError(result);
6869 return result;
6870
6871 outofmem:
6872 if (*res) WS_freeaddrinfo(*res);
6873 if (unixaires) freeaddrinfo(unixaires);
6874 return WSA_NOT_ENOUGH_MEMORY;
6875 #else
6876 FIXME("getaddrinfo() failed, not found during buildtime.\n");
6877 return EAI_FAIL;
6878 #endif
6879 }
6880
6881 static ADDRINFOEXW *addrinfo_AtoW(const struct WS_addrinfo *ai)
6882 {
6883 ADDRINFOEXW *ret;
6884
6885 if (!(ret = HeapAlloc(GetProcessHeap(), 0, sizeof(ADDRINFOEXW)))) return NULL;
6886 ret->ai_flags = ai->ai_flags;
6887 ret->ai_family = ai->ai_family;
6888 ret->ai_socktype = ai->ai_socktype;
6889 ret->ai_protocol = ai->ai_protocol;
6890 ret->ai_addrlen = ai->ai_addrlen;
6891 ret->ai_canonname = NULL;
6892 ret->ai_addr = NULL;
6893 ret->ai_blob = NULL;
6894 ret->ai_bloblen = 0;
6895 ret->ai_provider = NULL;
6896 ret->ai_next = NULL;
6897 if (ai->ai_canonname)
6898 {
6899 int len = MultiByteToWideChar(CP_ACP, 0, ai->ai_canonname, -1, NULL, 0);
6900 if (!(ret->ai_canonname = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR))))
6901 {
6902 HeapFree(GetProcessHeap(), 0, ret);
6903 return NULL;
6904 }
6905 MultiByteToWideChar(CP_ACP, 0, ai->ai_canonname, -1, ret->ai_canonname, len);
6906 }
6907 if (ai->ai_addr)
6908 {
6909 if (!(ret->ai_addr = HeapAlloc(GetProcessHeap(), 0, ai->ai_addrlen)))
6910 {
6911 HeapFree(GetProcessHeap(), 0, ret->ai_canonname);
6912 HeapFree(GetProcessHeap(), 0, ret);
6913 return NULL;
6914 }
6915 memcpy(ret->ai_addr, ai->ai_addr, ai->ai_addrlen);
6916 }
6917 return ret;
6918 }
6919
6920 static ADDRINFOEXW *addrinfo_list_AtoW(const struct WS_addrinfo *info)
6921 {
6922 ADDRINFOEXW *ret, *infoW;
6923
6924 if (!(ret = infoW = addrinfo_AtoW(info))) return NULL;
6925 while (info->ai_next)
6926 {
6927 if (!(infoW->ai_next = addrinfo_AtoW(info->ai_next)))
6928 {
6929 FreeAddrInfoExW(ret);
6930 return NULL;
6931 }
6932 infoW = infoW->ai_next;
6933 info = info->ai_next;
6934 }
6935 return ret;
6936 }
6937
6938 static struct WS_addrinfo *addrinfo_WtoA(const struct WS_addrinfoW *ai)
6939 {
6940 struct WS_addrinfo *ret;
6941
6942 if (!(ret = HeapAlloc(GetProcessHeap(), 0, sizeof(struct WS_addrinfo)))) return NULL;
6943 ret->ai_flags = ai->ai_flags;
6944 ret->ai_family = ai->ai_family;
6945 ret->ai_socktype = ai->ai_socktype;
6946 ret->ai_protocol = ai->ai_protocol;
6947 ret->ai_addrlen = ai->ai_addrlen;
6948 ret->ai_canonname = NULL;
6949 ret->ai_addr = NULL;
6950 ret->ai_next = NULL;
6951 if (ai->ai_canonname)
6952 {
6953 int len = WideCharToMultiByte(CP_ACP, 0, ai->ai_canonname, -1, NULL, 0, NULL, NULL);
6954 if (!(ret->ai_canonname = HeapAlloc(GetProcessHeap(), 0, len)))
6955 {
6956 HeapFree(GetProcessHeap(), 0, ret);
6957 return NULL;
6958 }
6959 WideCharToMultiByte(CP_ACP, 0, ai->ai_canonname, -1, ret->ai_canonname, len, NULL, NULL);
6960 }
6961 if (ai->ai_addr)
6962 {
6963 if (!(ret->ai_addr = HeapAlloc(GetProcessHeap(), 0, sizeof(struct WS_sockaddr))))
6964 {
6965 HeapFree(GetProcessHeap(), 0, ret->ai_canonname);
6966 HeapFree(GetProcessHeap(), 0, ret);
6967 return NULL;
6968 }
6969 memcpy(ret->ai_addr, ai->ai_addr, sizeof(struct WS_sockaddr));
6970 }
6971 return ret;
6972 }
6973
6974 struct getaddrinfo_args
6975 {
6976 OVERLAPPED *overlapped;
6977 LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine;
6978 ADDRINFOEXW **result;
6979 char *nodename;
6980 char *servname;
6981 };
6982
6983 static void WINAPI getaddrinfo_callback(TP_CALLBACK_INSTANCE *instance, void *context)
6984 {
6985 struct getaddrinfo_args *args = context;
6986 OVERLAPPED *overlapped = args->overlapped;
6987 HANDLE event = overlapped->hEvent;
6988 LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine = args->completion_routine;
6989 struct WS_addrinfo *res;
6990 int ret;
6991
6992 ret = WS_getaddrinfo(args->nodename, args->servname, NULL, &res);
6993 if (res)
6994 {
6995 *args->result = addrinfo_list_AtoW(res);
6996 overlapped->u.Pointer = args->result;
6997 WS_freeaddrinfo(res);
6998 }
6999
7000 HeapFree(GetProcessHeap(), 0, args->nodename);
7001 HeapFree(GetProcessHeap(), 0, args->servname);
7002 HeapFree(GetProcessHeap(), 0, args);
7003
7004 overlapped->Internal = ret;
7005 if (completion_routine) completion_routine(ret, 0, overlapped);
7006 if (event) SetEvent(event);
7007 }
7008
7009 static int WS_getaddrinfoW(const WCHAR *nodename, const WCHAR *servname, const struct WS_addrinfo *hints, ADDRINFOEXW **res,
7010 OVERLAPPED *overlapped, LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine)
7011 {
7012 int ret = EAI_MEMORY, len, i;
7013 char *nodenameA = NULL, *servnameA = NULL;
7014 struct WS_addrinfo *resA;
7015 WCHAR *local_nodenameW = (WCHAR *)nodename;
7016
7017 *res = NULL;
7018 if (nodename)
7019 {
7020 /* Is this an IDN? Most likely if any char is above the Ascii table, this
7021 * is the simplest validation possible, further validation will be done by
7022 * the native getaddrinfo() */
7023 for (i = 0; nodename[i]; i++)
7024 {
7025 if (nodename[i] > 'z')
7026 break;
7027 }
7028 if (nodename[i])
7029 {
7030 if (hints && (hints->ai_flags & WS_AI_DISABLE_IDN_ENCODING))
7031 {
7032 /* Name requires conversion but it was disabled */
7033 ret = WSAHOST_NOT_FOUND;
7034 WSASetLastError(ret);
7035 goto end;
7036 }
7037
7038 len = IdnToAscii(0, nodename, -1, NULL, 0);
7039 if (!len)
7040 {
7041 ERR("Failed to convert %s to punycode\n", debugstr_w(nodename));
7042 ret = EAI_FAIL;
7043 goto end;
7044 }
7045 if (!(local_nodenameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)))) goto end;
7046 IdnToAscii(0, nodename, -1, local_nodenameW, len);
7047 }
7048 }
7049 if (local_nodenameW)
7050 {
7051 len = WideCharToMultiByte(CP_ACP, 0, local_nodenameW, -1, NULL, 0, NULL, NULL);
7052 if (!(nodenameA = HeapAlloc(GetProcessHeap(), 0, len))) goto end;
7053 WideCharToMultiByte(CP_ACP, 0, local_nodenameW, -1, nodenameA, len, NULL, NULL);
7054 }
7055 if (servname)
7056 {
7057 len = WideCharToMultiByte(CP_ACP, 0, servname, -1, NULL, 0, NULL, NULL);
7058 if (!(servnameA = HeapAlloc(GetProcessHeap(), 0, len))) goto end;
7059 WideCharToMultiByte(CP_ACP, 0, servname, -1, servnameA, len, NULL, NULL);
7060 }
7061
7062 if (overlapped)
7063 {
7064 struct getaddrinfo_args *args;
7065
7066 if (overlapped->hEvent && completion_routine)
7067 {
7068 ret = WSAEINVAL;
7069 goto end;
7070 }
7071
7072 if (!(args = HeapAlloc(GetProcessHeap(), 0, sizeof(*args)))) goto end;
7073 args->overlapped = overlapped;
7074 args->completion_routine = completion_routine;
7075 args->result = res;
7076 args->nodename = nodenameA;
7077 args->servname = servnameA;
7078
7079 overlapped->Internal = WSAEINPROGRESS;
7080 if (!TrySubmitThreadpoolCallback(getaddrinfo_callback, args, NULL))
7081 {
7082 HeapFree(GetProcessHeap(), 0, args);
7083 ret = GetLastError();
7084 goto end;
7085 }
7086
7087 if (local_nodenameW != nodename)
7088 HeapFree(GetProcessHeap(), 0, local_nodenameW);
7089 WSASetLastError(ERROR_IO_PENDING);
7090 return ERROR_IO_PENDING;
7091 }
7092
7093 ret = WS_getaddrinfo(nodenameA, servnameA, hints, &resA);
7094 if (!ret)
7095 {
7096 *res = addrinfo_list_AtoW(resA);
7097 WS_freeaddrinfo(resA);
7098 }
7099
7100 end:
7101 if (local_nodenameW != nodename)
7102 HeapFree(GetProcessHeap(), 0, local_nodenameW);
7103 HeapFree(GetProcessHeap(), 0, nodenameA);
7104 HeapFree(GetProcessHeap(), 0, servnameA);
7105 return ret;
7106 }
7107
7108 /***********************************************************************
7109 * GetAddrInfoExW (WS2_32.@)
7110 */
7111 int WINAPI GetAddrInfoExW(const WCHAR *name, const WCHAR *servname, DWORD namespace, GUID *namespace_id,
7112 const ADDRINFOEXW *hints, ADDRINFOEXW **result, struct WS_timeval *timeout, OVERLAPPED *overlapped,
7113 LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine, HANDLE *handle)
7114 {
7115 int ret;
7116
7117 TRACE("(%s %s %x %s %p %p %p %p %p %p)\n", debugstr_w(name), debugstr_w(servname), namespace,
7118 debugstr_guid(namespace_id), hints, result, timeout, overlapped, completion_routine, handle);
7119
7120 if (namespace != NS_DNS)
7121 FIXME("Unsupported namespace %u\n", namespace);
7122 if (namespace_id)
7123 FIXME("Unsupported naemspace_id %s\n", debugstr_guid(namespace_id));
7124 if (hints)
7125 FIXME("Unsupported hints\n");
7126 if (timeout)
7127 FIXME("Unsupported timeout\n");
7128 if (handle)
7129 FIXME("Unsupported cancel handle\n");
7130
7131 ret = WS_getaddrinfoW(name, servname, NULL, result, overlapped, completion_routine);
7132 if (ret) return ret;
7133 if (handle) *handle = (HANDLE)0xdeadbeef;
7134 return 0;
7135 }
7136
7137 /***********************************************************************
7138 * GetAddrInfoExOverlappedResult (WS2_32.@)
7139 */
7140 int WINAPI GetAddrInfoExOverlappedResult(OVERLAPPED *overlapped)
7141 {
7142 TRACE("(%p)\n", overlapped);
7143 return overlapped->Internal;
7144 }
7145
7146 /***********************************************************************
7147 * GetAddrInfoExCancel (WS2_32.@)
7148 */
7149 int WINAPI GetAddrInfoExCancel(HANDLE *handle)
7150 {
7151 FIXME("(%p)\n", handle);
7152 return WSA_INVALID_HANDLE;
7153 }
7154
7155 /***********************************************************************
7156 * GetAddrInfoW (WS2_32.@)
7157 */
7158 int WINAPI GetAddrInfoW(LPCWSTR nodename, LPCWSTR servname, const ADDRINFOW *hints, PADDRINFOW *res)
7159 {
7160 struct WS_addrinfo *hintsA = NULL;
7161 ADDRINFOEXW *resex;
7162 int ret = EAI_MEMORY;
7163
7164 TRACE("nodename %s, servname %s, hints %p, result %p\n",
7165 debugstr_w(nodename), debugstr_w(servname), hints, res);
7166
7167 *res = NULL;
7168 if (hints) hintsA = addrinfo_WtoA(hints);
7169 ret = WS_getaddrinfoW(nodename, servname, hintsA, &resex, NULL, NULL);
7170 WS_freeaddrinfo(hintsA);
7171 if (ret) return ret;
7172
7173 if (resex)
7174 {
7175 /* ADDRINFOEXW has layout compatible with ADDRINFOW except for ai_next field,
7176 * so we may convert it in place */
7177 *res = (ADDRINFOW*)resex;
7178 do {
7179 ((ADDRINFOW*)resex)->ai_next = (ADDRINFOW*)resex->ai_next;
7180 resex = resex->ai_next;
7181 } while (resex);
7182 }
7183 return 0;
7184 }
7185
7186 /***********************************************************************
7187 * FreeAddrInfoW (WS2_32.@)
7188 */
7189 void WINAPI FreeAddrInfoW(PADDRINFOW ai)
7190 {
7191 while (ai)
7192 {
7193 ADDRINFOW *next;
7194 HeapFree(GetProcessHeap(), 0, ai->ai_canonname);
7195 HeapFree(GetProcessHeap(), 0, ai->ai_addr);
7196 next = ai->ai_next;
7197 HeapFree(GetProcessHeap(), 0, ai);
7198 ai = next;
7199 }
7200 }
7201
7202 /***********************************************************************
7203 * FreeAddrInfoEx (WS2_32.@)
7204 */
7205 void WINAPI FreeAddrInfoEx(ADDRINFOEXA *ai)
7206 {
7207 TRACE("(%p)\n", ai);
7208
7209 while (ai)
7210 {
7211 ADDRINFOEXA *next;
7212 HeapFree(GetProcessHeap(), 0, ai->ai_canonname);
7213 HeapFree(GetProcessHeap(), 0, ai->ai_addr);
7214 next = ai->ai_next;
7215 HeapFree(GetProcessHeap(), 0, ai);
7216 ai = next;
7217 }
7218 }
7219
7220 /***********************************************************************
7221 * FreeAddrInfoExW (WS2_32.@)
7222 */
7223 void WINAPI FreeAddrInfoExW(ADDRINFOEXW *ai)
7224 {
7225 TRACE("(%p)\n", ai);
7226
7227 while (ai)
7228 {
7229 ADDRINFOEXW *next;
7230 HeapFree(GetProcessHeap(), 0, ai->ai_canonname);
7231 HeapFree(GetProcessHeap(), 0, ai->ai_addr);
7232 next = ai->ai_next;
7233 HeapFree(GetProcessHeap(), 0, ai);
7234 ai = next;
7235 }
7236 }
7237
7238 int WINAPI WS_getnameinfo(const SOCKADDR *sa, WS_socklen_t salen, PCHAR host,
7239 DWORD hostlen, PCHAR serv, DWORD servlen, INT flags)
7240 {
7241 #ifdef HAVE_GETNAMEINFO
7242 int ret;
7243 union generic_unix_sockaddr sa_u;
7244 unsigned int size;
7245
7246 TRACE("%s %d %p %d %p %d %d\n", debugstr_sockaddr(sa), salen, host, hostlen,
7247 serv, servlen, flags);
7248
7249 size = ws_sockaddr_ws2u(sa, salen, &sa_u);
7250 if (!size)
7251 {
7252 SetLastError(WSAEFAULT);
7253 return WSA_NOT_ENOUGH_MEMORY;
7254 }
7255 ret = getnameinfo(&sa_u.addr, size, host, hostlen, serv, servlen, convert_niflag_w2u(flags));
7256 return convert_eai_u2w(ret);
7257 #else
7258 FIXME("getnameinfo() failed, not found during buildtime.\n");
7259 return EAI_FAIL;
7260 #endif
7261 }
7262
7263 int WINAPI GetNameInfoW(const SOCKADDR *sa, WS_socklen_t salen, PWCHAR host,
7264 DWORD hostlen, PWCHAR serv, DWORD servlen, INT flags)
7265 {
7266 int ret;
7267 char *hostA = NULL, *servA = NULL;
7268
7269 if (host && (!(hostA = HeapAlloc(GetProcessHeap(), 0, hostlen)))) return EAI_MEMORY;
7270 if (serv && (!(servA = HeapAlloc(GetProcessHeap(), 0, servlen))))
7271 {
7272 HeapFree(GetProcessHeap(), 0, hostA);
7273 return EAI_MEMORY;
7274 }
7275
7276 ret = WS_getnameinfo(sa, salen, hostA, hostlen, servA, servlen, flags);
7277 if (!ret)
7278 {
7279 if (host) MultiByteToWideChar(CP_ACP, 0, hostA, -1, host, hostlen);
7280 if (serv) MultiByteToWideChar(CP_ACP, 0, servA, -1, serv, servlen);
7281 }
7282
7283 HeapFree(GetProcessHeap(), 0, hostA);
7284 HeapFree(GetProcessHeap(), 0, servA);
7285 return ret;
7286 }
7287
7288 /***********************************************************************
7289 * getservbyport (WS2_32.56)
7290 */
7291 struct WS_servent* WINAPI WS_getservbyport(int port, const char *proto)
7292 {
7293 struct WS_servent* retval = NULL;
7294 #ifdef HAVE_GETSERVBYPORT
7295 struct servent* serv;
7296 char *proto_str = NULL;
7297
7298 if (proto && *proto)
7299 {
7300 if (!(proto_str = strdup_lower(proto))) return NULL;
7301 }
7302 EnterCriticalSection( &csWSgetXXXbyYYY );
7303 if( (serv = getservbyport(port, proto_str)) != NULL ) {
7304 retval = WS_dup_se(serv);
7305 }
7306 else SetLastError(WSANO_DATA);
7307 LeaveCriticalSection( &csWSgetXXXbyYYY );
7308 HeapFree( GetProcessHeap(), 0, proto_str );
7309 #endif
7310 TRACE("%d (i.e. port %d), %s ret %p\n", port, (int)ntohl(port), debugstr_a(proto), retval);
7311 return retval;
7312 }
7313
7314
7315 /***********************************************************************
7316 * gethostname (WS2_32.57)
7317 */
7318 int WINAPI WS_gethostname(char *name, int namelen)
7319 {
7320 char buf[256];
7321 int len;
7322
7323 TRACE("name %p, len %d\n", name, namelen);
7324
7325 if (!name)
7326 {
7327 SetLastError(WSAEFAULT);
7328 return SOCKET_ERROR;
7329 }
7330
7331 if (gethostname(buf, sizeof(buf)) != 0)
7332 {
7333 SetLastError(wsaErrno());
7334 return SOCKET_ERROR;
7335 }
7336
7337 TRACE("<- '%s'\n", buf);
7338 len = strlen(buf);
7339 if (len > 15)
7340 WARN("Windows supports NetBIOS name length up to 15 bytes!\n");
7341 if (namelen <= len)
7342 {
7343 SetLastError(WSAEFAULT);
7344 WARN("<- not enough space for hostname, required %d, got %d!\n", len + 1, namelen);
7345 return SOCKET_ERROR;
7346 }
7347 strcpy(name, buf);
7348 return 0;
7349 }
7350
7351
7352 /* ------------------------------------- Windows sockets extensions -- *
7353 * *
7354 * ------------------------------------------------------------------- */
7355
7356 /***********************************************************************
7357 * WSAEnumNetworkEvents (WS2_32.36)
7358 */
7359 int WINAPI WSAEnumNetworkEvents(SOCKET s, WSAEVENT hEvent, LPWSANETWORKEVENTS lpEvent)
7360 {
7361 int ret;
7362 int i;
7363 int errors[FD_MAX_EVENTS];
7364
7365 TRACE("%04lx, hEvent %p, lpEvent %p\n", s, hEvent, lpEvent );
7366
7367 SERVER_START_REQ( get_socket_event )
7368 {
7369 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
7370 req->service = TRUE;
7371 req->c_event = wine_server_obj_handle( hEvent );
7372 wine_server_set_reply( req, errors, sizeof(errors) );
7373 if (!(ret = wine_server_call(req))) lpEvent->lNetworkEvents = reply->pmask & reply->mask;
7374 }
7375 SERVER_END_REQ;
7376 if (!ret)
7377 {
7378 for (i = 0; i < FD_MAX_EVENTS; i++)
7379 {
7380 if (lpEvent->lNetworkEvents & (1 << i))
7381 lpEvent->iErrorCode[i] = errors[i];
7382 }
7383 return 0;
7384 }
7385 SetLastError(WSAEINVAL);
7386 return SOCKET_ERROR;
7387 }
7388
7389 /***********************************************************************
7390 * WSAEventSelect (WS2_32.39)
7391 */
7392 int WINAPI WSAEventSelect(SOCKET s, WSAEVENT hEvent, LONG lEvent)
7393 {
7394 int ret;
7395
7396 TRACE("%04lx, hEvent %p, event %08x\n", s, hEvent, lEvent);
7397
7398 SERVER_START_REQ( set_socket_event )
7399 {
7400 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
7401 req->mask = lEvent;
7402 req->event = wine_server_obj_handle( hEvent );
7403 req->window = 0;
7404 req->msg = 0;
7405 ret = wine_server_call( req );
7406 }
7407 SERVER_END_REQ;
7408 if (!ret) return 0;
7409 SetLastError(WSAEINVAL);
7410 return SOCKET_ERROR;
7411 }
7412
7413 /**********************************************************************
7414 * WSAGetOverlappedResult (WS2_32.40)
7415 */
7416 BOOL WINAPI WSAGetOverlappedResult( SOCKET s, LPWSAOVERLAPPED lpOverlapped,
7417 LPDWORD lpcbTransfer, BOOL fWait,
7418 LPDWORD lpdwFlags )
7419 {
7420 NTSTATUS status;
7421
7422 TRACE( "socket %04lx ovl %p trans %p, wait %d flags %p\n",
7423 s, lpOverlapped, lpcbTransfer, fWait, lpdwFlags );
7424
7425 if ( lpOverlapped == NULL )
7426 {
7427 ERR( "Invalid pointer\n" );
7428 SetLastError(WSA_INVALID_PARAMETER);
7429 return FALSE;
7430 }
7431
7432 status = lpOverlapped->Internal;
7433 if (status == STATUS_PENDING)
7434 {
7435 if (!fWait)
7436 {
7437 SetLastError( WSA_IO_INCOMPLETE );
7438 return FALSE;
7439 }
7440
7441 if (WaitForSingleObject( lpOverlapped->hEvent ? lpOverlapped->hEvent : SOCKET2HANDLE(s),
7442 INFINITE ) == WAIT_FAILED)
7443 return FALSE;
7444 status = lpOverlapped->Internal;
7445 }
7446
7447 if ( lpcbTransfer )
7448 *lpcbTransfer = lpOverlapped->InternalHigh;
7449
7450 if ( lpdwFlags )
7451 *lpdwFlags = lpOverlapped->u.s.Offset;
7452
7453 if (status) SetLastError( RtlNtStatusToDosError(status) );
7454 return !status;
7455 }
7456
7457
7458 /***********************************************************************
7459 * WSAAsyncSelect (WS2_32.101)
7460 */
7461 INT WINAPI WSAAsyncSelect(SOCKET s, HWND hWnd, UINT uMsg, LONG lEvent)
7462 {
7463 int ret;
7464
7465 TRACE("%04lx, hWnd %p, uMsg %08x, event %08x\n", s, hWnd, uMsg, lEvent);
7466
7467 SERVER_START_REQ( set_socket_event )
7468 {
7469 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
7470 req->mask = lEvent;
7471 req->event = 0;
7472 req->window = wine_server_user_handle( hWnd );
7473 req->msg = uMsg;
7474 ret = wine_server_call( req );
7475 }
7476 SERVER_END_REQ;
7477 if (!ret) return 0;
7478 SetLastError(WSAEINVAL);
7479 return SOCKET_ERROR;
7480 }
7481
7482 /***********************************************************************
7483 * WSACreateEvent (WS2_32.31)
7484 *
7485 */
7486 WSAEVENT WINAPI WSACreateEvent(void)
7487 {
7488 /* Create a manual-reset event, with initial state: unsignaled */
7489 TRACE("\n");
7490
7491 return CreateEventW(NULL, TRUE, FALSE, NULL);
7492 }
7493
7494 /***********************************************************************
7495 * WSACloseEvent (WS2_32.29)
7496 *
7497 */
7498 BOOL WINAPI WSACloseEvent(WSAEVENT event)
7499 {
7500 TRACE ("event=%p\n", event);
7501
7502 return CloseHandle(event);
7503 }
7504
7505 /***********************************************************************
7506 * WSASocketA (WS2_32.78)
7507 *
7508 */
7509 SOCKET WINAPI WSASocketA(int af, int type, int protocol,
7510 LPWSAPROTOCOL_INFOA lpProtocolInfo,
7511 GROUP g, DWORD dwFlags)
7512 {
7513 INT len;
7514 WSAPROTOCOL_INFOW info;
7515
7516 TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%x\n",
7517 af, type, protocol, lpProtocolInfo, g, dwFlags);
7518
7519 if (!lpProtocolInfo) return WSASocketW(af, type, protocol, NULL, g, dwFlags);
7520
7521 memcpy(&info, lpProtocolInfo, FIELD_OFFSET(WSAPROTOCOL_INFOW, szProtocol));
7522 len = MultiByteToWideChar(CP_ACP, 0, lpProtocolInfo->szProtocol, -1,
7523 info.szProtocol, WSAPROTOCOL_LEN + 1);
7524
7525 if (!len)
7526 {
7527 SetLastError(WSAEINVAL);
7528 return SOCKET_ERROR;
7529 }
7530
7531 return WSASocketW(af, type, protocol, &info, g, dwFlags);
7532 }
7533
7534 /***********************************************************************
7535 * WSASocketW (WS2_32.79)
7536 *
7537 */
7538 SOCKET WINAPI WSASocketW(int af, int type, int protocol,
7539 LPWSAPROTOCOL_INFOW lpProtocolInfo,
7540 GROUP g, DWORD dwFlags)
7541 {
7542 SOCKET ret;
7543 DWORD err;
7544 int unixaf, unixtype, ipxptype = -1;
7545
7546 /*
7547 FIXME: The "advanced" parameters of WSASocketW (lpProtocolInfo,
7548 g, dwFlags except WSA_FLAG_OVERLAPPED) are ignored.
7549 */
7550
7551 TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%x\n",
7552 af, type, protocol, lpProtocolInfo, g, dwFlags );
7553
7554 if (!num_startup)
7555 {
7556 err = WSANOTINITIALISED;
7557 goto done;
7558 }
7559
7560 /* hack for WSADuplicateSocket */
7561 if (lpProtocolInfo && lpProtocolInfo->dwServiceFlags4 == 0xff00ff00) {
7562 ret = lpProtocolInfo->dwServiceFlags3;
7563 TRACE("\tgot duplicate %04lx\n", ret);
7564 return ret;
7565 }
7566
7567 if (lpProtocolInfo)
7568 {
7569 if (af == FROM_PROTOCOL_INFO || !af)
7570 af = lpProtocolInfo->iAddressFamily;
7571 if (type == FROM_PROTOCOL_INFO || !type)
7572 type = lpProtocolInfo->iSocketType;
7573 if (protocol == FROM_PROTOCOL_INFO || !protocol)
7574 protocol = lpProtocolInfo->iProtocol;
7575 }
7576
7577 if (!type && (af || protocol))
7578 {
7579 int autoproto = protocol;
7580 WSAPROTOCOL_INFOW infow;
7581
7582 /* default to the first valid protocol */
7583 if (!autoproto)
7584 autoproto = valid_protocols[0];
7585 else if(IS_IPX_PROTO(autoproto))
7586 autoproto = WS_NSPROTO_IPX;
7587
7588 if (WS_EnterSingleProtocolW(autoproto, &infow))
7589 {
7590 type = infow.iSocketType;
7591
7592 /* after win2003 it's no longer possible to pass AF_UNSPEC
7593 using the protocol info struct */
7594 if (!lpProtocolInfo && af == WS_AF_UNSPEC)
7595 af = infow.iAddressFamily;
7596 }
7597 }
7598
7599 /*
7600 Windows has an extension to the IPX protocol that allows one to create sockets
7601 and set the IPX packet type at the same time, to do that a caller will use
7602 a protocol like NSPROTO_IPX + <PACKET TYPE>
7603 */
7604 if (IS_IPX_PROTO(protocol))
7605 ipxptype = protocol - WS_NSPROTO_IPX;
7606
7607 /* convert the socket family, type and protocol */
7608 unixaf = convert_af_w2u(af);
7609 unixtype = convert_socktype_w2u(type);
7610 protocol = convert_proto_w2u(protocol);
7611 if (unixaf == AF_UNSPEC) unixaf = -1;
7612
7613 /* filter invalid parameters */
7614 if (protocol < 0)
7615 {
7616 /* the type could not be converted */
7617 if (type && unixtype < 0)
7618 {
7619 err = WSAESOCKTNOSUPPORT;
7620 goto done;
7621 }
7622
7623 err = WSAEPROTONOSUPPORT;
7624 goto done;
7625 }
7626 if (unixaf < 0)
7627 {
7628 /* both family and protocol can't be invalid */
7629 if (protocol <= 0)
7630 {
7631 err = WSAEINVAL;
7632 goto done;
7633 }
7634
7635 /* family could not be converted and neither socket type */
7636 if (unixtype < 0 && af >= 0)
7637 {
7638
7639 err = WSAESOCKTNOSUPPORT;
7640 goto done;
7641 }
7642
7643 err = WSAEAFNOSUPPORT;
7644 goto done;
7645 }
7646
7647 SERVER_START_REQ( create_socket )
7648 {
7649 req->family = unixaf;
7650 req->type = unixtype;
7651 req->protocol = protocol;
7652 req->access = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
7653 req->attributes = (dwFlags & WSA_FLAG_NO_HANDLE_INHERIT) ? 0 : OBJ_INHERIT;
7654 req->flags = dwFlags & ~WSA_FLAG_NO_HANDLE_INHERIT;
7655 err = NtStatusToWSAError( wine_server_call( req ) );
7656 ret = HANDLE2SOCKET( wine_server_ptr_handle( reply->handle ));
7657 }
7658 SERVER_END_REQ;
7659 if (ret)
7660 {
7661 TRACE("\tcreated %04lx\n", ret );
7662 if (ipxptype > 0)
7663 set_ipx_packettype(ret, ipxptype);
7664
7665 if (unixaf == AF_INET || unixaf == AF_INET6)
7666 {
7667 /* ensure IP_DONTFRAGMENT is disabled for SOCK_DGRAM and SOCK_RAW, enabled for SOCK_STREAM */
7668 if (unixtype == SOCK_DGRAM || unixtype == SOCK_RAW) /* in Linux the global default can be enabled */
7669 set_dont_fragment(ret, unixaf == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP, FALSE);
7670 else if (unixtype == SOCK_STREAM)
7671 set_dont_fragment(ret, unixaf == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP, TRUE);
7672 }
7673
7674 #ifdef IPV6_V6ONLY
7675 if (unixaf == AF_INET6)
7676 {
7677 int fd = get_sock_fd(ret, 0, NULL);
7678 if (fd != -1)
7679 {
7680 /* IPV6_V6ONLY is set by default on Windows */
7681 int enable = 1;
7682 if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &enable, sizeof(enable)))
7683 WARN("\tsetting IPV6_V6ONLY failed - errno = %i\n", errno);
7684 release_sock_fd(ret, fd);
7685 }
7686 }
7687 #endif
7688 return ret;
7689 }
7690
7691 if (err == WSAEACCES) /* raw socket denied */
7692 {
7693 if (type == SOCK_RAW)
7694 ERR_(winediag)("Failed to create a socket of type SOCK_RAW, this requires special permissions.\n");
7695 else
7696 ERR_(winediag)("Failed to create socket, this requires special permissions.\n");
7697 }
7698
7699 done:
7700 WARN("\t\tfailed, error %d!\n", err);
7701 SetLastError(err);
7702 return INVALID_SOCKET;
7703 }
7704
7705 /***********************************************************************
7706 * WSAJoinLeaf (WS2_32.58)
7707 *
7708 */
7709 SOCKET WINAPI WSAJoinLeaf(
7710 SOCKET s,
7711 const struct WS_sockaddr *addr,
7712 int addrlen,
7713 LPWSABUF lpCallerData,
7714 LPWSABUF lpCalleeData,
7715 LPQOS lpSQOS,
7716 LPQOS lpGQOS,
7717 DWORD dwFlags)
7718 {
7719 FIXME("stub.\n");
7720 return INVALID_SOCKET;
7721 }
7722
7723 /***********************************************************************
7724 * __WSAFDIsSet (WS2_32.151)
7725 */
7726 int WINAPI __WSAFDIsSet(SOCKET s, WS_fd_set *set)
7727 {
7728 int i = set->fd_count, ret = 0;
7729
7730 while (i--)
7731 if (set->fd_array[i] == s)
7732 {
7733 ret = 1;
7734 break;
7735 }
7736
7737 TRACE("(socket %04lx, fd_set %p, count %i) <- %d\n", s, set, set->fd_count, ret);
7738 return ret;
7739 }
7740
7741 /***********************************************************************
7742 * WSAIsBlocking (WS2_32.114)
7743 */
7744 BOOL WINAPI WSAIsBlocking(void)
7745 {
7746 /* By default WinSock should set all its sockets to non-blocking mode
7747 * and poll in PeekMessage loop when processing "blocking" ones. This
7748 * function is supposed to tell if the program is in this loop. Our
7749 * blocking calls are truly blocking so we always return FALSE.
7750 *
7751 * Note: It is allowed to call this function without prior WSAStartup().
7752 */
7753
7754 TRACE("\n");
7755 return FALSE;
7756 }
7757
7758 /***********************************************************************
7759 * WSACancelBlockingCall (WS2_32.113)
7760 */
7761 INT WINAPI WSACancelBlockingCall(void)
7762 {
7763 TRACE("\n");
7764 return 0;
7765 }
7766
7767 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x )
7768 {
7769 FIXME("How was this called?\n");
7770 return x();
7771 }
7772
7773
7774 /***********************************************************************
7775 * WSASetBlockingHook (WS2_32.109)
7776 */
7777 FARPROC WINAPI WSASetBlockingHook(FARPROC lpBlockFunc)
7778 {
7779 FARPROC prev = blocking_hook;
7780 blocking_hook = lpBlockFunc;
7781 TRACE("hook %p\n", lpBlockFunc);
7782 return prev;
7783 }
7784
7785
7786 /***********************************************************************
7787 * WSAUnhookBlockingHook (WS2_32.110)
7788 */
7789 INT WINAPI WSAUnhookBlockingHook(void)
7790 {
7791 blocking_hook = (FARPROC)WSA_DefaultBlockingHook;
7792 return 0;
7793 }
7794
7795
7796 /* ----------------------------------- end of API stuff */
7797
7798 /* ----------------------------------- helper functions -
7799 *
7800 * TODO: Merge WS_dup_..() stuff into one function that
7801 * would operate with a generic structure containing internal
7802 * pointers (via a template of some kind).
7803 */
7804
7805 static int list_size(char** l, int item_size)
7806 {
7807 int i,j = 0;
7808 if(l)
7809 { for(i=0;l[i];i++)
7810 j += (item_size) ? item_size : strlen(l[i]) + 1;
7811 j += (i + 1) * sizeof(char*); }
7812 return j;
7813 }
7814
7815 static int list_dup(char** l_src, char** l_to, int item_size)
7816 {
7817 char *p;
7818 int i;
7819
7820 for (i = 0; l_src[i]; i++) ;
7821 p = (char *)(l_to + i + 1);
7822 for (i = 0; l_src[i]; i++)
7823 {
7824 int count = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
7825 memcpy(p, l_src[i], count);
7826 l_to[i] = p;
7827 p += count;
7828 }
7829 l_to[i] = NULL;
7830 return p - (char *)l_to;
7831 }
7832
7833 /* ----- hostent */
7834
7835 /* create a hostent entry
7836 *
7837 * Creates the entry with enough memory for the name, aliases
7838 * addresses, and the address pointers. Also copies the name
7839 * and sets up all the pointers.
7840 *
7841 * NOTE: The alias and address lists must be allocated with room
7842 * for the NULL item terminating the list. This is true even if
7843 * the list has no items ("aliases" and "addresses" must be
7844 * at least "1", a truly empty list is invalid).
7845 */
7846 static struct WS_hostent *WS_create_he(char *name, int aliases, int aliases_size, int addresses, int address_length)
7847 {
7848 struct WS_hostent *p_to;
7849 char *p;
7850 int size = (sizeof(struct WS_hostent) +
7851 strlen(name) + 1 +
7852 sizeof(char *) * aliases +
7853 aliases_size +
7854 sizeof(char *) * addresses +
7855 address_length * (addresses - 1)), i;
7856
7857 if (!(p_to = check_buffer_he(size))) return NULL;
7858 memset(p_to, 0, size);
7859
7860 /* Use the memory in the same way winsock does.
7861 * First set the pointer for aliases, second set the pointers for addresses.
7862 * Third fill the addresses indexes, fourth jump aliases names size.
7863 * Fifth fill the hostname.
7864 * NOTE: This method is valid for OS version's >= XP.
7865 */
7866 p = (char *)(p_to + 1);
7867 p_to->h_aliases = (char **)p;
7868 p += sizeof(char *)*aliases;
7869
7870 p_to->h_addr_list = (char **)p;
7871 p += sizeof(char *)*addresses;
7872
7873 for (i = 0, addresses--; i < addresses; i++, p += address_length)
7874 p_to->h_addr_list[i] = p;
7875
7876 /* NOTE: h_aliases must be filled in manually because we don't know each string
7877 * size, leave these pointers NULL (already set to NULL by memset earlier).
7878 */
7879 p += aliases_size;
7880
7881 p_to->h_name = p;
7882 strcpy(p, name);
7883
7884 return p_to;
7885 }
7886
7887 /* duplicate hostent entry
7888 * and handle all Win16/Win32 dependent things (struct size, ...) *correctly*.
7889 * Ditto for protoent and servent.
7890 */
7891 static struct WS_hostent *WS_dup_he(const struct hostent* p_he)
7892 {
7893 int i, addresses = 0, alias_size = 0;
7894 struct WS_hostent *p_to;
7895 char *p;
7896
7897 for( i = 0; p_he->h_aliases[i]; i++) alias_size += strlen(p_he->h_aliases[i]) + 1;
7898 while (p_he->h_addr_list[addresses]) addresses++;
7899
7900 p_to = WS_create_he(p_he->h_name, i + 1, alias_size, addresses + 1, p_he->h_length);
7901
7902 if (!p_to) return NULL;
7903 p_to->h_addrtype = convert_af_u2w(p_he->h_addrtype);
7904 p_to->h_length = p_he->h_length;
7905
7906 for(i = 0, p = p_to->h_addr_list[0]; p_he->h_addr_list[i]; i++, p += p_to->h_length)
7907 memcpy(p, p_he->h_addr_list[i], p_to->h_length);
7908
7909 /* Fill the aliases after the IP data */
7910 for(i = 0; p_he->h_aliases[i]; i++)
7911 {
7912 p_to->h_aliases[i] = p;
7913 strcpy(p, p_he->h_aliases[i]);
7914 p += strlen(p) + 1;
7915 }
7916
7917 return p_to;
7918 }
7919
7920 /* ----- protoent */
7921
7922 static struct WS_protoent *WS_create_pe( const char *name, char **aliases, int prot )
7923 {
7924 struct WS_protoent *ret;
7925 unsigned int size = sizeof(*ret) + strlen(name) + sizeof(char *) + list_size(aliases, 0);
7926
7927 if (!(ret = check_buffer_pe( size ))) return NULL;
7928 ret->p_proto = prot;
7929 ret->p_name = (char *)(ret + 1);
7930 strcpy( ret->p_name, name );
7931 ret->p_aliases = (char **)ret->p_name + strlen(name) / sizeof(char *) + 1;
7932 list_dup( aliases, ret->p_aliases, 0 );
7933 return ret;
7934 }
7935
7936 /* ----- servent */
7937
7938 static struct WS_servent *WS_dup_se(const struct servent* p_se)
7939 {
7940 char *p;
7941 struct WS_servent *p_to;
7942
7943 int size = (sizeof(*p_se) +
7944 strlen(p_se->s_proto) + 1 +
7945 strlen(p_se->s_name) + 1 +
7946 list_size(p_se->s_aliases, 0));
7947
7948 if (!(p_to = check_buffer_se(size))) return NULL;
7949 p_to->s_port = p_se->s_port;
7950
7951 p = (char *)(p_to + 1);
7952 p_to->s_name = p;
7953 strcpy(p, p_se->s_name);
7954 p += strlen(p) + 1;
7955
7956 p_to->s_proto = p;
7957 strcpy(p, p_se->s_proto);
7958 p += strlen(p) + 1;
7959
7960 p_to->s_aliases = (char **)p;
7961 list_dup(p_se->s_aliases, p_to->s_aliases, 0);
7962 return p_to;
7963 }
7964
7965
7966 /***********************************************************************
7967 * WSARecv (WS2_32.67)
7968 */
7969 int WINAPI WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
7970 LPDWORD NumberOfBytesReceived, LPDWORD lpFlags,
7971 LPWSAOVERLAPPED lpOverlapped,
7972 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
7973 {
7974 return WS2_recv_base(s, lpBuffers, dwBufferCount, NumberOfBytesReceived, lpFlags,
7975 NULL, NULL, lpOverlapped, lpCompletionRoutine, NULL);
7976 }
7977
7978 static int WS2_recv_base( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
7979 LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags,
7980 struct WS_sockaddr *lpFrom,
7981 LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped,
7982 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
7983 LPWSABUF lpControlBuffer )
7984 {
7985 unsigned int i, options;
7986 int n, fd, err, overlapped, flags;
7987 struct ws2_async *wsa = NULL, localwsa;
7988 BOOL is_blocking;
7989 DWORD timeout_start = GetTickCount();
7990 ULONG_PTR cvalue = (lpOverlapped && ((ULONG_PTR)lpOverlapped->hEvent & 1) == 0) ? (ULONG_PTR)lpOverlapped : 0;
7991
7992 TRACE("socket %04lx, wsabuf %p, nbufs %d, flags %d, from %p, fromlen %d, ovl %p, func %p\n",
7993 s, lpBuffers, dwBufferCount, *lpFlags, lpFrom,
7994 (lpFromlen ? *lpFromlen : -1),
7995 lpOverlapped, lpCompletionRoutine);
7996
7997 fd = get_sock_fd( s, FILE_READ_DATA, &options );
7998 TRACE( "fd=%d, options=%x\n", fd, options );
7999
8000 if (fd == -1) return SOCKET_ERROR;
8001
8002 if (*lpFlags & WS_MSG_OOB)
8003 {
8004 /* It's invalid to receive OOB data from an OOBINLINED socket
8005 * as OOB data is turned into normal data. */
8006 socklen_t len = sizeof(n);
8007 if (!getsockopt(fd, SOL_SOCKET, SO_OOBINLINE, (char*) &n, &len) && n)
8008 {
8009 err = WSAEINVAL;
8010 goto error;
8011 }
8012 }
8013
8014 overlapped = (lpOverlapped || lpCompletionRoutine) &&
8015 !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT));
8016 if (overlapped || dwBufferCount > 1)
8017 {
8018 if (!(wsa = (struct ws2_async *)alloc_async_io( offsetof(struct ws2_async, iovec[dwBufferCount]),
8019 WS2_async_recv )))
8020 {
8021 err = WSAEFAULT;
8022 goto error;
8023 }
8024 }
8025 else
8026 wsa = &localwsa;
8027
8028 wsa->hSocket = SOCKET2HANDLE(s);
8029 wsa->flags = *lpFlags;
8030 wsa->lpFlags = lpFlags;
8031 wsa->addr = lpFrom;
8032 wsa->addrlen.ptr = lpFromlen;
8033 wsa->control = lpControlBuffer;
8034 wsa->n_iovecs = dwBufferCount;
8035 wsa->first_iovec = 0;
8036 for (i = 0; i < dwBufferCount; i++)
8037 {
8038 /* check buffer first to trigger write watches */
8039 if (IsBadWritePtr( lpBuffers[i].buf, lpBuffers[i].len ))
8040 {
8041 err = WSAEFAULT;
8042 goto error;
8043 }
8044 wsa->iovec[i].iov_base = lpBuffers[i].buf;
8045 wsa->iovec[i].iov_len = lpBuffers[i].len;
8046 }
8047
8048 flags = convert_flags(wsa->flags);
8049 for (;;)
8050 {
8051 n = WS2_recv( fd, wsa, flags );
8052 if (n == -1)
8053 {
8054 /* Unix-like systems return EINVAL when attempting to read OOB data from
8055 * an empty socket buffer, convert that to a Windows expected return. */
8056 if ((flags & MSG_OOB) && errno == EINVAL)
8057 errno = EWOULDBLOCK;
8058
8059 if (errno != EAGAIN)
8060 {
8061 err = wsaErrno();
8062 goto error;
8063 }
8064 }
8065 else if (lpNumberOfBytesRecvd) *lpNumberOfBytesRecvd = n;
8066
8067 if (overlapped)
8068 {
8069 IO_STATUS_BLOCK *iosb = lpOverlapped ? (IO_STATUS_BLOCK *)lpOverlapped : &wsa->local_iosb;
8070
8071 wsa->user_overlapped = lpOverlapped;
8072 wsa->completion_func = lpCompletionRoutine;
8073 release_sock_fd( s, fd );
8074
8075 if (n == -1)
8076 {
8077 iosb->u.Status = STATUS_PENDING;
8078 iosb->Information = 0;
8079
8080 if (wsa->completion_func)
8081 err = register_async( ASYNC_TYPE_READ, wsa->hSocket, &wsa->io, NULL,
8082 ws2_async_apc, wsa, iosb );
8083 else
8084 err = register_async( ASYNC_TYPE_READ, wsa->hSocket, &wsa->io, lpOverlapped->hEvent,
8085 NULL, (void *)cvalue, iosb );
8086
8087 if (err != STATUS_PENDING) HeapFree( GetProcessHeap(), 0, wsa );
8088 SetLastError(NtStatusToWSAError( err ));
8089 return SOCKET_ERROR;
8090 }
8091
8092 iosb->u.Status = STATUS_SUCCESS;
8093 iosb->Information = n;
8094 if (!wsa->completion_func)
8095 {
8096 if (cvalue) WS_AddCompletion( s, cvalue, STATUS_SUCCESS, n, FALSE );
8097 if (lpOverlapped->hEvent) SetEvent( lpOverlapped->hEvent );
8098 HeapFree( GetProcessHeap(), 0, wsa );
8099 }
8100 else NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC)ws2_async_apc,
8101 (ULONG_PTR)wsa, (ULONG_PTR)iosb, 0 );
8102 _enable_event(SOCKET2HANDLE(s), FD_READ, 0, 0);
8103 return 0;
8104 }
8105
8106 if (n != -1) break;
8107
8108 if ((err = sock_is_blocking( s, &is_blocking ))) goto error;
8109
8110 if ( is_blocking )
8111 {
8112 struct pollfd pfd;
8113 int poll_timeout = -1;
8114 INT64 timeout = get_rcvsnd_timeo(fd, TRUE);
8115
8116 if (timeout)
8117 {
8118 timeout -= GetTickCount() - timeout_start;
8119 if (timeout < 0) poll_timeout = 0;
8120 else poll_timeout = timeout <= INT_MAX ? timeout : INT_MAX;
8121 }
8122
8123 pfd.fd = fd;
8124 pfd.events = POLLIN;
8125 if (*lpFlags & WS_MSG_OOB) pfd.events |= POLLPRI;
8126
8127 if (!poll_timeout || !poll( &pfd, 1, poll_timeout ))
8128 {
8129 err = WSAETIMEDOUT;
8130 /* a timeout is not fatal */
8131 _enable_event(SOCKET2HANDLE(s), FD_READ, 0, 0);
8132 goto error;
8133 }
8134 }
8135 else
8136 {
8137 _enable_event(SOCKET2HANDLE(s), FD_READ, 0, 0);
8138 err = WSAEWOULDBLOCK;
8139 goto error;
8140 }
8141 }
8142
8143 TRACE(" -> %i bytes\n", n);
8144 if (wsa != &localwsa) HeapFree( GetProcessHeap(), 0, wsa );
8145 release_sock_fd( s, fd );
8146 _enable_event(SOCKET2HANDLE(s), FD_READ, 0, 0);
8147 SetLastError(ERROR_SUCCESS);
8148
8149 return 0;
8150
8151 error:
8152 if (wsa != &localwsa) HeapFree( GetProcessHeap(), 0, wsa );
8153 release_sock_fd( s, fd );
8154 WARN(" -> ERROR %d\n", err);
8155 SetLastError( err );
8156 return SOCKET_ERROR;
8157 }
8158
8159 /***********************************************************************
8160 * WSARecvFrom (WS2_32.69)
8161 */
8162 INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
8163 LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct WS_sockaddr *lpFrom,
8164 LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped,
8165 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
8166
8167 {
8168 return WS2_recv_base( s, lpBuffers, dwBufferCount,
8169 lpNumberOfBytesRecvd, lpFlags,
8170 lpFrom, lpFromlen,
8171 lpOverlapped, lpCompletionRoutine, NULL );
8172 }
8173
8174 /***********************************************************************
8175 * WSCInstallProvider (WS2_32.88)
8176 */
8177 INT WINAPI WSCInstallProvider( const LPGUID lpProviderId,
8178 LPCWSTR lpszProviderDllPath,
8179 const LPWSAPROTOCOL_INFOW lpProtocolInfoList,
8180 DWORD dwNumberOfEntries,
8181 LPINT lpErrno )
8182 {
8183 FIXME("(%s, %s, %p, %d, %p): stub !\n", debugstr_guid(lpProviderId),
8184 debugstr_w(lpszProviderDllPath), lpProtocolInfoList,
8185 dwNumberOfEntries, lpErrno);
8186 *lpErrno = 0;
8187 return 0;
8188 }
8189
8190
8191 /***********************************************************************
8192 * WSCDeinstallProvider (WS2_32.83)
8193 */
8194 INT WINAPI WSCDeinstallProvider(LPGUID lpProviderId, LPINT lpErrno)
8195 {
8196 FIXME("(%s, %p): stub !\n", debugstr_guid(lpProviderId), lpErrno);
8197 *lpErrno = 0;
8198 return 0;
8199 }
8200
8201
8202 /***********************************************************************
8203 * WSAAccept (WS2_32.26)
8204 */
8205 SOCKET WINAPI WSAAccept( SOCKET s, struct WS_sockaddr *addr, LPINT addrlen,
8206 LPCONDITIONPROC lpfnCondition, DWORD_PTR dwCallbackData)
8207 {
8208
8209 int ret = 0, size;
8210 WSABUF CallerId, CallerData, CalleeId, CalleeData;
8211 /* QOS SQOS, GQOS; */
8212 GROUP g;
8213 SOCKET cs;
8214 SOCKADDR src_addr, dst_addr;
8215
8216 TRACE("socket %04lx, sockaddr %p, addrlen %p, fnCondition %p, dwCallbackData %ld\n",
8217 s, addr, addrlen, lpfnCondition, dwCallbackData);
8218
8219 cs = WS_accept(s, addr, addrlen);
8220 if (cs == SOCKET_ERROR) return SOCKET_ERROR;
8221 if (!lpfnCondition) return cs;
8222
8223 if (addr && addrlen)
8224 {
8225 CallerId.buf = (char *)addr;
8226 CallerId.len = *addrlen;
8227 }
8228 else
8229 {
8230 size = sizeof(src_addr);
8231 WS_getpeername(cs, &src_addr, &size);
8232 CallerId.buf = (char *)&src_addr;
8233 CallerId.len = size;
8234 }
8235 CallerData.buf = NULL;
8236 CallerData.len = 0;
8237
8238 size = sizeof(dst_addr);
8239 WS_getsockname(cs, &dst_addr, &size);
8240
8241 CalleeId.buf = (char *)&dst_addr;
8242 CalleeId.len = sizeof(dst_addr);
8243
8244 ret = (*lpfnCondition)(&CallerId, &CallerData, NULL, NULL,
8245 &CalleeId, &CalleeData, &g, dwCallbackData);
8246
8247 switch (ret)
8248 {
8249 case CF_ACCEPT:
8250 return cs;
8251 case CF_DEFER:
8252 SERVER_START_REQ( set_socket_deferred )
8253 {
8254 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
8255 req->deferred = wine_server_obj_handle( SOCKET2HANDLE(cs) );
8256 if ( !wine_server_call_err ( req ) )
8257 {
8258 SetLastError( WSATRY_AGAIN );
8259 WS_closesocket( cs );
8260 }
8261 }
8262 SERVER_END_REQ;
8263 return SOCKET_ERROR;
8264 case CF_REJECT:
8265 WS_closesocket(cs);
8266 SetLastError(WSAECONNREFUSED);
8267 return SOCKET_ERROR;
8268 default:
8269 FIXME("Unknown return type from Condition function\n");
8270 SetLastError(WSAENOTSOCK);
8271 return SOCKET_ERROR;
8272 }
8273 }
8274
8275 /***********************************************************************
8276 * WSADuplicateSocketA (WS2_32.32)
8277 */
8278 int WINAPI WSADuplicateSocketA( SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOA lpProtocolInfo )
8279 {
8280 return WS_DuplicateSocket(FALSE, s, dwProcessId, (LPWSAPROTOCOL_INFOW) lpProtocolInfo);
8281 }
8282
8283 /***********************************************************************
8284 * WSADuplicateSocketW (WS2_32.33)
8285 */
8286 int WINAPI WSADuplicateSocketW( SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo )
8287 {
8288 return WS_DuplicateSocket(TRUE, s, dwProcessId, lpProtocolInfo);
8289 }
8290
8291 /***********************************************************************
8292 * WSAInstallServiceClassA (WS2_32.48)
8293 */
8294 int WINAPI WSAInstallServiceClassA(LPWSASERVICECLASSINFOA info)
8295 {
8296 FIXME("Request to install service %s\n",debugstr_a(info->lpszServiceClassName));
8297 SetLastError(WSAEACCES);
8298 return SOCKET_ERROR;
8299 }
8300
8301 /***********************************************************************
8302 * WSAInstallServiceClassW (WS2_32.49)
8303 */
8304 int WINAPI WSAInstallServiceClassW(LPWSASERVICECLASSINFOW info)
8305 {
8306 FIXME("Request to install service %s\n",debugstr_w(info->lpszServiceClassName));
8307 SetLastError(WSAEACCES);
8308 return SOCKET_ERROR;
8309 }
8310
8311 /***********************************************************************
8312 * WSARemoveServiceClass (WS2_32.70)
8313 */
8314 int WINAPI WSARemoveServiceClass(LPGUID info)
8315 {
8316 FIXME("Request to remove service %s\n", debugstr_guid(info));
8317 SetLastError(WSATYPE_NOT_FOUND);
8318 return SOCKET_ERROR;
8319 }
8320
8321 /***********************************************************************
8322 * inet_ntop (WS2_32.@)
8323 */
8324 PCSTR WINAPI WS_inet_ntop( INT family, PVOID addr, PSTR buffer, SIZE_T len )
8325 {
8326 NTSTATUS status;
8327 ULONG size = min( len, (ULONG)-1 );
8328
8329 TRACE("family %d, addr (%p), buffer (%p), len %ld\n", family, addr, buffer, len);
8330 if (!buffer)
8331 {
8332 SetLastError( STATUS_INVALID_PARAMETER );
8333 return NULL;
8334 }
8335
8336 switch (family)
8337 {
8338 case WS_AF_INET:
8339 {
8340 status = RtlIpv4AddressToStringExA( (IN_ADDR *)addr, 0, buffer, &size );
8341 break;
8342 }
8343 case WS_AF_INET6:
8344 {
8345 status = RtlIpv6AddressToStringExA( (IN6_ADDR *)addr, 0, 0, buffer, &size );
8346 break;
8347 }
8348 default:
8349 SetLastError( WSAEAFNOSUPPORT );
8350 return NULL;
8351 }
8352
8353 if (status == STATUS_SUCCESS) return buffer;
8354 SetLastError( STATUS_INVALID_PARAMETER );
8355 return NULL;
8356 }
8357
8358 /***********************************************************************
8359 * inet_pton (WS2_32.@)
8360 */
8361 INT WINAPI WS_inet_pton(INT family, const char *addr, void *buffer)
8362 {
8363 NTSTATUS status;
8364 const char *terminator;
8365
8366 TRACE("family %d, addr %s, buffer (%p)\n", family, debugstr_a(addr), buffer);
8367
8368 if (!addr || !buffer)
8369 {
8370 SetLastError(WSAEFAULT);
8371 return SOCKET_ERROR;
8372 }
8373
8374 switch (family)
8375 {
8376 case WS_AF_INET:
8377 status = RtlIpv4StringToAddressA(addr, TRUE, &terminator, buffer);
8378 break;
8379 case WS_AF_INET6:
8380 status = RtlIpv6StringToAddressA(addr, &terminator, buffer);
8381 break;
8382 default:
8383 SetLastError(WSAEAFNOSUPPORT);
8384 return SOCKET_ERROR;
8385 }
8386
8387 return (status == STATUS_SUCCESS && *terminator == 0);
8388 }
8389
8390 /***********************************************************************
8391 * InetPtonW (WS2_32.@)
8392 */
8393 INT WINAPI InetPtonW(INT family, PCWSTR addr, PVOID buffer)
8394 {
8395 char *addrA;
8396 int len;
8397 INT ret;
8398
8399 TRACE("family %d, addr %s, buffer (%p)\n", family, debugstr_w(addr), buffer);
8400
8401 if (!addr)
8402 {
8403 SetLastError(WSAEFAULT);
8404 return SOCKET_ERROR;
8405 }
8406
8407 len = WideCharToMultiByte(CP_ACP, 0, addr, -1, NULL, 0, NULL, NULL);
8408 if (!(addrA = HeapAlloc(GetProcessHeap(), 0, len)))
8409 {
8410 SetLastError(WSA_NOT_ENOUGH_MEMORY);
8411 return SOCKET_ERROR;
8412 }
8413 WideCharToMultiByte(CP_ACP, 0, addr, -1, addrA, len, NULL, NULL);
8414
8415 ret = WS_inet_pton(family, addrA, buffer);
8416 if (!ret) SetLastError(WSAEINVAL);
8417
8418 HeapFree(GetProcessHeap(), 0, addrA);
8419 return ret;
8420 }
8421
8422 /***********************************************************************
8423 * InetNtopW (WS2_32.@)
8424 */
8425 PCWSTR WINAPI InetNtopW(INT family, PVOID addr, PWSTR buffer, SIZE_T len)
8426 {
8427 char bufferA[WS_INET6_ADDRSTRLEN];
8428 PWSTR ret = NULL;
8429
8430 TRACE("family %d, addr (%p), buffer (%p), len %ld\n", family, addr, buffer, len);
8431
8432 if (WS_inet_ntop(family, addr, bufferA, sizeof(bufferA)))
8433 {
8434 if (MultiByteToWideChar(CP_ACP, 0, bufferA, -1, buffer, len))
8435 ret = buffer;
8436 else
8437 SetLastError(ERROR_INVALID_PARAMETER);
8438 }
8439 return ret;
8440 }
8441
8442 /***********************************************************************
8443 * WSAStringToAddressA (WS2_32.80)
8444 */
8445 INT WINAPI WSAStringToAddressA(LPSTR AddressString,
8446 INT AddressFamily,
8447 LPWSAPROTOCOL_INFOA lpProtocolInfo,
8448 LPSOCKADDR lpAddress,
8449 LPINT lpAddressLength)
8450 {
8451 INT res=0;
8452 NTSTATUS status;
8453
8454 TRACE( "(%s, %x, %p, %p, %p)\n", debugstr_a(AddressString), AddressFamily,
8455 lpProtocolInfo, lpAddress, lpAddressLength );
8456
8457 if (!lpAddressLength || !lpAddress) return SOCKET_ERROR;
8458
8459 if (!AddressString)
8460 {
8461 SetLastError(WSAEINVAL);
8462 return SOCKET_ERROR;
8463 }
8464
8465 if (lpProtocolInfo)
8466 FIXME("ProtocolInfo not implemented.\n");
8467
8468 switch(AddressFamily)
8469 {
8470 case WS_AF_INET:
8471 {
8472 SOCKADDR_IN *addr4 = (SOCKADDR_IN *)lpAddress;
8473
8474 /* If lpAddressLength is too small, tell caller the size we need */
8475 if (*lpAddressLength < sizeof(SOCKADDR_IN))
8476 {
8477 *lpAddressLength = sizeof(SOCKADDR_IN);
8478 res = WSAEFAULT;
8479 break;
8480 }
8481 memset(lpAddress, 0, sizeof(SOCKADDR_IN));
8482
8483 status = RtlIpv4StringToAddressExA(AddressString, FALSE, &addr4->sin_addr, &addr4->sin_port);
8484 if (status != STATUS_SUCCESS)
8485 {
8486 res = WSAEINVAL;
8487 break;
8488 }
8489 addr4->sin_family = WS_AF_INET;
8490 *lpAddressLength = sizeof(SOCKADDR_IN);
8491 break;
8492 }
8493 case WS_AF_INET6:
8494 {
8495 SOCKADDR_IN6 *addr6 = (SOCKADDR_IN6 *)lpAddress;
8496
8497 /* If lpAddressLength is too small, tell caller the size we need */
8498 if (*lpAddressLength < sizeof(SOCKADDR_IN6))
8499 {
8500 *lpAddressLength = sizeof(SOCKADDR_IN6);
8501 res = WSAEFAULT;
8502 break;
8503 }
8504 memset(lpAddress, 0, sizeof(SOCKADDR_IN6));
8505
8506 status = RtlIpv6StringToAddressExA(AddressString, &addr6->sin6_addr, &addr6->sin6_scope_id, &addr6->sin6_port);
8507 if (status != STATUS_SUCCESS)
8508 {
8509 res = WSAEINVAL;
8510 break;
8511 }
8512 addr6->sin6_family = WS_AF_INET6;
8513 *lpAddressLength = sizeof(SOCKADDR_IN6);
8514 break;
8515 }
8516 default:
8517 /* According to MSDN, only AF_INET and AF_INET6 are supported. */
8518 TRACE("Unsupported address family specified: %d.\n", AddressFamily);
8519 res = WSAEINVAL;
8520 }
8521
8522 if (!res) return 0;
8523 SetLastError(res);
8524 return SOCKET_ERROR;
8525 }
8526
8527 /***********************************************************************
8528 * WSAStringToAddressW (WS2_32.81)
8529 *
8530 * FIXME: Does anybody know if this function allows using Hebrew/Arabic/Chinese... digits?
8531 * If this should be the case, it would be required to map these digits
8532 * to Unicode digits (0-9) using FoldString first.
8533 */
8534 INT WINAPI WSAStringToAddressW(LPWSTR AddressString,
8535 INT AddressFamily,
8536 LPWSAPROTOCOL_INFOW lpProtocolInfo,
8537 LPSOCKADDR lpAddress,
8538 LPINT lpAddressLength)
8539 {
8540 INT sBuffer,res=0;
8541 LPSTR workBuffer=NULL;
8542 WSAPROTOCOL_INFOA infoA;
8543 LPWSAPROTOCOL_INFOA lpProtoInfoA = NULL;
8544
8545 TRACE( "(%s, %x, %p, %p, %p)\n", debugstr_w(AddressString), AddressFamily, lpProtocolInfo,
8546 lpAddress, lpAddressLength );
8547
8548 if (!lpAddressLength || !lpAddress) return SOCKET_ERROR;
8549
8550 /* if ProtocolInfo is available - convert to ANSI variant */
8551 if (lpProtocolInfo)
8552 {
8553 lpProtoInfoA = &infoA;
8554 memcpy( lpProtoInfoA, lpProtocolInfo, FIELD_OFFSET( WSAPROTOCOL_INFOA, szProtocol ) );
8555
8556 if (!WideCharToMultiByte( CP_ACP, 0, lpProtocolInfo->szProtocol, -1,
8557 lpProtoInfoA->szProtocol, WSAPROTOCOL_LEN+1, NULL, NULL ))
8558 {
8559 SetLastError(WSAEINVAL);
8560 return SOCKET_ERROR;
8561 }
8562 }
8563
8564 if (AddressString)
8565 {
8566 /* Translate AddressString to ANSI code page - assumes that only
8567 standard digits 0-9 are used with this API call */
8568 sBuffer = WideCharToMultiByte( CP_ACP, 0, AddressString, -1, NULL, 0, NULL, NULL );
8569 workBuffer = HeapAlloc( GetProcessHeap(), 0, sBuffer );
8570
8571 if (workBuffer)
8572 {
8573 WideCharToMultiByte( CP_ACP, 0, AddressString, -1, workBuffer, sBuffer, NULL, NULL );
8574 res = WSAStringToAddressA(workBuffer,AddressFamily,lpProtoInfoA,
8575 lpAddress,lpAddressLength);
8576 HeapFree( GetProcessHeap(), 0, workBuffer );
8577 return res;
8578 }
8579 else
8580 res = WSA_NOT_ENOUGH_MEMORY;
8581 }
8582 else
8583 res = WSAEINVAL;
8584
8585 SetLastError(res);
8586 return SOCKET_ERROR;
8587 }
8588
8589 /***********************************************************************
8590 * WSAAddressToStringA (WS2_32.27)
8591 *
8592 * See WSAAddressToStringW
8593 */
8594 INT WINAPI WSAAddressToStringA( LPSOCKADDR sockaddr, DWORD len,
8595 LPWSAPROTOCOL_INFOA info, LPSTR string,
8596 LPDWORD lenstr )
8597 {
8598 DWORD size;
8599 CHAR buffer[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
8600 CHAR *p;
8601
8602 TRACE( "(%p, %d, %p, %p, %p)\n", sockaddr, len, info, string, lenstr );
8603
8604 if (!sockaddr) return SOCKET_ERROR;
8605 if (!string || !lenstr) return SOCKET_ERROR;
8606
8607 switch(sockaddr->sa_family)
8608 {
8609 case WS_AF_INET:
8610 {
8611 unsigned int long_ip = ntohl(((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr);
8612 if (len < sizeof(SOCKADDR_IN)) return SOCKET_ERROR;
8613 sprintf( buffer, "%u.%u.%u.%u:%u",
8614 (long_ip >> 24) & 0xff,
8615 (long_ip >> 16) & 0xff,
8616 (long_ip >> 8) & 0xff,
8617 long_ip & 0xff,
8618 ntohs( ((SOCKADDR_IN *)sockaddr)->sin_port ) );
8619
8620 p = strchr( buffer, ':' );
8621 if (!((SOCKADDR_IN *)sockaddr)->sin_port) *p = 0;
8622 break;
8623 }
8624 case WS_AF_INET6:
8625 {
8626 struct WS_sockaddr_in6 *sockaddr6 = (LPSOCKADDR_IN6) sockaddr;
8627 size_t slen;
8628
8629 buffer[0] = 0;
8630 if (len < sizeof(SOCKADDR_IN6)) return SOCKET_ERROR;
8631 if ((sockaddr6->sin6_port))
8632 strcpy(buffer, "[");
8633 slen = strlen(buffer);
8634 if (!WS_inet_ntop(WS_AF_INET6, &sockaddr6->sin6_addr, &buffer[slen], sizeof(buffer) - slen))
8635 {
8636 SetLastError(WSAEINVAL);
8637 return SOCKET_ERROR;
8638 }
8639 if ((sockaddr6->sin6_scope_id))
8640 sprintf(buffer+strlen(buffer), "%%%u", sockaddr6->sin6_scope_id);
8641 if ((sockaddr6->sin6_port))
8642 sprintf(buffer+strlen(buffer), "]:%u", ntohs(sockaddr6->sin6_port));
8643 break;
8644 }
8645
8646 default:
8647 SetLastError(WSAEINVAL);
8648 return SOCKET_ERROR;
8649 }
8650
8651 size = strlen( buffer ) + 1;
8652
8653 if (*lenstr < size)
8654 {
8655 *lenstr = size;
8656 SetLastError(WSAEFAULT);
8657 return SOCKET_ERROR;
8658 }
8659
8660 TRACE("=> %s,%u bytes\n", debugstr_a(buffer), size);
8661 *lenstr = size;
8662 strcpy( string, buffer );
8663 return 0;
8664 }
8665
8666 /***********************************************************************
8667 * WSAAddressToStringW (WS2_32.28)
8668 *
8669 * Convert a sockaddr address into a readable address string.
8670 *
8671 * PARAMS
8672 * sockaddr [I] Pointer to a sockaddr structure.
8673 * len [I] Size of the sockaddr structure.
8674 * info [I] Pointer to a WSAPROTOCOL_INFOW structure (optional).
8675 * string [I/O] Pointer to a buffer to receive the address string.
8676 * lenstr [I/O] Size of the receive buffer in WCHARs.
8677 *
8678 * RETURNS
8679 * Success: 0
8680 * Failure: SOCKET_ERROR
8681 *
8682 * NOTES
8683 * The 'info' parameter is ignored.
8684 */
8685 INT WINAPI WSAAddressToStringW( LPSOCKADDR sockaddr, DWORD len,
8686 LPWSAPROTOCOL_INFOW info, LPWSTR string,
8687 LPDWORD lenstr )
8688 {
8689 INT ret;
8690 DWORD size;
8691 WCHAR buffer[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
8692 CHAR bufAddr[54];
8693
8694 TRACE( "(%p, %d, %p, %p, %p)\n", sockaddr, len, info, string, lenstr );
8695
8696 size = *lenstr;
8697 ret = WSAAddressToStringA(sockaddr, len, NULL, bufAddr, &size);
8698
8699 if (ret) return ret;
8700
8701 MultiByteToWideChar(CP_ACP, 0, bufAddr, size, buffer, ARRAY_SIZE(buffer));
8702
8703 if (*lenstr < size)
8704 {
8705 *lenstr = size;
8706 SetLastError(WSAEFAULT);
8707 return SOCKET_ERROR;
8708 }
8709
8710 TRACE("=> %s,%u bytes\n", debugstr_w(buffer), size);
8711 *lenstr = size;
8712 lstrcpyW( string, buffer );
8713 return 0;
8714 }
8715
8716 /***********************************************************************
8717 * WSAEnumNameSpaceProvidersA (WS2_32.34)
8718 */
8719 INT WINAPI WSAEnumNameSpaceProvidersA( LPDWORD len, LPWSANAMESPACE_INFOA buffer )
8720 {
8721 FIXME( "(%p %p) Stub!\n", len, buffer );
8722 return 0;
8723 }
8724
8725 /***********************************************************************
8726 * WSAEnumNameSpaceProvidersW (WS2_32.35)
8727 */
8728 INT WINAPI WSAEnumNameSpaceProvidersW( LPDWORD len, LPWSANAMESPACE_INFOW buffer )
8729 {
8730 FIXME( "(%p %p) Stub!\n", len, buffer );
8731 return 0;
8732 }
8733
8734 /***********************************************************************
8735 * WSAGetQOSByName (WS2_32.41)
8736 */
8737 BOOL WINAPI WSAGetQOSByName( SOCKET s, LPWSABUF lpQOSName, LPQOS lpQOS )
8738 {
8739 FIXME( "(0x%04lx %p %p) Stub!\n", s, lpQOSName, lpQOS );
8740 return FALSE;
8741 }
8742
8743 /***********************************************************************
8744 * WSAGetServiceClassInfoA (WS2_32.42)
8745 */
8746 INT WINAPI WSAGetServiceClassInfoA( LPGUID provider, LPGUID service, LPDWORD len,
8747 LPWSASERVICECLASSINFOA info )
8748 {
8749 FIXME( "(%s %s %p %p) Stub!\n", debugstr_guid(provider), debugstr_guid(service),
8750 len, info );
8751 SetLastError(WSA_NOT_ENOUGH_MEMORY);
8752 return SOCKET_ERROR;
8753 }
8754
8755 /***********************************************************************
8756 * WSAGetServiceClassInfoW (WS2_32.43)
8757 */
8758 INT WINAPI WSAGetServiceClassInfoW( LPGUID provider, LPGUID service, LPDWORD len,
8759 LPWSASERVICECLASSINFOW info )
8760 {
8761 FIXME( "(%s %s %p %p) Stub!\n", debugstr_guid(provider), debugstr_guid(service),
8762 len, info );
8763 SetLastError(WSA_NOT_ENOUGH_MEMORY);
8764 return SOCKET_ERROR;
8765 }
8766
8767 /***********************************************************************
8768 * WSAGetServiceClassNameByClassIdA (WS2_32.44)
8769 */
8770 INT WINAPI WSAGetServiceClassNameByClassIdA( LPGUID class, LPSTR service, LPDWORD len )
8771 {
8772 FIXME( "(%s %p %p) Stub!\n", debugstr_guid(class), service, len );
8773 SetLastError(WSA_NOT_ENOUGH_MEMORY);
8774 return SOCKET_ERROR;
8775 }
8776
8777 /***********************************************************************
8778 * WSAGetServiceClassNameByClassIdW (WS2_32.45)
8779 */
8780 INT WINAPI WSAGetServiceClassNameByClassIdW( LPGUID class, LPWSTR service, LPDWORD len )
8781 {
8782 FIXME( "(%s %p %p) Stub!\n", debugstr_guid(class), service, len );
8783 SetLastError(WSA_NOT_ENOUGH_MEMORY);
8784 return SOCKET_ERROR;
8785 }
8786
8787 /***********************************************************************
8788 * WSALookupServiceBeginA (WS2_32.59)
8789 */
8790 INT WINAPI WSALookupServiceBeginA( LPWSAQUERYSETA lpqsRestrictions,
8791 DWORD dwControlFlags,
8792 LPHANDLE lphLookup)
8793 {
8794 FIXME("(%p 0x%08x %p) Stub!\n", lpqsRestrictions, dwControlFlags,
8795 lphLookup);
8796 SetLastError(WSA_NOT_ENOUGH_MEMORY);
8797 return SOCKET_ERROR;
8798 }
8799
8800 /***********************************************************************
8801 * WSALookupServiceBeginW (WS2_32.60)
8802 */
8803 INT WINAPI WSALookupServiceBeginW( LPWSAQUERYSETW lpqsRestrictions,
8804 DWORD dwControlFlags,
8805 LPHANDLE lphLookup)
8806 {
8807 FIXME("(%p 0x%08x %p) Stub!\n", lpqsRestrictions, dwControlFlags,
8808 lphLookup);
8809 SetLastError(WSA_NOT_ENOUGH_MEMORY);
8810 return SOCKET_ERROR;
8811 }
8812
8813 /***********************************************************************
8814 * WSALookupServiceEnd (WS2_32.61)
8815 */
8816 INT WINAPI WSALookupServiceEnd( HANDLE lookup )
8817 {
8818 FIXME("(%p) Stub!\n", lookup );
8819 return 0;
8820 }
8821
8822 /***********************************************************************
8823 * WSALookupServiceNextA (WS2_32.62)
8824 */
8825 INT WINAPI WSALookupServiceNextA( HANDLE lookup, DWORD flags, LPDWORD len, LPWSAQUERYSETA results )
8826 {
8827 FIXME( "(%p 0x%08x %p %p) Stub!\n", lookup, flags, len, results );
8828 SetLastError(WSA_E_NO_MORE);
8829 return SOCKET_ERROR;
8830 }
8831
8832 /***********************************************************************
8833 * WSALookupServiceNextW (WS2_32.63)
8834 */
8835 INT WINAPI WSALookupServiceNextW( HANDLE lookup, DWORD flags, LPDWORD len, LPWSAQUERYSETW results )
8836 {
8837 FIXME( "(%p 0x%08x %p %p) Stub!\n", lookup, flags, len, results );
8838 SetLastError(WSA_E_NO_MORE);
8839 return SOCKET_ERROR;
8840 }
8841
8842 /***********************************************************************
8843 * WSANtohl (WS2_32.64)
8844 */
8845 INT WINAPI WSANtohl( SOCKET s, WS_u_long netlong, WS_u_long* lphostlong )
8846 {
8847 TRACE( "(%04lx 0x%08x %p)\n", s, netlong, lphostlong );
8848
8849 if (!lphostlong) return WSAEFAULT;
8850
8851 *lphostlong = ntohl( netlong );
8852 return 0;
8853 }
8854
8855 /***********************************************************************
8856 * WSANtohs (WS2_32.65)
8857 */
8858 INT WINAPI WSANtohs( SOCKET s, WS_u_short netshort, WS_u_short* lphostshort )
8859 {
8860 TRACE( "(%04lx 0x%08x %p)\n", s, netshort, lphostshort );
8861
8862 if (!lphostshort) return WSAEFAULT;
8863
8864 *lphostshort = ntohs( netshort );
8865 return 0;
8866 }
8867
8868 /***********************************************************************
8869 * WSAProviderConfigChange (WS2_32.66)
8870 */
8871 INT WINAPI WSAProviderConfigChange( LPHANDLE handle, LPWSAOVERLAPPED overlapped,
8872 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
8873 {
8874 FIXME( "(%p %p %p) Stub!\n", handle, overlapped, completion );
8875 return SOCKET_ERROR;
8876 }
8877
8878 /***********************************************************************
8879 * WSARecvDisconnect (WS2_32.68)
8880 */
8881 INT WINAPI WSARecvDisconnect( SOCKET s, LPWSABUF disconnectdata )
8882 {
8883 TRACE( "(%04lx %p)\n", s, disconnectdata );
8884
8885 return WS_shutdown( s, SD_RECEIVE );
8886 }
8887
8888 /***********************************************************************
8889 * WSASetServiceA (WS2_32.76)
8890 */
8891 INT WINAPI WSASetServiceA( LPWSAQUERYSETA query, WSAESETSERVICEOP operation, DWORD flags )
8892 {
8893 FIXME( "(%p 0x%08x 0x%08x) Stub!\n", query, operation, flags );
8894 return 0;
8895 }
8896
8897 /***********************************************************************
8898 * WSASetServiceW (WS2_32.77)
8899 */
8900 INT WINAPI WSASetServiceW( LPWSAQUERYSETW query, WSAESETSERVICEOP operation, DWORD flags )
8901 {
8902 FIXME( "(%p 0x%08x 0x%08x) Stub!\n", query, operation, flags );
8903 return 0;
8904 }
8905
8906 /***********************************************************************
8907 * WSCEnableNSProvider (WS2_32.84)
8908 */
8909 INT WINAPI WSCEnableNSProvider( LPGUID provider, BOOL enable )
8910 {
8911 FIXME( "(%s 0x%08x) Stub!\n", debugstr_guid(provider), enable );
8912 return 0;
8913 }
8914
8915 /***********************************************************************
8916 * WSCGetProviderInfo
8917 */
8918 INT WINAPI WSCGetProviderInfo( LPGUID provider, WSC_PROVIDER_INFO_TYPE info_type,
8919 PBYTE info, size_t* len, DWORD flags, LPINT errcode )
8920 {
8921 FIXME( "(%s 0x%08x %p %p 0x%08x %p) Stub!\n",
8922 debugstr_guid(provider), info_type, info, len, flags, errcode );
8923
8924 if (!errcode)
8925 return SOCKET_ERROR;
8926
8927 if (!provider) {
8928 *errcode = WSAEFAULT;
8929 return SOCKET_ERROR;
8930 }
8931
8932 *errcode = WSANO_RECOVERY;
8933 return SOCKET_ERROR;
8934 }
8935
8936 /***********************************************************************
8937 * WSCGetProviderPath (WS2_32.86)
8938 */
8939 INT WINAPI WSCGetProviderPath( LPGUID provider, LPWSTR path, LPINT len, LPINT errcode )
8940 {
8941 FIXME( "(%s %p %p %p) Stub!\n", debugstr_guid(provider), path, len, errcode );
8942
8943 if (!errcode || !provider || !len) return WSAEFAULT;
8944
8945 *errcode = WSAEINVAL;
8946 return SOCKET_ERROR;
8947 }
8948
8949 /***********************************************************************
8950 * WSCInstallNameSpace (WS2_32.87)
8951 */
8952 INT WINAPI WSCInstallNameSpace( LPWSTR identifier, LPWSTR path, DWORD namespace,
8953 DWORD version, LPGUID provider )
8954 {
8955 FIXME( "(%s %s 0x%08x 0x%08x %s) Stub!\n", debugstr_w(identifier), debugstr_w(path),
8956 namespace, version, debugstr_guid(provider) );
8957 return 0;
8958 }
8959
8960 /***********************************************************************
8961 * WSCUnInstallNameSpace (WS2_32.89)
8962 */
8963 INT WINAPI WSCUnInstallNameSpace( LPGUID lpProviderId )
8964 {
8965 FIXME("(%s) Stub!\n", debugstr_guid(lpProviderId));
8966 return NO_ERROR;
8967 }
8968
8969 /***********************************************************************
8970 * WSCWriteProviderOrder (WS2_32.91)
8971 */
8972 INT WINAPI WSCWriteProviderOrder( LPDWORD entry, DWORD number )
8973 {
8974 FIXME("(%p 0x%08x) Stub!\n", entry, number);
8975 return 0;
8976 }
8977
8978 /***********************************************************************
8979 * WSCSetApplicationCategory (WS2_32.@)
8980 */
8981 INT WINAPI WSCSetApplicationCategory( LPCWSTR path, DWORD len, LPCWSTR extra, DWORD extralen,
8982 DWORD lspcat, DWORD *prev_lspcat, LPINT err )
8983 {
8984 FIXME("(%s %d %s %d %d %p) Stub!\n", debugstr_w(path), len, debugstr_w(extra),
8985 extralen, lspcat, prev_lspcat);
8986 return 0;
8987 }
8988
8989 /***********************************************************************
8990 * WSANSPIoctl (WS2_32.91)
8991 */
8992 INT WINAPI WSANSPIoctl( HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer,
8993 DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer,
8994 LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion )
8995 {
8996 FIXME("(%p, 0x%08x, %p, 0x%08x, %p, 0x%08x, %p, %p) Stub!\n", hLookup, dwControlCode,
8997 lpvInBuffer, cbInBuffer, lpvOutBuffer, cbOutBuffer, lpcbBytesReturned, lpCompletion);
8998 SetLastError(WSA_NOT_ENOUGH_MEMORY);
8999 return SOCKET_ERROR;
9000 }
9001
9002 /*****************************************************************************
9003 * WSAEnumProtocolsA [WS2_32.@]
9004 *
9005 * see function WSAEnumProtocolsW
9006 */
9007 INT WINAPI WSAEnumProtocolsA( LPINT protocols, LPWSAPROTOCOL_INFOA buffer, LPDWORD len )
9008 {
9009 return WS_EnumProtocols( FALSE, protocols, (LPWSAPROTOCOL_INFOW) buffer, len);
9010 }
9011
9012 /*****************************************************************************
9013 * WSAEnumProtocolsW [WS2_32.@]
9014 *
9015 * Retrieves information about specified set of active network protocols.
9016 *
9017 * PARAMS
9018 * protocols [I] Pointer to null-terminated array of protocol id's. NULL
9019 * retrieves information on all available protocols.
9020 * buffer [I] Pointer to a buffer to be filled with WSAPROTOCOL_INFO
9021 * structures.
9022 * len [I/O] Pointer to a variable specifying buffer size. On output
9023 * the variable holds the number of bytes needed when the
9024 * specified size is too small.
9025 *
9026 * RETURNS
9027 * Success: number of WSAPROTOCOL_INFO structures in buffer.
9028 * Failure: SOCKET_ERROR
9029 *
9030 * NOTES
9031 * NT4SP5 does not return SPX if protocols == NULL
9032 *
9033 * BUGS
9034 * - NT4SP5 returns in addition these list of NETBIOS protocols
9035 * (address family 17), each entry two times one for socket type 2 and 5
9036 *
9037 * iProtocol szProtocol
9038 * 0x80000000 \Device\NwlnkNb
9039 * 0xfffffffa \Device\NetBT_CBENT7
9040 * 0xfffffffb \Device\Nbf_CBENT7
9041 * 0xfffffffc \Device\NetBT_NdisWan5
9042 * 0xfffffffd \Device\NetBT_El9202
9043 * 0xfffffffe \Device\Nbf_El9202
9044 * 0xffffffff \Device\Nbf_NdisWan4
9045 *
9046 * - there is no check that the operating system supports the returned
9047 * protocols
9048 */
9049 INT WINAPI WSAEnumProtocolsW( LPINT protocols, LPWSAPROTOCOL_INFOW buffer, LPDWORD len )
9050 {
9051 return WS_EnumProtocols( TRUE, protocols, buffer, len);
9052 }
9053
9054 /*****************************************************************************
9055 * WSCEnumProtocols [WS2_32.@]
9056 *
9057 * PARAMS
9058 * protocols [I] Null-terminated array of iProtocol values.
9059 * buffer [O] Buffer of WSAPROTOCOL_INFOW structures.
9060 * len [I/O] Size of buffer on input/output.
9061 * errno [O] Error code.
9062 *
9063 * RETURNS
9064 * Success: number of protocols to be reported on.
9065 * Failure: SOCKET_ERROR. error is in errno.
9066 *
9067 * BUGS
9068 * Doesn't supply info on layered protocols.
9069 *
9070 */
9071 INT WINAPI WSCEnumProtocols( LPINT protocols, LPWSAPROTOCOL_INFOW buffer, LPDWORD len, LPINT err )
9072 {
9073 INT ret = WSAEnumProtocolsW( protocols, buffer, len );
9074
9075 if (ret == SOCKET_ERROR) *err = WSAENOBUFS;
9076
9077 return ret;
9078 }
Windows API implementation