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) 2005 Marcus Meissner
6 * Copyright (C) 2006-2008 Kai Blin
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 * NOTE: If you make any changes to fix a particular app, make sure
23 * they don't break something else like Netscape or telnet and ftp
24 * clients and servers (www.winsite.com got a lot of those).
25 */
26
27 #include "config.h"
28 #include "wine/port.h"
29
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <string.h>
33 #include <sys/types.h>
34 #ifdef HAVE_SYS_IPC_H
35 # include <sys/ipc.h>
36 #endif
37 #ifdef HAVE_SYS_IOCTL_H
38 # include <sys/ioctl.h>
39 #endif
40 #ifdef HAVE_SYS_FILIO_H
41 # include <sys/filio.h>
42 #endif
43 #ifdef HAVE_SYS_SOCKIO_H
44 # include <sys/sockio.h>
45 #endif
46
47 #if defined(__EMX__)
48 # include <sys/so_ioctl.h>
49 #endif
50
51 #ifdef HAVE_SYS_PARAM_H
52 # include <sys/param.h>
53 #endif
54
55 #ifdef HAVE_SYS_MSG_H
56 # include <sys/msg.h>
57 #endif
58 #ifdef HAVE_SYS_WAIT_H
59 # include <sys/wait.h>
60 #endif
61 #ifdef HAVE_SYS_UIO_H
62 # include <sys/uio.h>
63 #endif
64 #ifdef HAVE_SYS_SOCKET_H
65 #include <sys/socket.h>
66 #endif
67 #ifdef HAVE_NETINET_IN_H
68 # include <netinet/in.h>
69 #endif
70 #ifdef HAVE_NETINET_TCP_H
71 # include <netinet/tcp.h>
72 #endif
73 #ifdef HAVE_ARPA_INET_H
74 # include <arpa/inet.h>
75 #endif
76 #include <ctype.h>
77 #include <fcntl.h>
78 #include <errno.h>
79 #ifdef HAVE_SYS_ERRNO_H
80 #include <sys/errno.h>
81 #endif
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
99 #ifdef HAVE_NETIPX_IPX_H
100 # include <netipx/ipx.h>
101 # define HAVE_IPX
102 #elif defined(HAVE_LINUX_IPX_H)
103 # ifdef HAVE_ASM_TYPES_H
104 # include <asm/types.h>
105 # endif
106 # ifdef HAVE_LINUX_TYPES_H
107 # include <linux/types.h>
108 # endif
109 # include <linux/ipx.h>
110 # define HAVE_IPX
111 #endif
112
113 #ifdef HAVE_LINUX_IRDA_H
114 # ifdef HAVE_LINUX_TYPES_H
115 # include <linux/types.h>
116 # endif
117 # include <linux/irda.h>
118 # define HAVE_IRDA
119 #endif
120
121 #ifdef HAVE_POLL_H
122 #include <poll.h>
123 #endif
124 #ifdef HAVE_SYS_POLL_H
125 # include <sys/poll.h>
126 #endif
127 #ifdef HAVE_SYS_TIME_H
128 # include <sys/time.h>
129 #endif
130
131 #define NONAMELESSUNION
132 #define NONAMELESSSTRUCT
133 #include "ntstatus.h"
134 #define WIN32_NO_STATUS
135 #include "windef.h"
136 #include "winbase.h"
137 #include "wingdi.h"
138 #include "winuser.h"
139 #include "winerror.h"
140 #include "winnls.h"
141 #include "winsock2.h"
142 #include "mswsock.h"
143 #include "ws2tcpip.h"
144 #include "ws2spi.h"
145 #include "wsipx.h"
146 #include "mstcpip.h"
147 #include "af_irda.h"
148 #include "winnt.h"
149 #include "iphlpapi.h"
150 #include "wine/server.h"
151 #include "wine/debug.h"
152 #include "wine/unicode.h"
153
154 #ifdef HAVE_IPX
155 # include "wsnwlink.h"
156 #endif
157
158
159 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
160 # define sipx_network sipx_addr.x_net
161 # define sipx_node sipx_addr.x_host.c_host
162 #endif /* __FreeBSD__ */
163
164 #ifndef INADDR_NONE
165 #define INADDR_NONE ~0UL
166 #endif
167
168 WINE_DEFAULT_DEBUG_CHANNEL(winsock);
169
170 /* critical section to protect some non-reentrant net function */
171 extern CRITICAL_SECTION csWSgetXXXbyYYY;
172
173 union generic_unix_sockaddr
174 {
175 struct sockaddr addr;
176 char data[128]; /* should be big enough for all families */
177 };
178
179 static inline const char *debugstr_sockaddr( const struct WS_sockaddr *a )
180 {
181 if (!a) return "(nil)";
182 switch (a->sa_family)
183 {
184 case WS_AF_INET:
185 return wine_dbg_sprintf("{ family AF_INET, address %s, port %d }",
186 inet_ntoa(((const struct sockaddr_in *)a)->sin_addr),
187 ntohs(((const struct sockaddr_in *)a)->sin_port));
188 case WS_AF_INET6:
189 {
190 char buf[46];
191 const char *p;
192 struct WS_sockaddr_in6 *sin = (struct WS_sockaddr_in6 *)a;
193
194 p = WS_inet_ntop( WS_AF_INET6, &sin->sin6_addr, buf, sizeof(buf) );
195 if (!p)
196 p = "(unknown IPv6 address)";
197 return wine_dbg_sprintf("{ family AF_INET6, address %s, port %d }",
198 p, ntohs(sin->sin6_port));
199 }
200 case WS_AF_IRDA:
201 {
202 DWORD addr;
203
204 memcpy( &addr, ((const SOCKADDR_IRDA *)a)->irdaDeviceID, sizeof(addr) );
205 addr = ntohl( addr );
206 return wine_dbg_sprintf("{ family AF_IRDA, addr %08x, name %s }",
207 addr,
208 ((const SOCKADDR_IRDA *)a)->irdaServiceName);
209 }
210 default:
211 return wine_dbg_sprintf("{ family %d }", a->sa_family);
212 }
213 }
214
215 /* HANDLE<->SOCKET conversion (SOCKET is UINT_PTR). */
216 #define SOCKET2HANDLE(s) ((HANDLE)(s))
217 #define HANDLE2SOCKET(h) ((SOCKET)(h))
218
219 /****************************************************************
220 * Async IO declarations
221 ****************************************************************/
222
223 typedef struct ws2_async
224 {
225 HANDLE hSocket;
226 int type;
227 LPWSAOVERLAPPED user_overlapped;
228 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_func;
229 IO_STATUS_BLOCK local_iosb;
230 struct WS_sockaddr *addr;
231 union
232 {
233 int val; /* for send operations */
234 int *ptr; /* for recv operations */
235 } addrlen;
236 DWORD flags;
237 unsigned int n_iovecs;
238 unsigned int first_iovec;
239 struct iovec iovec[1];
240 } ws2_async;
241
242 /****************************************************************/
243
244 /* ----------------------------------- internal data */
245
246 /* ws_... struct conversion flags */
247
248 typedef struct /* WSAAsyncSelect() control struct */
249 {
250 HANDLE service, event, sock;
251 HWND hWnd;
252 UINT uMsg;
253 LONG lEvent;
254 } ws_select_info;
255
256 #define WS_MAX_SOCKETS_PER_PROCESS 128 /* reasonable guess */
257 #define WS_MAX_UDP_DATAGRAM 1024
258 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x );
259
260 /* hostent's, servent's and protent's are stored in one buffer per thread,
261 * as documented on MSDN for the functions that return any of the buffers */
262 struct per_thread_data
263 {
264 int opentype;
265 struct WS_hostent *he_buffer;
266 struct WS_servent *se_buffer;
267 struct WS_protoent *pe_buffer;
268 int he_len;
269 int se_len;
270 int pe_len;
271 };
272
273 static INT num_startup; /* reference counter */
274 static FARPROC blocking_hook = (FARPROC)WSA_DefaultBlockingHook;
275
276 /* function prototypes */
277 static struct WS_hostent *WS_dup_he(const struct hostent* p_he);
278 static struct WS_protoent *WS_dup_pe(const struct protoent* p_pe);
279 static struct WS_servent *WS_dup_se(const struct servent* p_se);
280
281 int WSAIOCTL_GetInterfaceCount(void);
282 int WSAIOCTL_GetInterfaceName(int intNumber, char *intName);
283
284 UINT wsaErrno(void);
285 UINT wsaHerrno(int errnr);
286
287 #define MAP_OPTION(opt) { WS_##opt, opt }
288
289 static const int ws_sock_map[][2] =
290 {
291 MAP_OPTION( SO_DEBUG ),
292 MAP_OPTION( SO_ACCEPTCONN ),
293 MAP_OPTION( SO_REUSEADDR ),
294 MAP_OPTION( SO_KEEPALIVE ),
295 MAP_OPTION( SO_DONTROUTE ),
296 MAP_OPTION( SO_BROADCAST ),
297 MAP_OPTION( SO_LINGER ),
298 MAP_OPTION( SO_OOBINLINE ),
299 MAP_OPTION( SO_SNDBUF ),
300 MAP_OPTION( SO_RCVBUF ),
301 MAP_OPTION( SO_ERROR ),
302 MAP_OPTION( SO_TYPE ),
303 #ifdef SO_RCVTIMEO
304 MAP_OPTION( SO_RCVTIMEO ),
305 #endif
306 #ifdef SO_SNDTIMEO
307 MAP_OPTION( SO_SNDTIMEO ),
308 #endif
309 };
310
311 static const int ws_tcp_map[][2] =
312 {
313 #ifdef TCP_NODELAY
314 MAP_OPTION( TCP_NODELAY ),
315 #endif
316 };
317
318 static const int ws_ip_map[][2] =
319 {
320 MAP_OPTION( IP_MULTICAST_IF ),
321 MAP_OPTION( IP_MULTICAST_TTL ),
322 MAP_OPTION( IP_MULTICAST_LOOP ),
323 MAP_OPTION( IP_ADD_MEMBERSHIP ),
324 MAP_OPTION( IP_DROP_MEMBERSHIP ),
325 MAP_OPTION( IP_OPTIONS ),
326 #ifdef IP_HDRINCL
327 MAP_OPTION( IP_HDRINCL ),
328 #endif
329 MAP_OPTION( IP_TOS ),
330 MAP_OPTION( IP_TTL ),
331 };
332
333 static const int ws_af_map[][2] =
334 {
335 MAP_OPTION( AF_UNSPEC ),
336 MAP_OPTION( AF_INET ),
337 MAP_OPTION( AF_INET6 ),
338 #ifdef HAVE_IPX
339 MAP_OPTION( AF_IPX ),
340 #endif
341 #ifdef AF_IRDA
342 MAP_OPTION( AF_IRDA ),
343 #endif
344 {FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO},
345 };
346
347 static const int ws_socktype_map[][2] =
348 {
349 MAP_OPTION( SOCK_DGRAM ),
350 MAP_OPTION( SOCK_STREAM ),
351 MAP_OPTION( SOCK_RAW ),
352 {FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO},
353 };
354
355 static const int ws_proto_map[][2] =
356 {
357 MAP_OPTION( IPPROTO_IP ),
358 MAP_OPTION( IPPROTO_TCP ),
359 MAP_OPTION( IPPROTO_UDP ),
360 MAP_OPTION( IPPROTO_ICMP ),
361 MAP_OPTION( IPPROTO_IGMP ),
362 MAP_OPTION( IPPROTO_RAW ),
363 {FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO},
364 };
365
366 static const int ws_aiflag_map[][2] =
367 {
368 MAP_OPTION( AI_PASSIVE ),
369 MAP_OPTION( AI_CANONNAME ),
370 MAP_OPTION( AI_NUMERICHOST ),
371 /* Linux/UNIX knows a lot more. But Windows only
372 * has 3 as far as I could see. -Marcus
373 */
374 };
375
376 static const int ws_niflag_map[][2] =
377 {
378 MAP_OPTION( NI_NOFQDN ),
379 MAP_OPTION( NI_NUMERICHOST ),
380 MAP_OPTION( NI_NAMEREQD ),
381 MAP_OPTION( NI_NUMERICSERV ),
382 MAP_OPTION( NI_DGRAM ),
383 };
384
385 static const int ws_eai_map[][2] =
386 {
387 MAP_OPTION( EAI_AGAIN ),
388 MAP_OPTION( EAI_BADFLAGS ),
389 MAP_OPTION( EAI_FAIL ),
390 MAP_OPTION( EAI_FAMILY ),
391 MAP_OPTION( EAI_MEMORY ),
392 /* Note: EAI_NODATA is deprecated, but still
393 * used by Windows and Linux... We map the newer
394 * EAI_NONAME to EAI_NODATA for now until Windows
395 * changes too.
396 */
397 #ifdef EAI_NODATA
398 MAP_OPTION( EAI_NODATA ),
399 #endif
400 #ifdef EAI_NONAME
401 { WS_EAI_NODATA, EAI_NONAME },
402 #endif
403
404 MAP_OPTION( EAI_SERVICE ),
405 MAP_OPTION( EAI_SOCKTYPE ),
406 { 0, 0 }
407 };
408
409 static const char magic_loopback_addr[] = {127, 12, 34, 56};
410
411 static inline DWORD NtStatusToWSAError( const DWORD status )
412 {
413 /* We only need to cover the status codes set by server async request handling */
414 DWORD wserr;
415 switch ( status )
416 {
417 case STATUS_SUCCESS: wserr = 0; break;
418 case STATUS_PENDING: wserr = WSA_IO_PENDING; break;
419 case STATUS_OBJECT_TYPE_MISMATCH: wserr = WSAENOTSOCK; break;
420 case STATUS_INVALID_HANDLE: wserr = WSAEBADF; break;
421 case STATUS_INVALID_PARAMETER: wserr = WSAEINVAL; break;
422 case STATUS_PIPE_DISCONNECTED: wserr = WSAESHUTDOWN; break;
423 case STATUS_CANCELLED: wserr = WSA_OPERATION_ABORTED; break;
424 case STATUS_TIMEOUT: wserr = WSAETIMEDOUT; break;
425 case STATUS_NO_MEMORY: wserr = WSAEFAULT; break;
426 default:
427 if ( status >= WSABASEERR && status <= WSABASEERR+1004 )
428 /* It is not an NT status code but a winsock error */
429 wserr = status;
430 else
431 {
432 wserr = RtlNtStatusToDosError( status );
433 FIXME( "Status code %08x converted to DOS error code %x\n", status, wserr );
434 }
435 }
436 return wserr;
437 }
438
439 /* set last error code from NT status without mapping WSA errors */
440 static inline unsigned int set_error( unsigned int err )
441 {
442 if (err)
443 {
444 err = NtStatusToWSAError( err );
445 SetLastError( err );
446 }
447 return err;
448 }
449
450 static inline int get_sock_fd( SOCKET s, DWORD access, unsigned int *options )
451 {
452 int fd;
453 if (set_error( wine_server_handle_to_fd( SOCKET2HANDLE(s), access, &fd, options ) ))
454 return -1;
455 return fd;
456 }
457
458 static inline void release_sock_fd( SOCKET s, int fd )
459 {
460 wine_server_release_fd( SOCKET2HANDLE(s), fd );
461 }
462
463 static void _enable_event( HANDLE s, unsigned int event,
464 unsigned int sstate, unsigned int cstate )
465 {
466 SERVER_START_REQ( enable_socket_event )
467 {
468 req->handle = wine_server_obj_handle( s );
469 req->mask = event;
470 req->sstate = sstate;
471 req->cstate = cstate;
472 wine_server_call( req );
473 }
474 SERVER_END_REQ;
475 }
476
477 static int _is_blocking(SOCKET s)
478 {
479 int ret;
480 SERVER_START_REQ( get_socket_event )
481 {
482 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
483 req->service = FALSE;
484 req->c_event = 0;
485 wine_server_call( req );
486 ret = (reply->state & FD_WINE_NONBLOCKING) == 0;
487 }
488 SERVER_END_REQ;
489 return ret;
490 }
491
492 static unsigned int _get_sock_mask(SOCKET s)
493 {
494 unsigned int ret;
495 SERVER_START_REQ( get_socket_event )
496 {
497 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
498 req->service = FALSE;
499 req->c_event = 0;
500 wine_server_call( req );
501 ret = reply->mask;
502 }
503 SERVER_END_REQ;
504 return ret;
505 }
506
507 static void _sync_sock_state(SOCKET s)
508 {
509 /* do a dummy wineserver request in order to let
510 the wineserver run through its select loop once */
511 (void)_is_blocking(s);
512 }
513
514 static int _get_sock_error(SOCKET s, unsigned int bit)
515 {
516 int events[FD_MAX_EVENTS];
517
518 SERVER_START_REQ( get_socket_event )
519 {
520 req->handle = wine_server_obj_handle( SOCKET2HANDLE(s) );
521 req->service = FALSE;
522 req->c_event = 0;
523 wine_server_set_reply( req, events, sizeof(events) );
524 wine_server_call( req );
525 }
526 SERVER_END_REQ;
527 return events[bit];
528 }
529
530 static struct per_thread_data *get_per_thread_data(void)
531 {
532 struct per_thread_data * ptb = NtCurrentTeb()->WinSockData;
533 /* lazy initialization */
534 if (!ptb)
535 {
536 ptb = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ptb) );
537 NtCurrentTeb()->WinSockData = ptb;
538 }
539 return ptb;
540 }
541
542 static void free_per_thread_data(void)
543 {
544 struct per_thread_data * ptb = NtCurrentTeb()->WinSockData;
545
546 if (!ptb) return;
547
548 /* delete scratch buffers */
549 HeapFree( GetProcessHeap(), 0, ptb->he_buffer );
550 HeapFree( GetProcessHeap(), 0, ptb->se_buffer );
551 HeapFree( GetProcessHeap(), 0, ptb->pe_buffer );
552 ptb->he_buffer = NULL;
553 ptb->se_buffer = NULL;
554 ptb->pe_buffer = NULL;
555
556 HeapFree( GetProcessHeap(), 0, ptb );
557 NtCurrentTeb()->WinSockData = NULL;
558 }
559
560 /***********************************************************************
561 * DllMain (WS2_32.init)
562 */
563 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
564 {
565 TRACE("%p 0x%x %p\n", hInstDLL, fdwReason, fImpLoad);
566 switch (fdwReason) {
567 case DLL_PROCESS_ATTACH:
568 break;
569 case DLL_PROCESS_DETACH:
570 free_per_thread_data();
571 num_startup = 0;
572 break;
573 case DLL_THREAD_DETACH:
574 free_per_thread_data();
575 break;
576 }
577 return TRUE;
578 }
579
580 /***********************************************************************
581 * convert_sockopt()
582 *
583 * Converts socket flags from Windows format.
584 * Return 1 if converted, 0 if not (error).
585 */
586 static int convert_sockopt(INT *level, INT *optname)
587 {
588 unsigned int i;
589 switch (*level)
590 {
591 case WS_SOL_SOCKET:
592 *level = SOL_SOCKET;
593 for(i=0; i<sizeof(ws_sock_map)/sizeof(ws_sock_map[0]); i++) {
594 if( ws_sock_map[i][0] == *optname )
595 {
596 *optname = ws_sock_map[i][1];
597 return 1;
598 }
599 }
600 FIXME("Unknown SOL_SOCKET optname 0x%x\n", *optname);
601 break;
602 case WS_IPPROTO_TCP:
603 *level = IPPROTO_TCP;
604 for(i=0; i<sizeof(ws_tcp_map)/sizeof(ws_tcp_map[0]); i++) {
605 if ( ws_tcp_map[i][0] == *optname )
606 {
607 *optname = ws_tcp_map[i][1];
608 return 1;
609 }
610 }
611 FIXME("Unknown IPPROTO_TCP optname 0x%x\n", *optname);
612 break;
613 case WS_IPPROTO_IP:
614 *level = IPPROTO_IP;
615 for(i=0; i<sizeof(ws_ip_map)/sizeof(ws_ip_map[0]); i++) {
616 if (ws_ip_map[i][0] == *optname )
617 {
618 *optname = ws_ip_map[i][1];
619 return 1;
620 }
621 }
622 FIXME("Unknown IPPROTO_IP optname 0x%x\n", *optname);
623 break;
624 default: FIXME("Unimplemented or unknown socket level\n");
625 }
626 return 0;
627 }
628
629 /* ----------------------------------- Per-thread info (or per-process?) */
630
631 static char *strdup_lower(const char *str)
632 {
633 int i;
634 char *ret = HeapAlloc( GetProcessHeap(), 0, strlen(str) + 1 );
635
636 if (ret)
637 {
638 for (i = 0; str[i]; i++) ret[i] = tolower(str[i]);
639 ret[i] = 0;
640 }
641 else SetLastError(WSAENOBUFS);
642 return ret;
643 }
644
645 static inline int sock_error_p(int s)
646 {
647 unsigned int optval, optlen;
648
649 optlen = sizeof(optval);
650 getsockopt(s, SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
651 if (optval) WARN("\t[%i] error: %d\n", s, optval);
652 return optval != 0;
653 }
654
655 /* Utility: get the SO_RCVTIMEO or SO_SNDTIMEO socket option
656 * from an fd and return the value converted to milli seconds
657 * or -1 if there is an infinite time out */
658 static inline int get_rcvsnd_timeo( int fd, int optname)
659 {
660 struct timeval tv;
661 unsigned int len = sizeof(tv);
662 int ret = getsockopt(fd, SOL_SOCKET, optname, &tv, &len);
663 if( ret >= 0)
664 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
665 if( ret <= 0 ) /* tv == {0,0} means infinite time out */
666 return -1;
667 return ret;
668 }
669
670 /* macro wrappers for portability */
671 #ifdef SO_RCVTIMEO
672 #define GET_RCVTIMEO(fd) get_rcvsnd_timeo( (fd), SO_RCVTIMEO)
673 #else
674 #define GET_RCVTIMEO(fd) (-1)
675 #endif
676
677 #ifdef SO_SNDTIMEO
678 #define GET_SNDTIMEO(fd) get_rcvsnd_timeo( (fd), SO_SNDTIMEO)
679 #else
680 #define GET_SNDTIMEO(fd) (-1)
681 #endif
682
683 /* utility: given an fd, will block until one of the events occurs */
684 static inline int do_block( int fd, int events, int timeout )
685 {
686 struct pollfd pfd;
687 int ret;
688
689 pfd.fd = fd;
690 pfd.events = events;
691
692 while ((ret = poll(&pfd, 1, timeout)) < 0)
693 {
694 if (errno != EINTR)
695 return -1;
696 }
697 if( ret == 0 )
698 return 0;
699 return pfd.revents;
700 }
701
702 static int
703 convert_af_w2u(int windowsaf) {
704 unsigned int i;
705
706 for (i=0;i<sizeof(ws_af_map)/sizeof(ws_af_map[0]);i++)
707 if (ws_af_map[i][0] == windowsaf)
708 return ws_af_map[i][1];
709 FIXME("unhandled Windows address family %d\n", windowsaf);
710 return -1;
711 }
712
713 static int
714 convert_af_u2w(int unixaf) {
715 unsigned int i;
716
717 for (i=0;i<sizeof(ws_af_map)/sizeof(ws_af_map[0]);i++)
718 if (ws_af_map[i][1] == unixaf)
719 return ws_af_map[i][0];
720 FIXME("unhandled UNIX address family %d\n", unixaf);
721 return -1;
722 }
723
724 static int
725 convert_proto_w2u(int windowsproto) {
726 unsigned int i;
727
728 for (i=0;i<sizeof(ws_proto_map)/sizeof(ws_proto_map[0]);i++)
729 if (ws_proto_map[i][0] == windowsproto)
730 return ws_proto_map[i][1];
731 FIXME("unhandled Windows socket protocol %d\n", windowsproto);
732 return -1;
733 }
734
735 static int
736 convert_proto_u2w(int unixproto) {
737 unsigned int i;
738
739 for (i=0;i<sizeof(ws_proto_map)/sizeof(ws_proto_map[0]);i++)
740 if (ws_proto_map[i][1] == unixproto)
741 return ws_proto_map[i][0];
742 FIXME("unhandled UNIX socket protocol %d\n", unixproto);
743 return -1;
744 }
745
746 static int
747 convert_socktype_w2u(int windowssocktype) {
748 unsigned int i;
749
750 for (i=0;i<sizeof(ws_socktype_map)/sizeof(ws_socktype_map[0]);i++)
751 if (ws_socktype_map[i][0] == windowssocktype)
752 return ws_socktype_map[i][1];
753 FIXME("unhandled Windows socket type %d\n", windowssocktype);
754 return -1;
755 }
756
757 static int
758 convert_socktype_u2w(int unixsocktype) {
759 unsigned int i;
760
761 for (i=0;i<sizeof(ws_socktype_map)/sizeof(ws_socktype_map[0]);i++)
762 if (ws_socktype_map[i][1] == unixsocktype)
763 return ws_socktype_map[i][0];
764 FIXME("unhandled UNIX socket type %d\n", unixsocktype);
765 return -1;
766 }
767
768 /* ----------------------------------- API -----
769 *
770 * Init / cleanup / error checking.
771 */
772
773 /***********************************************************************
774 * WSAStartup (WS2_32.115)
775 */
776 int WINAPI WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)
777 {
778 TRACE("verReq=%x\n", wVersionRequested);
779
780 if (LOBYTE(wVersionRequested) < 1)
781 return WSAVERNOTSUPPORTED;
782
783 if (!lpWSAData) return WSAEINVAL;
784
785 num_startup++;
786
787 /* that's the whole of the negotiation for now */
788 lpWSAData->wVersion = wVersionRequested;
789 /* return winsock information */
790 lpWSAData->wHighVersion = 0x0202;
791 strcpy(lpWSAData->szDescription, "WinSock 2.0" );
792 strcpy(lpWSAData->szSystemStatus, "Running" );
793 lpWSAData->iMaxSockets = WS_MAX_SOCKETS_PER_PROCESS;
794 lpWSAData->iMaxUdpDg = WS_MAX_UDP_DATAGRAM;
795 /* don't do anything with lpWSAData->lpVendorInfo */
796 /* (some apps don't allocate the space for this field) */
797
798 TRACE("succeeded\n");
799 return 0;
800 }
801
802
803 /***********************************************************************
804 * WSACleanup (WS2_32.116)
805 */
806 INT WINAPI WSACleanup(void)
807 {
808 if (num_startup) {
809 num_startup--;
810 return 0;
811 }
812 SetLastError(WSANOTINITIALISED);
813 return SOCKET_ERROR;
814 }
815
816
817 /***********************************************************************
818 * WSAGetLastError (WINSOCK.111)
819 * WSAGetLastError (WS2_32.111)
820 */
821 INT WINAPI WSAGetLastError(void)
822 {
823 return GetLastError();
824 }
825
826 /***********************************************************************
827 * WSASetLastError (WS2_32.112)
828 */
829 void WINAPI WSASetLastError(INT iError) {
830 SetLastError(iError);
831 }
832
833 static struct WS_hostent *check_buffer_he(int size)
834 {
835 struct per_thread_data * ptb = get_per_thread_data();
836 if (ptb->he_buffer)
837 {
838 if (ptb->he_len >= size ) return ptb->he_buffer;
839 HeapFree( GetProcessHeap(), 0, ptb->he_buffer );
840 }
841 ptb->he_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->he_len = size) );
842 if (!ptb->he_buffer) SetLastError(WSAENOBUFS);
843 return ptb->he_buffer;
844 }
845
846 static struct WS_servent *check_buffer_se(int size)
847 {
848 struct per_thread_data * ptb = get_per_thread_data();
849 if (ptb->se_buffer)
850 {
851 if (ptb->se_len >= size ) return ptb->se_buffer;
852 HeapFree( GetProcessHeap(), 0, ptb->se_buffer );
853 }
854 ptb->se_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->se_len = size) );
855 if (!ptb->se_buffer) SetLastError(WSAENOBUFS);
856 return ptb->se_buffer;
857 }
858
859 static struct WS_protoent *check_buffer_pe(int size)
860 {
861 struct per_thread_data * ptb = get_per_thread_data();
862 if (ptb->pe_buffer)
863 {
864 if (ptb->pe_len >= size ) return ptb->pe_buffer;
865 HeapFree( GetProcessHeap(), 0, ptb->pe_buffer );
866 }
867 ptb->pe_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->pe_len = size) );
868 if (!ptb->pe_buffer) SetLastError(WSAENOBUFS);
869 return ptb->pe_buffer;
870 }
871
872 /* ----------------------------------- i/o APIs */
873
874 static inline BOOL supported_pf(int pf)
875 {
876 switch (pf)
877 {
878 case WS_AF_INET:
879 case WS_AF_INET6:
880 return TRUE;
881 #ifdef HAVE_IPX
882 case WS_AF_IPX:
883 return TRUE;
884 #endif
885 #ifdef HAVE_IRDA
886 case WS_AF_IRDA:
887 return TRUE;
888 #endif
889 default:
890 return FALSE;
891 }
892 }
893
894
895 /**********************************************************************/
896
897 /* Returns the length of the converted address if successful, 0 if it was too small to
898 * start with.
899 */
900 static unsigned int ws_sockaddr_ws2u(const struct WS_sockaddr* wsaddr, int wsaddrlen,
901 union generic_unix_sockaddr *uaddr)
902 {
903 unsigned int uaddrlen = 0;
904
905 switch (wsaddr->sa_family)
906 {
907 #ifdef HAVE_IPX
908 case WS_AF_IPX:
909 {
910 const struct WS_sockaddr_ipx* wsipx=(const struct WS_sockaddr_ipx*)wsaddr;
911 struct sockaddr_ipx* uipx = (struct sockaddr_ipx *)uaddr;
912
913 if (wsaddrlen<sizeof(struct WS_sockaddr_ipx))
914 return 0;
915
916 uaddrlen = sizeof(struct sockaddr_ipx);
917 memset( uaddr, 0, uaddrlen );
918 uipx->sipx_family=AF_IPX;
919 uipx->sipx_port=wsipx->sa_socket;
920 /* copy sa_netnum and sa_nodenum to sipx_network and sipx_node
921 * in one go
922 */
923 memcpy(&uipx->sipx_network,wsipx->sa_netnum,sizeof(uipx->sipx_network)+sizeof(uipx->sipx_node));
924 #ifdef IPX_FRAME_NONE
925 uipx->sipx_type=IPX_FRAME_NONE;
926 #endif
927 break;
928 }
929 #endif
930 case WS_AF_INET6: {
931 struct sockaddr_in6* uin6 = (struct sockaddr_in6 *)uaddr;
932 const struct WS_sockaddr_in6* win6 = (const struct WS_sockaddr_in6*)wsaddr;
933
934 /* Note: Windows has 2 versions of the sockaddr_in6 struct, one with
935 * scope_id, one without.
936 */
937 if (wsaddrlen >= sizeof(struct WS_sockaddr_in6_old)) {
938 uaddrlen = sizeof(struct sockaddr_in6);
939 memset( uaddr, 0, uaddrlen );
940 uin6->sin6_family = AF_INET6;
941 uin6->sin6_port = win6->sin6_port;
942 uin6->sin6_flowinfo = win6->sin6_flowinfo;
943 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
944 if (wsaddrlen >= sizeof(struct WS_sockaddr_in6)) uin6->sin6_scope_id = win6->sin6_scope_id;
945 #endif
946 memcpy(&uin6->sin6_addr,&win6->sin6_addr,16); /* 16 bytes = 128 address bits */
947 break;
948 }
949 FIXME("bad size %d for WS_sockaddr_in6\n",wsaddrlen);
950 return 0;
951 }
952 case WS_AF_INET: {
953 struct sockaddr_in* uin = (struct sockaddr_in *)uaddr;
954 const struct WS_sockaddr_in* win = (const struct WS_sockaddr_in*)wsaddr;
955
956 if (wsaddrlen<sizeof(struct WS_sockaddr_in))
957 return 0;
958 uaddrlen = sizeof(struct sockaddr_in);
959 memset( uaddr, 0, uaddrlen );
960 uin->sin_family = AF_INET;
961 uin->sin_port = win->sin_port;
962 memcpy(&uin->sin_addr,&win->sin_addr,4); /* 4 bytes = 32 address bits */
963 break;
964 }
965 #ifdef HAVE_IRDA
966 case WS_AF_IRDA: {
967 struct sockaddr_irda *uin = (struct sockaddr_irda *)uaddr;
968 const SOCKADDR_IRDA *win = (const SOCKADDR_IRDA *)wsaddr;
969
970 if (wsaddrlen < sizeof(SOCKADDR_IRDA))
971 return 0;
972 uaddrlen = sizeof(struct sockaddr_irda);
973 memset( uaddr, 0, uaddrlen );
974 uin->sir_family = AF_IRDA;
975 if (!strncmp( win->irdaServiceName, "LSAP-SEL", strlen( "LSAP-SEL" ) ))
976 {
977 unsigned int lsap_sel;
978
979 sscanf( win->irdaServiceName, "LSAP-SEL%u", &lsap_sel );
980 uin->sir_lsap_sel = lsap_sel;
981 }
982 else
983 {
984 uin->sir_lsap_sel = LSAP_ANY;
985 memcpy( uin->sir_name, win->irdaServiceName, 25 );
986 }
987 memcpy( &uin->sir_addr, win->irdaDeviceID, sizeof(uin->sir_addr) );
988 break;
989 }
990 #endif
991 case WS_AF_UNSPEC: {
992 /* Try to determine the needed space by the passed windows sockaddr space */
993 switch (wsaddrlen) {
994 default: /* likely a ipv4 address */
995 case sizeof(struct WS_sockaddr_in):
996 uaddrlen = sizeof(struct sockaddr_in);
997 break;
998 #ifdef HAVE_IPX
999 case sizeof(struct WS_sockaddr_ipx):
1000 uaddrlen = sizeof(struct sockaddr_ipx);
1001 break;
1002 #endif
1003 #ifdef HAVE_IRDA
1004 case sizeof(SOCKADDR_IRDA):
1005 uaddrlen = sizeof(struct sockaddr_irda);
1006 break;
1007 #endif
1008 case sizeof(struct WS_sockaddr_in6):
1009 case sizeof(struct WS_sockaddr_in6_old):
1010 uaddrlen = sizeof(struct sockaddr_in6);
1011 break;
1012 }
1013 memset( uaddr, 0, uaddrlen );
1014 break;
1015 }
1016 default:
1017 FIXME("Unknown address family %d, return NULL.\n", wsaddr->sa_family);
1018 return 0;
1019 }
1020 return uaddrlen;
1021 }
1022
1023 static BOOL is_sockaddr_bound(const struct sockaddr *uaddr, int uaddrlen)
1024 {
1025 switch (uaddr->sa_family)
1026 {
1027 #ifdef HAVE_IPX
1028 case AF_IPX:
1029 FIXME("don't know how to tell if IPX socket is bound, assuming it is!\n");
1030 return TRUE;
1031 #endif
1032 case AF_INET6:
1033 {
1034 static const struct sockaddr_in6 emptyAddr;
1035 const struct sockaddr_in6 *in6 = (const struct sockaddr_in6*) uaddr;
1036 return in6->sin6_port || memcmp(&in6->sin6_addr, &emptyAddr.sin6_addr, sizeof(struct in6_addr));
1037 }
1038 case AF_INET:
1039 {
1040 static const struct sockaddr_in emptyAddr;
1041 const struct sockaddr_in *in = (const struct sockaddr_in*) uaddr;
1042 return in->sin_port || memcmp(&in->sin_addr, &emptyAddr.sin_addr, sizeof(struct in_addr));
1043 }
1044 case AF_UNSPEC:
1045 return FALSE;
1046 default:
1047 FIXME("unknown address family %d\n", uaddr->sa_family);
1048 return TRUE;
1049 }
1050 }
1051
1052 /* Returns 0 if successful, -1 if the buffer is too small */
1053 static int ws_sockaddr_u2ws(const struct sockaddr* uaddr, struct WS_sockaddr* wsaddr, int* wsaddrlen)
1054 {
1055 int res;
1056
1057 switch(uaddr->sa_family)
1058 {
1059 #ifdef HAVE_IPX
1060 case AF_IPX:
1061 {
1062 const struct sockaddr_ipx* uipx=(const struct sockaddr_ipx*)uaddr;
1063 struct WS_sockaddr_ipx* wsipx=(struct WS_sockaddr_ipx*)wsaddr;
1064
1065 res=-1;
1066 switch (*wsaddrlen) /* how much can we copy? */
1067 {
1068 default:
1069 res=0; /* enough */
1070 *wsaddrlen = sizeof(*wsipx);
1071 wsipx->sa_socket=uipx->sipx_port;
1072 /* fall through */
1073 case 13:
1074 case 12:
1075 memcpy(wsipx->sa_nodenum,uipx->sipx_node,sizeof(wsipx->sa_nodenum));
1076 /* fall through */
1077 case 11:
1078 case 10:
1079 case 9:
1080 case 8:
1081 case 7:
1082 case 6:
1083 memcpy(wsipx->sa_netnum,&uipx->sipx_network,sizeof(wsipx->sa_netnum));
1084 /* fall through */
1085 case 5:
1086 case 4:
1087 case 3:
1088 case 2:
1089 wsipx->sa_family=WS_AF_IPX;
1090 /* fall through */
1091 case 1:
1092 case 0:
1093 /* way too small */
1094 break;
1095 }
1096 }
1097 break;
1098 #endif
1099 #ifdef HAVE_IRDA
1100 case AF_IRDA: {
1101 const struct sockaddr_irda *uin = (const struct sockaddr_irda *)uaddr;
1102 SOCKADDR_IRDA *win = (SOCKADDR_IRDA *)wsaddr;
1103
1104 if (*wsaddrlen < sizeof(SOCKADDR_IRDA))
1105 return -1;
1106 win->irdaAddressFamily = WS_AF_IRDA;
1107 memcpy( win->irdaDeviceID, &uin->sir_addr, sizeof(win->irdaDeviceID) );
1108 if (uin->sir_lsap_sel != LSAP_ANY)
1109 sprintf( win->irdaServiceName, "LSAP-SEL%u", uin->sir_lsap_sel );
1110 else
1111 memcpy( win->irdaServiceName, uin->sir_name,
1112 sizeof(win->irdaServiceName) );
1113 return 0;
1114 }
1115 #endif
1116 case AF_INET6: {
1117 const struct sockaddr_in6* uin6 = (const struct sockaddr_in6*)uaddr;
1118 struct WS_sockaddr_in6_old* win6old = (struct WS_sockaddr_in6_old*)wsaddr;
1119
1120 if (*wsaddrlen < sizeof(struct WS_sockaddr_in6_old))
1121 return -1;
1122 win6old->sin6_family = WS_AF_INET6;
1123 win6old->sin6_port = uin6->sin6_port;
1124 win6old->sin6_flowinfo = uin6->sin6_flowinfo;
1125 memcpy(&win6old->sin6_addr,&uin6->sin6_addr,16); /* 16 bytes = 128 address bits */
1126 *wsaddrlen = sizeof(struct WS_sockaddr_in6_old);
1127 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
1128 if (*wsaddrlen >= sizeof(struct WS_sockaddr_in6)) {
1129 struct WS_sockaddr_in6* win6 = (struct WS_sockaddr_in6*)wsaddr;
1130 win6->sin6_scope_id = uin6->sin6_scope_id;
1131 *wsaddrlen = sizeof(struct WS_sockaddr_in6);
1132 }
1133 #endif
1134 return 0;
1135 }
1136 case AF_INET: {
1137 const struct sockaddr_in* uin = (const struct sockaddr_in*)uaddr;
1138 struct WS_sockaddr_in* win = (struct WS_sockaddr_in*)wsaddr;
1139
1140 if (*wsaddrlen < sizeof(struct WS_sockaddr_in))
1141 return -1;
1142 win->sin_family = WS_AF_INET;
1143 win->sin_port = uin->sin_port;
1144 memcpy(&win->sin_addr,&uin->sin_addr,4); /* 4 bytes = 32 address bits */
1145 memset(win->sin_zero, 0, 8); /* Make sure the null padding is null */
1146 *wsaddrlen = sizeof(struct WS_sockaddr_in);
1147 return 0;
1148 }
1149 case AF_UNSPEC: {
1150 memset(wsaddr,0,*wsaddrlen);
1151 return 0;
1152 }
1153 default:
1154 FIXME("Unknown address family %d\n", uaddr->sa_family);
1155 return -1;
1156 }
1157 return res;
1158 }
1159
1160 /**************************************************************************
1161 * Functions for handling overlapped I/O
1162 **************************************************************************/
1163
1164 /* user APC called upon async completion */
1165 static void WINAPI ws2_async_apc( void *arg, IO_STATUS_BLOCK *iosb, ULONG reserved )
1166 {
1167 ws2_async *wsa = arg;
1168
1169 if (wsa->completion_func) wsa->completion_func( NtStatusToWSAError(iosb->u.Status),
1170 iosb->Information, wsa->user_overlapped,
1171 wsa->flags );
1172 HeapFree( GetProcessHeap(), 0, wsa );
1173 }
1174
1175 /***********************************************************************
1176 * WS2_recv (INTERNAL)
1177 *
1178 * Workhorse for both synchronous and asynchronous recv() operations.
1179 */
1180 static int WS2_recv( int fd, struct ws2_async *wsa )
1181 {
1182 struct msghdr hdr;
1183 union generic_unix_sockaddr unix_sockaddr;
1184 int n;
1185
1186 hdr.msg_name = NULL;
1187
1188 if (wsa->addr)
1189 {
1190 hdr.msg_namelen = sizeof(unix_sockaddr);
1191 hdr.msg_name = &unix_sockaddr;
1192 }
1193 else
1194 hdr.msg_namelen = 0;
1195
1196 hdr.msg_iov = wsa->iovec + wsa->first_iovec;
1197 hdr.msg_iovlen = wsa->n_iovecs - wsa->first_iovec;
1198 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
1199 hdr.msg_accrights = NULL;
1200 hdr.msg_accrightslen = 0;
1201 #else
1202 hdr.msg_control = NULL;
1203 hdr.msg_controllen = 0;
1204 hdr.msg_flags = 0;
1205 #endif
1206
1207 if ( (n = recvmsg(fd, &hdr, wsa->flags)) == -1 )
1208 return -1;
1209
1210 /* if this socket is connected and lpFrom is not NULL, Linux doesn't give us
1211 * msg_name and msg_namelen from recvmsg, but it does set msg_namelen to zero.
1212 *
1213 * quoting linux 2.6 net/ipv4/tcp.c:
1214 * "According to UNIX98, msg_name/msg_namelen are ignored
1215 * on connected socket. I was just happy when found this 8) --ANK"
1216 *
1217 * likewise MSDN says that lpFrom and lpFromlen are ignored for
1218 * connection-oriented sockets, so don't try to update lpFrom.
1219 */
1220 if (wsa->addr && hdr.msg_namelen)
1221 ws_sockaddr_u2ws( &unix_sockaddr.addr, wsa->addr, wsa->addrlen.ptr );
1222
1223 return n;
1224 }
1225
1226 /***********************************************************************
1227 * WS2_async_recv (INTERNAL)
1228 *
1229 * Handler for overlapped recv() operations.
1230 */
1231 static NTSTATUS WS2_async_recv( void* user, IO_STATUS_BLOCK* iosb, NTSTATUS status, void **apc)
1232 {
1233 ws2_async* wsa = user;
1234 int result = 0, fd;
1235
1236 switch (status)
1237 {
1238 case STATUS_ALERTED:
1239 if ((status = wine_server_handle_to_fd( wsa->hSocket, FILE_READ_DATA, &fd, NULL ) ))
1240 break;
1241
1242 result = WS2_recv( fd, wsa );
1243 wine_server_release_fd( wsa->hSocket, fd );
1244 if (result >= 0)
1245 {
1246 status = STATUS_SUCCESS;
1247 _enable_event( wsa->hSocket, FD_READ, 0, 0 );
1248 }
1249 else
1250 {
1251 if (errno == EINTR || errno == EAGAIN)
1252 {
1253 status = STATUS_PENDING;
1254 _enable_event( wsa->hSocket, FD_READ, 0, 0 );
1255 }
1256 else
1257 {
1258 result = 0;
1259 status = wsaErrno(); /* FIXME: is this correct ???? */
1260 }
1261 }
1262 break;
1263 }
1264 if (status != STATUS_PENDING)
1265 {
1266 iosb->u.Status = status;
1267 iosb->Information = result;
1268 *apc = ws2_async_apc;
1269 }
1270 return status;
1271 }
1272
1273 /***********************************************************************
1274 * WS2_send (INTERNAL)
1275 *
1276 * Workhorse for both synchronous and asynchronous send() operations.
1277 */
1278 static int WS2_send( int fd, struct ws2_async *wsa )
1279 {
1280 struct msghdr hdr;
1281 union generic_unix_sockaddr unix_addr;
1282
1283 hdr.msg_name = NULL;
1284 hdr.msg_namelen = 0;
1285
1286 if (wsa->addr)
1287 {
1288 hdr.msg_name = &unix_addr;
1289 hdr.msg_namelen = ws_sockaddr_ws2u( wsa->addr, wsa->addrlen.val, &unix_addr );
1290 if ( !hdr.msg_namelen )
1291 {
1292 errno = EFAULT;
1293 return -1;
1294 }
1295
1296 #if defined(HAVE_IPX) && defined(SOL_IPX)
1297 if(wsa->addr->sa_family == WS_AF_IPX)
1298 {
1299 struct sockaddr_ipx* uipx = (struct sockaddr_ipx*)hdr.msg_name;
1300 int val=0;
1301 unsigned int len=sizeof(int);
1302
1303 /* The packet type is stored at the ipx socket level; At least the linux kernel seems
1304 * to do something with it in case hdr.msg_name is NULL. Nonetheless can we use it to store
1305 * the packet type and then we can retrieve it using getsockopt. After that we can set the
1306 * ipx type in the sockaddr_opx structure with the stored value.
1307 */
1308 if(getsockopt(fd, SOL_IPX, IPX_TYPE, &val, &len) != -1)
1309 uipx->sipx_type = val;
1310 }
1311 #endif
1312 }
1313
1314 hdr.msg_iov = wsa->iovec + wsa->first_iovec;
1315 hdr.msg_iovlen = wsa->n_iovecs - wsa->first_iovec;
1316 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
1317 hdr.msg_accrights = NULL;
1318 hdr.msg_accrightslen = 0;
1319 #else
1320 hdr.msg_control = NULL;
1321 hdr.msg_controllen = 0;
1322 hdr.msg_flags = 0;
1323 #endif
1324
1325 return sendmsg(fd, &hdr, wsa->flags);
1326 }
1327
1328 /***********************************************************************
1329 * WS2_async_send (INTERNAL)
1330 *
1331 * Handler for overlapped send() operations.
1332 */
1333 static NTSTATUS WS2_async_send(void* user, IO_STATUS_BLOCK* iosb, NTSTATUS status, void **apc)
1334 {
1335 ws2_async* wsa = user;
1336 int result = 0, fd;
1337
1338 switch (status)
1339 {
1340 case STATUS_ALERTED:
1341 if ((status = wine_server_handle_to_fd( wsa->hSocket, FILE_WRITE_DATA, &fd, NULL ) ))
1342 break;
1343
1344 /* check to see if the data is ready (non-blocking) */
1345 result = WS2_send( fd, wsa );
1346 wine_server_release_fd( wsa->hSocket, fd );
1347
1348 if (result >= 0)
1349 {
1350 int totalLength = 0;
1351 unsigned int i;
1352 status = STATUS_SUCCESS;
1353 for (i = 0; i < wsa->n_iovecs; i++)
1354 totalLength += wsa->iovec[i].iov_len;
1355 if (result < totalLength)
1356 _enable_event( wsa->hSocket, FD_WRITE, 0, 0 );
1357 }
1358 else
1359 {
1360 if (errno == EINTR || errno == EAGAIN)
1361 {
1362 status = STATUS_PENDING;
1363 _enable_event( wsa->hSocket, FD_WRITE, 0, 0 );
1364 }
1365 else
1366 {
1367 /* We set the status to a winsock error code and check for that
1368 later in NtStatusToWSAError () */
1369 status = wsaErrno();
1370 result = 0;
1371 }
1372 }
1373 break;
1374 }
1375 if (status != STATUS_PENDING)
1376 {
1377 iosb->u.Status = status;
1378 iosb->Information = result;
1379 *apc = ws2_async_apc;
1380 }
1381 return status;
1382 }
1383
1384 /***********************************************************************
1385 * WS2_async_shutdown (INTERNAL)
1386 *
1387 * Handler for shutdown() operations on overlapped sockets.
1388 */
1389 static NTSTATUS WS2_async_shutdown( void* user, PIO_STATUS_BLOCK iosb, NTSTATUS status, void **apc )
1390 {
1391 ws2_async* wsa = user;
1392 int fd, err = 1;
1393
1394 switch (status)
1395 {
1396 case STATUS_ALERTED:
1397 if ((status = wine_server_handle_to_fd( wsa->hSocket, 0, &fd, NULL ) ))
1398 break;
1399
1400 switch ( wsa->type )
1401 {
1402 case ASYNC_TYPE_READ: err = shutdown( fd, 0 ); break;
1403 case ASYNC_TYPE_WRITE: err = shutdown( fd, 1 ); break;
1404 }
1405 wine_server_release_fd( wsa->hSocket, fd );
1406 status = err ? wsaErrno() : STATUS_SUCCESS;
1407 break;
1408 }
1409 iosb->u.Status = status;
1410 *apc = ws2_async_apc;
1411 return status;
1412 }
1413
1414 /***********************************************************************
1415 * WS2_register_async_shutdown (INTERNAL)
1416 *
1417 * Helper function for WS_shutdown() on overlapped sockets.
1418 */
1419 static int WS2_register_async_shutdown( SOCKET s, int type )
1420 {
1421 struct ws2_async *wsa;
1422 NTSTATUS status;
1423
1424 TRACE("s %ld type %d\n", s, type);
1425
1426 wsa = HeapAlloc( GetProcessHeap(), 0, sizeof(*wsa) );
1427 if ( !wsa )
1428 return WSAEFAULT;
1429
1430 wsa->hSocket = SOCKET2HANDLE(s);
1431 wsa->type = type;
1432 wsa->completion_func = NULL;
1433
1434 SERVER_START_REQ( register_async )
1435 {
1436 req->type = type;
1437 req->async.handle = wine_server_obj_handle( wsa->hSocket );
1438 req->async.callback = wine_server_client_ptr( WS2_async_shutdown );
1439 req->async.iosb = wine_server_client_ptr( &wsa->local_iosb );
1440 req->async.arg = wine_server_client_ptr( wsa );
1441 req->async.cvalue = 0;
1442 status = wine_server_call( req );
1443 }
1444 SERVER_END_REQ;
1445
1446 if (status != STATUS_PENDING)
1447 {
1448 HeapFree( GetProcessHeap(), 0, wsa );
1449 return NtStatusToWSAError( status );
1450 }
1451 return 0;
1452 }
1453
1454 /***********************************************************************
1455 * accept (WS2_32.1)
1456 */
1457 SOCKET WINAPI WS_accept(SOCKET s, struct WS_sockaddr *addr,
1458 int *addrlen32)
1459 {
1460 SOCKET as;
1461 BOOL is_blocking;
1462
1463 TRACE("socket %04lx\n", s );
1464 is_blocking = _is_blocking(s);
1465
1466 do {
1467 if (is_blocking)
1468 {
1469 int fd = get_sock_fd( s, FILE_READ_DATA, NULL );
1470 if (fd == -1) return INVALID_SOCKET;
1471 /* block here */
1472 do_block(fd, POLLIN, -1);
1473 _sync_sock_state(s); /* let wineserver notice connection */
1474 release_sock_fd( s, fd );
1475 /* retrieve any error codes from it */
1476 SetLastError(_get_sock_error(s, FD_ACCEPT_BIT));
1477 /* FIXME: care about the error? */
1478 }
1479 SERVER_START_REQ( accept_socket )
1480 {
1481 req->lhandle = wine_server_obj_handle( SOCKET2HANDLE(s) );
1482 req->access = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
1483 req->attributes = OBJ_INHERIT;
1484 set_error( wine_server_call( req ) );
1485 as = HANDLE2SOCKET( wine_server_ptr_handle( reply->handle ));
1486 }
1487 SERVER_END_REQ;
1488 if (as)
1489 {
1490 if (addr) WS_getpeername(as, addr, addrlen32);
1491 return as;
1492 }
1493 } while (is_blocking);
1494 return INVALID_SOCKET;
1495 }
1496
1497 /***********************************************************************
1498 * bind (WS2_32.2)
1499 */
1500 int WINAPI WS_bind(SOCKET s, const struct WS_sockaddr* name, int namelen)
1501 {
1502 int fd = get_sock_fd( s, 0, NULL );
1503 int res = SOCKET_ERROR;
1504
1505 TRACE("socket %04lx, ptr %p %s, length %d\n", s, name, debugstr_sockaddr(name), namelen);
1506
1507 if (fd != -1)
1508 {
1509 if (!name || (name->sa_family && !supported_pf(name->sa_family)))
1510 {
1511 SetLastError(WSAEAFNOSUPPORT);
1512 }
1513 else
1514 {
1515 union generic_unix_sockaddr uaddr;
1516 unsigned int uaddrlen = ws_sockaddr_ws2u(name, namelen, &uaddr);
1517 if (!uaddrlen)
1518 {
1519 SetLastError(WSAEFAULT);
1520 }
1521 else
1522 {
1523 #ifdef IPV6_V6ONLY
1524 const struct sockaddr_in6 *in6 = (const struct sockaddr_in6*) &uaddr;
1525 if (name->sa_family == WS_AF_INET6 &&
1526 !memcmp(&in6->sin6_addr, &in6addr_any, sizeof(struct in6_addr)))
1527 {
1528 int enable = 1;
1529 if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &enable, sizeof(enable)) == -1)
1530 {
1531 release_sock_fd( s, fd );
1532 SetLastError(WSAEAFNOSUPPORT);
1533 return SOCKET_ERROR;
1534 }
1535 }
1536 #endif
1537 if (name->sa_family == WS_AF_INET)
1538 {
1539 struct sockaddr_in *in4 = (struct sockaddr_in*) &uaddr;
1540 if (memcmp(&in4->sin_addr, magic_loopback_addr, 4) == 0)
1541 {
1542 /* Trying to bind to the default host interface, using
1543 * INADDR_ANY instead*/
1544 WARN("Trying to bind to magic IP address, using "
1545 "INADDR_ANY instead.\n");
1546 in4->sin_addr.s_addr = htonl(WS_INADDR_ANY);
1547 }
1548 }
1549 if (bind(fd, &uaddr.addr, uaddrlen) < 0)
1550 {
1551 int loc_errno = errno;
1552 WARN("\tfailure - errno = %i\n", errno);
1553 errno = loc_errno;
1554 switch (errno)
1555 {
1556 case EBADF:
1557 SetLastError(WSAENOTSOCK);
1558 break;
1559 case EADDRNOTAVAIL:
1560 SetLastError(WSAEINVAL);
1561 break;
1562 default:
1563 SetLastError(wsaErrno());
1564 break;
1565 }
1566 }
1567 else
1568 {
1569 res=0; /* success */
1570 }
1571 }
1572 }
1573 release_sock_fd( s, fd );
1574 }
1575 return res;
1576 }
1577
1578 /***********************************************************************
1579 * closesocket (WS2_32.3)
1580 */
1581 int WINAPI WS_closesocket(SOCKET s)
1582 {
1583 TRACE("socket %04lx\n", s);
1584 if (CloseHandle(SOCKET2HANDLE(s))) return 0;
1585 return SOCKET_ERROR;
1586 }
1587
1588 /***********************************************************************
1589 * connect (WS2_32.4)
1590 */
1591 int WINAPI WS_connect(SOCKET s, const struct WS_sockaddr* name, int namelen)
1592 {
1593 int fd = get_sock_fd( s, FILE_READ_DATA, NULL );
1594
1595 TRACE("socket %04lx, ptr %p %s, length %d\n", s, name, debugstr_sockaddr(name), namelen);
1596
1597 if (fd != -1)
1598 {
1599 union generic_unix_sockaddr uaddr;
1600 unsigned int uaddrlen = ws_sockaddr_ws2u(name, namelen, &uaddr);
1601
1602 if (!uaddrlen)
1603 {
1604 SetLastError(WSAEFAULT);
1605 }
1606 else
1607 {
1608 if (name->sa_family == WS_AF_INET)
1609 {
1610 struct sockaddr_in *in4 = (struct sockaddr_in*) &uaddr;
1611 if (memcmp(&in4->sin_addr, magic_loopback_addr, 4) == 0)
1612 {
1613 /* Trying to connect to magic replace-loopback address,
1614 * assuming we really want to connect to localhost */
1615 TRACE("Trying to connect to magic IP address, using "
1616 "INADDR_LOOPBACK instead.\n");
1617 in4->sin_addr.s_addr = htonl(WS_INADDR_LOOPBACK);
1618 }
1619 }
1620
1621 if (connect(fd, &uaddr.addr, uaddrlen) == 0)
1622 goto connect_success;
1623 }
1624
1625 if (errno == EINPROGRESS)
1626 {
1627 /* tell wineserver that a connection is in progress */
1628 _enable_event(SOCKET2HANDLE(s), FD_CONNECT|FD_READ|FD_WRITE,
1629 FD_CONNECT|FD_READ|FD_WRITE,
1630 FD_WINE_CONNECTED|FD_WINE_LISTENING);
1631 if (_is_blocking(s))
1632 {
1633 int result;
1634 /* block here */
1635 do_block(fd, POLLIN | POLLOUT, -1);
1636 _sync_sock_state(s); /* let wineserver notice connection */
1637 /* retrieve any error codes from it */
1638 result = _get_sock_error(s, FD_CONNECT_BIT);
1639 if (result)
1640 SetLastError(result);
1641 else
1642 {
1643 goto connect_success;
1644 }
1645 }
1646 else
1647 {
1648 SetLastError(WSAEWOULDBLOCK);
1649 }
1650 }
1651 else
1652 {
1653 SetLastError(wsaErrno());
1654 }
1655 release_sock_fd( s, fd );
1656 }
1657 return SOCKET_ERROR;
1658
1659 connect_success:
1660 release_sock_fd( s, fd );
1661 _enable_event(SOCKET2HANDLE(s), FD_CONNECT|FD_READ|FD_WRITE,
1662 FD_WINE_CONNECTED|FD_READ|FD_WRITE,
1663 FD_CONNECT|FD_WINE_LISTENING);
1664 return 0;
1665 }
1666
1667 /***********************************************************************
1668 * WSAConnect (WS2_32.30)
1669 */
1670 int WINAPI WSAConnect( SOCKET s, const struct WS_sockaddr* name, int namelen,
1671 LPWSABUF lpCallerData, LPWSABUF lpCalleeData,
1672 LPQOS lpSQOS, LPQOS lpGQOS )
1673 {
1674 if ( lpCallerData || lpCalleeData || lpSQOS || lpGQOS )
1675 FIXME("unsupported parameters!\n");
1676 return WS_connect( s, name, namelen );
1677 }
1678
1679
1680 /***********************************************************************
1681 * getpeername (WS2_32.5)
1682 */
1683 int WINAPI WS_getpeername(SOCKET s, struct WS_sockaddr *name, int *namelen)
1684 {
1685 int fd;
1686 int res;
1687
1688 TRACE("socket: %04lx, ptr %p, len %08x\n", s, name, *namelen);
1689
1690 /* Check if what we've received is valid. Should we use IsBadReadPtr? */
1691 if( (name == NULL) || (namelen == NULL) )
1692 {
1693 SetLastError( WSAEFAULT );
1694 return SOCKET_ERROR;
1695 }
1696
1697 fd = get_sock_fd( s, 0, NULL );
1698 res = SOCKET_ERROR;
1699
1700 if (fd != -1)
1701 {
1702 union generic_unix_sockaddr uaddr;
1703 unsigned int uaddrlen = sizeof(uaddr);
1704
1705 if (getpeername(fd, &uaddr.addr, &uaddrlen) != 0)
1706 {
1707 SetLastError(wsaErrno());
1708 }
1709 else if (ws_sockaddr_u2ws(&uaddr.addr, name, namelen) != 0)
1710 {
1711 /* The buffer was too small */
1712 SetLastError(WSAEFAULT);
1713 }
1714 else
1715 {
1716 res=0;
1717 }
1718 release_sock_fd( s, fd );
1719 }
1720 return res;
1721 }
1722
1723 /***********************************************************************
1724 * getsockname (WS2_32.6)
1725 */
1726 int WINAPI WS_getsockname(SOCKET s, struct WS_sockaddr *name, int *namelen)
1727 {
1728 int fd;
1729 int res;
1730
1731 TRACE("socket: %04lx, ptr %p, len %8x\n", s, name, *namelen);
1732
1733 /* Check if what we've received is valid. Should we use IsBadReadPtr? */
1734 if( (name == NULL) || (namelen == NULL) )
1735 {
1736 SetLastError( WSAEFAULT );
1737 return SOCKET_ERROR;
1738 }
1739
1740 fd = get_sock_fd( s, 0, NULL );
1741 res = SOCKET_ERROR;
1742
1743 if (fd != -1)
1744 {
1745 union generic_unix_sockaddr uaddr;
1746 unsigned int uaddrlen = sizeof(uaddr);
1747
1748 if (getsockname(fd, &uaddr.addr, &uaddrlen) != 0)
1749 {
1750 SetLastError(wsaErrno());
1751 }
1752 else if (!is_sockaddr_bound(&uaddr.addr, uaddrlen))
1753 {
1754 SetLastError(WSAEINVAL);
1755 }
1756 else if (ws_sockaddr_u2ws(&uaddr.addr, name, namelen) != 0)
1757 {
1758 /* The buffer was too small */
1759 SetLastError(WSAEFAULT);
1760 }
1761 else
1762 {
1763 res=0;
1764 }
1765 release_sock_fd( s, fd );
1766 }
1767 return res;
1768 }
1769
1770 /***********************************************************************
1771 * getsockopt (WS2_32.7)
1772 */
1773 INT WINAPI WS_getsockopt(SOCKET s, INT level,
1774 INT optname, char *optval, INT *optlen)
1775 {
1776 int fd;
1777 INT ret = 0;
1778
1779 TRACE("socket: %04lx, level 0x%x, name 0x%x, ptr %p, len %d\n",
1780 s, level, optname, optval, *optlen);
1781
1782 switch(level)
1783 {
1784 case WS_SOL_SOCKET:
1785 {
1786 switch(optname)
1787 {
1788 /* Handle common cases. The special cases are below, sorted
1789 * alphabetically */
1790 case WS_SO_ACCEPTCONN:
1791 case WS_SO_BROADCAST:
1792 case WS_SO_DEBUG:
1793 case WS_SO_ERROR:
1794 case WS_SO_KEEPALIVE:
1795 case WS_SO_OOBINLINE:
1796 case WS_SO_RCVBUF:
1797 case WS_SO_REUSEADDR:
1798 case WS_SO_SNDBUF:
1799 case WS_SO_TYPE:
1800 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1801 return SOCKET_ERROR;
1802 convert_sockopt(&level, &optname);
1803 if (getsockopt(fd, level, optname, optval, (unsigned int *)optlen) != 0 )
1804 {
1805 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1806 ret = SOCKET_ERROR;
1807 }
1808 release_sock_fd( s, fd );
1809 return ret;
1810
1811 case WS_SO_DONTLINGER:
1812 {
1813 struct linger lingval;
1814 unsigned int len = sizeof(struct linger);
1815
1816 if (!optlen || *optlen < sizeof(BOOL)|| !optval)
1817 {
1818 SetLastError(WSAEFAULT);
1819 return SOCKET_ERROR;
1820 }
1821 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1822 return SOCKET_ERROR;
1823
1824 if (getsockopt(fd, SOL_SOCKET, SO_LINGER, &lingval, &len) != 0 )
1825 {
1826 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1827 ret = SOCKET_ERROR;
1828 }
1829 else
1830 {
1831 *(BOOL *)optval = (lingval.l_onoff) ? FALSE : TRUE;
1832 *optlen = sizeof(BOOL);
1833 }
1834
1835 release_sock_fd( s, fd );
1836 return ret;
1837 }
1838
1839 /* As mentioned in setsockopt, Windows ignores this, so we
1840 * always return true here */
1841 case WS_SO_DONTROUTE:
1842 if (!optlen || *optlen < sizeof(BOOL) || !optval)
1843 {
1844 SetLastError(WSAEFAULT);
1845 return SOCKET_ERROR;
1846 }
1847 *(BOOL *)optval = TRUE;
1848 *optlen = sizeof(BOOL);
1849 return 0;
1850
1851 case WS_SO_LINGER:
1852 {
1853 struct linger lingval;
1854 unsigned int len = sizeof(struct linger);
1855
1856 /* struct linger and LINGER have different sizes */
1857 if (!optlen || *optlen < sizeof(LINGER) || !optval)
1858 {
1859 SetLastError(WSAEFAULT);
1860 return SOCKET_ERROR;
1861 }
1862 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1863 return SOCKET_ERROR;
1864
1865 if (getsockopt(fd, SOL_SOCKET, SO_LINGER, &lingval, &len) != 0 )
1866 {
1867 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1868 ret = SOCKET_ERROR;
1869 }
1870 else
1871 {
1872 ((LINGER *)optval)->l_onoff = lingval.l_onoff;
1873 ((LINGER *)optval)->l_linger = lingval.l_linger;
1874 *optlen = sizeof(struct linger);
1875 }
1876
1877 release_sock_fd( s, fd );
1878 return ret;
1879 }
1880
1881 case WS_SO_MAX_MSG_SIZE:
1882 if (!optlen || *optlen < sizeof(int) || !optval)
1883 {
1884 SetLastError(WSAEFAULT);
1885 return SOCKET_ERROR;
1886 }
1887 TRACE("getting global SO_MAX_MSG_SIZE = 65507\n");
1888 *(int *)optval = 65507;
1889 *optlen = sizeof(int);
1890 return 0;
1891
1892 /* SO_OPENTYPE does not require a valid socket handle. */
1893 case WS_SO_OPENTYPE:
1894 if (!optlen || *optlen < sizeof(int) || !optval)
1895 {
1896 SetLastError(WSAEFAULT);
1897 return SOCKET_ERROR;
1898 }
1899 *(int *)optval = get_per_thread_data()->opentype;
1900 *optlen = sizeof(int);
1901 TRACE("getting global SO_OPENTYPE = 0x%x\n", *((int*)optval) );
1902 return 0;
1903
1904 #ifdef SO_RCVTIMEO
1905 case WS_SO_RCVTIMEO:
1906 #endif
1907 #ifdef SO_SNDTIMEO
1908 case WS_SO_SNDTIMEO:
1909 #endif
1910 #if defined(SO_RCVTIMEO) || defined(SO_SNDTIMEO)
1911 {
1912 struct timeval tv;
1913 unsigned int len = sizeof(struct timeval);
1914
1915 if (!optlen || *optlen < sizeof(int)|| !optval)
1916 {
1917 SetLastError(WSAEFAULT);
1918 return SOCKET_ERROR;
1919 }
1920 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1921 return SOCKET_ERROR;
1922
1923 convert_sockopt(&level, &optname);
1924 if (getsockopt(fd, level, optname, &tv, &len) != 0 )
1925 {
1926 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1927 ret = SOCKET_ERROR;
1928 }
1929 else
1930 {
1931 *(int *)optval = tv.tv_sec * 1000 + tv.tv_usec / 1000;
1932 *optlen = sizeof(int);
1933 }
1934
1935 release_sock_fd( s, fd );
1936 return ret;
1937 }
1938 #endif
1939 default:
1940 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
1941 SetLastError(WSAENOPROTOOPT);
1942 return SOCKET_ERROR;
1943 } /* end switch(optname) */
1944 }/* end case WS_SOL_SOCKET */
1945 #ifdef HAVE_IPX
1946 case NSPROTO_IPX:
1947 {
1948 struct WS_sockaddr_ipx addr;
1949 IPX_ADDRESS_DATA *data;
1950 int namelen;
1951 switch(optname)
1952 {
1953 case IPX_PTYPE:
1954 if ((fd = get_sock_fd( s, 0, NULL )) == -1) return SOCKET_ERROR;
1955 #ifdef SOL_IPX
1956 if(getsockopt(fd, SOL_IPX, IPX_TYPE, optval, (unsigned int*)optlen) == -1)
1957 {
1958 ret = SOCKET_ERROR;
1959 }
1960 #else
1961 {
1962 struct ipx val;
1963 socklen_t len=sizeof(struct ipx);
1964 if(getsockopt(fd, 0, SO_DEFAULT_HEADERS, &val, &len) == -1 )
1965 ret = SOCKET_ERROR;
1966 else
1967 *optval = (int)val.ipx_pt;
1968 }
1969 #endif
1970 TRACE("ptype: %d (fd: %d)\n", *(int*)optval, fd);
1971 release_sock_fd( s, fd );
1972 return ret;
1973
1974 case IPX_ADDRESS:
1975 /*
1976 * On a Win2000 system with one network card there are usually
1977 * three ipx devices one with a speed of 28.8kbps, 10Mbps and 100Mbps.
1978 * Using this call you can then retrieve info about this all.
1979 * In case of Linux it is a bit different. Usually you have
1980 * only "one" device active and further it is not possible to
1981 * query things like the linkspeed.
1982 */
1983 FIXME("IPX_ADDRESS\n");
1984 namelen = sizeof(struct WS_sockaddr_ipx);
1985 memset(&addr, 0, sizeof(struct WS_sockaddr_ipx));
1986 WS_getsockname(s, (struct WS_sockaddr*)&addr, &namelen);
1987
1988 data = (IPX_ADDRESS_DATA*)optval;
1989 memcpy(data->nodenum,addr.sa_nodenum,sizeof(data->nodenum));
1990 memcpy(data->netnum,addr.sa_netnum,sizeof(data->netnum));
1991 data->adapternum = 0;
1992 data->wan = FALSE; /* We are not on a wan for now .. */
1993 data->status = FALSE; /* Since we are not on a wan, the wan link isn't up */
1994 data->maxpkt = 1467; /* This value is the default one, at least on Win2k/WinXP */
1995 data->linkspeed = 100000; /* Set the line speed in 100bit/s to 10 Mbit;
1996 * note 1MB = 1000kB in this case */
1997 return 0;
1998
1999 case IPX_MAX_ADAPTER_NUM:
2000 FIXME("IPX_MAX_ADAPTER_NUM\n");
2001 *(int*)optval = 1; /* As noted under IPX_ADDRESS we have just one card. */
2002 return 0;
2003
2004 default:
2005 FIXME("IPX optname:%x\n", optname);
2006 return SOCKET_ERROR;
2007 }/* end switch(optname) */
2008 } /* end case NSPROTO_IPX */
2009 #endif
2010
2011 #ifdef HAVE_IRDA
2012 case WS_SOL_IRLMP:
2013 switch(optname)
2014 {
2015 case WS_IRLMP_ENUMDEVICES:
2016 {
2017 static const int MAX_IRDA_DEVICES = 10;
2018 char buf[sizeof(struct irda_device_list) +
2019 (MAX_IRDA_DEVICES - 1) * sizeof(struct irda_device_info)];
2020 int fd, res;
2021 socklen_t len = sizeof(buf);
2022
2023 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2024 return SOCKET_ERROR;
2025 res = getsockopt( fd, SOL_IRLMP, IRLMP_ENUMDEVICES, buf, &len );
2026 if (res < 0)
2027 {
2028 SetLastError(wsaErrno());
2029 return SOCKET_ERROR;
2030 }
2031 else
2032 {
2033 struct irda_device_list *src = (struct irda_device_list *)buf;
2034 DEVICELIST *dst = (DEVICELIST *)optval;
2035 INT needed = sizeof(DEVICELIST), i;
2036
2037 if (src->len > 0)
2038 needed += (src->len - 1) * sizeof(IRDA_DEVICE_INFO);
2039 if (*optlen < needed)
2040 {
2041 SetLastError(WSAEFAULT);
2042 return SOCKET_ERROR;
2043 }
2044 *optlen = needed;
2045 TRACE("IRLMP_ENUMDEVICES: %d devices found:\n", src->len);
2046 dst->numDevice = src->len;
2047 for (i = 0; i < src->len; i++)
2048 {
2049 TRACE("saddr = %08x, daddr = %08x, info = %s, hints = %02x%02x\n",
2050 src->dev[i].saddr, src->dev[i].daddr,
2051 src->dev[i].info, src->dev[i].hints[0],
2052 src->dev[i].hints[1]);
2053 memcpy( dst->Device[i].irdaDeviceID,
2054 &src->dev[i].daddr,
2055 sizeof(dst->Device[i].irdaDeviceID) ) ;
2056 memcpy( dst->Device[i].irdaDeviceName,
2057 &src->dev[i].info,
2058 sizeof(dst->Device[i].irdaDeviceName) ) ;
2059 memcpy( &dst->Device[i].irdaDeviceHints1,
2060 &src->dev[i].hints[0],
2061 sizeof(dst->Device[i].irdaDeviceHints1) ) ;
2062 memcpy( &dst->Device[i].irdaDeviceHints2,
2063 &src->dev[i].hints[1],
2064 sizeof(dst->Device[i].irdaDeviceHints2) ) ;
2065 dst->Device[i].irdaCharSet = src->dev[i].charset;
2066 }
2067 return 0;
2068 }
2069 }
2070 default:
2071 FIXME("IrDA optname:0x%x\n", optname);
2072 return SOCKET_ERROR;
2073 }
2074 break; /* case WS_SOL_IRLMP */
2075 #endif
2076
2077 /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */
2078 case WS_IPPROTO_TCP:
2079 switch(optname)
2080 {
2081 case WS_TCP_NODELAY:
2082 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2083 return SOCKET_ERROR;
2084 convert_sockopt(&level, &optname);
2085 if (getsockopt(fd, level, optname, optval, (unsigned int *)optlen) != 0 )
2086 {
2087 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
2088 ret = SOCKET_ERROR;
2089 }
2090 release_sock_fd( s, fd );
2091 return ret;
2092 }
2093 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
2094 return SOCKET_ERROR;
2095
2096 case WS_IPPROTO_IP:
2097 switch(optname)
2098 {
2099 case WS_IP_ADD_MEMBERSHIP:
2100 case WS_IP_DROP_MEMBERSHIP:
2101 #ifdef IP_HDRINCL
2102 case WS_IP_HDRINCL:
2103 #endif
2104 case WS_IP_MULTICAST_IF:
2105 case WS_IP_MULTICAST_LOOP:
2106 case WS_IP_MULTICAST_TTL:
2107 case WS_IP_OPTIONS:
2108 case WS_IP_TOS:
2109 case WS_IP_TTL:
2110 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
2111 return SOCKET_ERROR;
2112 convert_sockopt(&level, &optname);
2113 if (getsockopt(fd, level, optname, optval, (unsigned int *)optlen) != 0 )
2114 {
2115 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
2116 ret = SOCKET_ERROR;
2117 }
2118 release_sock_fd( s, fd );
2119 return ret;
2120 case WS_IP_DONTFRAGMENT:
2121 FIXME("WS_IP_DONTFRAGMENT is always false!\n");
2122 *(BOOL*)optval = FALSE;
2123 return 0;
2124 }
2125 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
2126 return SOCKET_ERROR;
2127
2128 default:
2129 FIXME("Unknown level: 0x%08x\n", level);
2130 return SOCKET_ERROR;
2131 } /* end switch(level) */
2132 }
2133
2134 /***********************************************************************
2135 * htonl (WINSOCK.8)
2136 * htonl (WS2_32.8)
2137 */
2138 WS_u_long WINAPI WS_htonl(WS_u_long hostlong)
2139 {
2140 return htonl(hostlong);
2141 }
2142
2143
2144 /***********************************************************************
2145 * htons (WINSOCK.9)
2146 * htons (WS2_32.9)
2147 */
2148 WS_u_short WINAPI WS_htons(WS_u_short hostshort)
2149 {
2150 return htons(hostshort);
2151 }
2152
2153 /***********************************************************************
2154 * WSAHtonl (WS2_32.46)
2155 * From MSDN description of error codes, this function should also
2156 * check if WinSock has been initialized and the socket is a valid
2157 * socket. But why? This function only translates a host byte order
2158 * u_long into a network byte order u_long...
2159 */
2160 int WINAPI WSAHtonl(SOCKET s, WS_u_long hostlong, WS_u_long *lpnetlong)
2161 {
2162 if (lpnetlong)
2163 {
2164 *lpnetlong = htonl(hostlong);
2165 return 0;
2166 }
2167 WSASetLastError(WSAEFAULT);
2168 return SOCKET_ERROR;
2169 }
2170
2171 /***********************************************************************
2172 * WSAHtons (WS2_32.47)
2173 * From MSDN description of error codes, this function should also
2174 * check if WinSock has been initialized and the socket is a valid
2175 * socket. But why? This function only translates a host byte order
2176 * u_short into a network byte order u_short...
2177 */
2178 int WINAPI WSAHtons(SOCKET s, WS_u_short hostshort, WS_u_short *lpnetshort)
2179 {
2180
2181 if (lpnetshort)
2182 {
2183 *lpnetshort = htons(hostshort);
2184 return 0;
2185 }
2186 WSASetLastError(WSAEFAULT);
2187 return SOCKET_ERROR;
2188 }
2189
2190
2191 /***********************************************************************
2192 * inet_addr (WINSOCK.10)
2193 * inet_addr (WS2_32.11)
2194 */
2195 WS_u_long WINAPI WS_inet_addr(const char *cp)
2196 {
2197 if (!cp) return INADDR_NONE;
2198 return inet_addr(cp);
2199 }
2200
2201
2202 /***********************************************************************
2203 * ntohl (WINSOCK.14)
2204 * ntohl (WS2_32.14)
2205 */
2206 WS_u_long WINAPI WS_ntohl(WS_u_long netlong)
2207 {
2208 return ntohl(netlong);
2209 }
2210
2211
2212 /***********************************************************************
2213 * ntohs (WINSOCK.15)
2214 * ntohs (WS2_32.15)
2215 */
2216 WS_u_short WINAPI WS_ntohs(WS_u_short netshort)
2217 {
2218 return ntohs(netshort);
2219 }
2220
2221
2222 /***********************************************************************
2223 * inet_ntoa (WS2_32.12)
2224 */
2225 char* WINAPI WS_inet_ntoa(struct WS_in_addr in)
2226 {
2227 /* use "buffer for dummies" here because some applications have a
2228 * propensity to decode addresses in ws_hostent structure without
2229 * saving them first...
2230 */
2231 static char dbuffer[16]; /* Yes, 16: 4*3 digits + 3 '.' + 1 '\0' */
2232
2233 char* s = inet_ntoa(*((struct in_addr*)&in));
2234 if( s )
2235 {
2236 strcpy(dbuffer, s);
2237 return dbuffer;
2238 }
2239 SetLastError(wsaErrno());
2240 return NULL;
2241 }
2242
2243 /**********************************************************************
2244 * WSAIoctl (WS2_32.50)
2245 *
2246 */
2247 INT WINAPI WSAIoctl(SOCKET s,
2248 DWORD dwIoControlCode,
2249 LPVOID lpvInBuffer,
2250 DWORD cbInBuffer,
2251 LPVOID lpbOutBuffer,
2252 DWORD cbOutBuffer,
2253 LPDWORD lpcbBytesReturned,
2254 LPWSAOVERLAPPED lpOverlapped,
2255 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
2256 {
2257 TRACE("%ld, 0x%08x, %p, %d, %p, %d, %p, %p, %p\n",
2258 s, dwIoControlCode, lpvInBuffer, cbInBuffer, lpbOutBuffer,
2259 cbOutBuffer, lpcbBytesReturned, lpOverlapped, lpCompletionRoutine);
2260
2261 switch( dwIoControlCode )
2262 {
2263 case WS_FIONBIO:
2264 if (cbInBuffer != sizeof(WS_u_long)) {
2265 WSASetLastError(WSAEFAULT);
2266 return SOCKET_ERROR;
2267 }
2268 return WS_ioctlsocket( s, WS_FIONBIO, lpvInBuffer);
2269
2270 case WS_FIONREAD:
2271 if (cbOutBuffer != sizeof(WS_u_long)) {
2272 WSASetLastError(WSAEFAULT);
2273 return SOCKET_ERROR;
2274 }
2275 return WS_ioctlsocket( s, WS_FIONREAD, lpbOutBuffer);
2276
2277 case WS_SIO_GET_INTERFACE_LIST:
2278 {
2279 INTERFACE_INFO* intArray = (INTERFACE_INFO*)lpbOutBuffer;
2280 DWORD size, numInt, apiReturn;
2281 int fd;
2282
2283 TRACE("-> SIO_GET_INTERFACE_LIST request\n");
2284
2285 if (!lpbOutBuffer)
2286 {
2287 WSASetLastError(WSAEFAULT);
2288 return SOCKET_ERROR;
2289 }
2290 if (!lpcbBytesReturned)
2291 {
2292 WSASetLastError(WSAEFAULT);
2293 return SOCKET_ERROR;
2294 }
2295
2296 fd = get_sock_fd( s, 0, NULL );
2297 if (fd == -1) return SOCKET_ERROR;
2298
2299 apiReturn = GetAdaptersInfo(NULL, &size);
2300 if (apiReturn == ERROR_NO_DATA)
2301 {
2302 numInt = 0;
2303 }
2304 else if (apiReturn == ERROR_BUFFER_OVERFLOW)
2305 {
2306 PIP_ADAPTER_INFO table = HeapAlloc(GetProcessHeap(),0,size);
2307
2308 if (table)
2309 {
2310 if (GetAdaptersInfo(table, &size) == NO_ERROR)
2311 {
2312 PIP_ADAPTER_INFO ptr;
2313
2314 if (size*sizeof(INTERFACE_INFO)/sizeof(IP_ADAPTER_INFO) > cbOutBuffer)
2315 {
2316 WARN("Buffer too small = %u, cbOutBuffer = %u\n", size, cbOutBuffer);
2317 HeapFree(GetProcessHeap(),0,table);
2318 release_sock_fd( s, fd );
2319 WSASetLastError(WSAEFAULT);
2320 return SOCKET_ERROR;
2321 }
2322 for (ptr = table, numInt = 0; ptr;
2323 ptr = ptr->Next, intArray++, numInt++)
2324 {
2325 unsigned int addr, mask, bcast;
2326 struct ifreq ifInfo;
2327
2328 /* Socket Status Flags */
2329 lstrcpynA(ifInfo.ifr_name, ptr->AdapterName, IFNAMSIZ);
2330 if (ioctl(fd, SIOCGIFFLAGS, &ifInfo) < 0)
2331 {
2332 ERR("Error obtaining status flags for socket!\n");
2333 HeapFree(GetProcessHeap(),0,table);
2334 release_sock_fd( s, fd );
2335 WSASetLastError(WSAEINVAL);
2336 return SOCKET_ERROR;
2337 }
2338 else
2339 {
2340 /* set flags; the values of IFF_* are not the same
2341 under Linux and Windows, therefore must generate
2342 new flags */
2343 intArray->iiFlags = 0;
2344 if (ifInfo.ifr_flags & IFF_BROADCAST)
2345 intArray->iiFlags |= WS_IFF_BROADCAST;
2346 #ifdef IFF_POINTOPOINT
2347 if (ifInfo.ifr_flags & IFF_POINTOPOINT)
2348 intArray->iiFlags |= WS_IFF_POINTTOPOINT;
2349 #endif
2350 if (ifInfo.ifr_flags & IFF_LOOPBACK)
2351 intArray->iiFlags |= WS_IFF_LOOPBACK;
2352 if (ifInfo.ifr_flags & IFF_UP)
2353 intArray->iiFlags |= WS_IFF_UP;
2354 if (ifInfo.ifr_flags & IFF_MULTICAST)
2355 intArray->iiFlags |= WS_IFF_MULTICAST;
2356 }
2357
2358 addr = inet_addr(ptr->IpAddressList.IpAddress.String);
2359 mask = inet_addr(ptr->IpAddressList.IpMask.String);
2360 bcast = addr | ~mask;
2361 intArray->iiAddress.AddressIn.sin_family = AF_INET;
2362 intArray->iiAddress.AddressIn.sin_port = 0;
2363 intArray->iiAddress.AddressIn.sin_addr.WS_s_addr =
2364 addr;
2365 intArray->iiNetmask.AddressIn.sin_family = AF_INET;
2366 intArray->iiNetmask.AddressIn.sin_port = 0;
2367 intArray->iiNetmask.AddressIn.sin_addr.WS_s_addr =
2368 mask;
2369 intArray->iiBroadcastAddress.AddressIn.sin_family =
2370 AF_INET;
2371 intArray->iiBroadcastAddress.AddressIn.sin_port = 0;
2372 intArray->iiBroadcastAddress.AddressIn.sin_addr.
2373 WS_s_addr = bcast;
2374 }
2375 }
2376 else
2377 {
2378 ERR("Unable to get interface table!\n");
2379 release_sock_fd( s, fd );
2380 HeapFree(GetProcessHeap(),0,table);
2381 WSASetLastError(WSAEINVAL);
2382 return SOCKET_ERROR;
2383 }
2384 HeapFree(GetProcessHeap(),0,table);
2385 }
2386 else
2387 {
2388 release_sock_fd( s, fd );
2389 WSASetLastError(WSAEINVAL);
2390 return SOCKET_ERROR;
2391 }
2392 }
2393 else
2394 {
2395 ERR("Unable to get interface table!\n");
2396 release_sock_fd( s, fd );
2397 WSASetLastError(WSAEINVAL);
2398 return SOCKET_ERROR;
2399 }
2400 /* Calculate the size of the array being returned */
2401 *lpcbBytesReturned = sizeof(INTERFACE_INFO) * numInt;
2402 release_sock_fd( s, fd );
2403 break;
2404 }
2405
2406 case WS_SIO_ADDRESS_LIST_CHANGE:
2407 FIXME("-> SIO_ADDRESS_LIST_CHANGE request: stub\n");
2408 /* FIXME: error and return code depend on whether socket was created
2409 * with WSA_FLAG_OVERLAPPED, but there is no easy way to get this */
2410 break;
2411
2412 case WS_SIO_ADDRESS_LIST_QUERY:
2413 {
2414 DWORD size;
2415
2416 TRACE("-> SIO_ADDRESS_LIST_QUERY request\n");
2417
2418 if (!lpcbBytesReturned)
2419 {
2420 WSASetLastError(WSAEFAULT);
2421 return SOCKET_ERROR;
2422 }
2423
2424 if (GetAdaptersInfo(NULL, &size) == ERROR_BUFFER_OVERFLOW)
2425 {
2426 IP_ADAPTER_INFO *p, *table = HeapAlloc(GetProcessHeap(), 0, size);
2427 DWORD need, num;
2428
2429 if (!table || GetAdaptersInfo(table, &size))
2430 {
2431 HeapFree(GetProcessHeap(), 0, table);
2432 WSASetLastError(WSAEINVAL);
2433 return SOCKET_ERROR;
2434 }
2435
2436 for (p = table, num = 0; p; p = p->Next)
2437 if (p->IpAddressList.IpAddress.String[0]) num++;
2438
2439 need = sizeof(SOCKET_ADDRESS_LIST) + sizeof(SOCKET_ADDRESS) * (num - 1);
2440 need += sizeof(SOCKADDR) * num;
2441 *lpcbBytesReturned = need;
2442
2443 if (need > cbOutBuffer)
2444 {
2445 HeapFree(GetProcessHeap(), 0, table);
2446 WSASetLastError(WSAEFAULT);
2447 return SOCKET_ERROR;
2448 }
2449
2450 if (lpbOutBuffer)
2451 {
2452 unsigned int i;
2453 SOCKET_ADDRESS *sa;
2454 SOCKET_ADDRESS_LIST *sa_list = (SOCKET_ADDRESS_LIST *)lpbOutBuffer;
2455 SOCKADDR_IN *sockaddr;
2456
2457 sa = sa_list->Address;
2458 sockaddr = (SOCKADDR_IN *)((char *)sa + num * sizeof(SOCKET_ADDRESS));
2459 sa_list->iAddressCount = num;
2460
2461 for (p = table, i = 0; p; p = p->Next)
2462 {
2463 if (!p->IpAddressList.IpAddress.String[0]) continue;
2464
2465 sa[i].lpSockaddr = (SOCKADDR *)&sockaddr[i];
2466 sa[i].iSockaddrLength = sizeof(SOCKADDR);
2467
2468 sockaddr[i].sin_family = AF_INET;
2469 sockaddr[i].sin_port = 0;
2470 sockaddr[i].sin_addr.WS_s_addr = inet_addr(p->IpAddressList.IpAddress.String);
2471 i++;
2472 }
2473 }
2474
2475 HeapFree(GetProcessHeap(), 0, table);
2476 return 0;
2477 }
2478 else
2479 {
2480 WARN("unable to get IP address list\n");
2481 WSASetLastError(WSAEINVAL);
2482 return SOCKET_ERROR;
2483 }
2484 }
2485 case WS_SIO_FLUSH:
2486 FIXME("SIO_FLUSH: stub.\n");
2487 break;
2488
2489 case WS_SIO_GET_EXTENSION_FUNCTION_POINTER:
2490 FIXME("SIO_GET_EXTENSION_FUNCTION_POINTER %s: stub\n", debugstr_guid(lpvInBuffer));
2491 WSASetLastError(WSAEOPNOTSUPP);
2492 return SOCKET_ERROR;
2493
2494 case WS_SIO_KEEPALIVE_VALS:
2495 {
2496 int fd;
2497 struct tcp_keepalive *k = lpvInBuffer;
2498 int keepalive = k->onoff ? 1 : 0;
2499 int keepidle = k->keepalivetime / 1000;
2500 int keepintvl = k->keepaliveinterval / 1000;
2501
2502 if (!lpvInBuffer)
2503 {
2504 WSASetLastError(WSAEINVAL);
2505 return SOCKET_ERROR;
2506 }
2507
2508 TRACE("onoff: %d, keepalivetime: %d, keepaliveinterval: %d\n", keepalive, keepidle, keepintvl);
2509
2510 fd = get_sock_fd(s, 0, NULL);
2511 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive, sizeof(int)) == -1)
2512 {
2513 release_sock_fd(s, fd);
2514 WSASetLastError(WSAEINVAL);
2515 return SOCKET_ERROR;
2516 }
2517 #if defined(TCP_KEEPIDLE) && defined(TCP_KEEPINTVL)
2518 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, (void *)&keepidle, sizeof(int)) == -1)
2519 {
2520 release_sock_fd(s, fd);
2521 WSASetLastError(WSAEINVAL);
2522 return SOCKET_ERROR;
2523 }
2524 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, (void *)&keepintvl, sizeof(int)) == -1)
2525 {
2526 release_sock_fd(s, fd);
2527 WSASetLastError(WSAEINVAL);
2528 return SOCKET_ERROR;
2529 }
2530 #else
2531 FIXME("ignoring keepalive interval and timeout\n");
2532 #endif
2533
2534 release_sock_fd(s, fd);
2535 break;
2536 }
2537 default:
2538 FIXME("unsupported WS_IOCTL cmd (%08x)\n", dwIoControlCode);
2539 WSASetLastError(WSAEOPNOTSUPP);
2540 return SOCKET_ERROR;
2541 }
2542
2543 return 0;
2544 }
2545
2546
2547 /***********************************************************************
2548 * ioctlsocket (WS2_32.10)
2549 */
2550 int WINAPI WS_ioctlsocket(SOCKET s, LONG cmd, WS_u_long *argp)
2551 {
2552 int fd;
2553 LONG newcmd = cmd;
2554
2555 TRACE("socket %04lx, cmd %08x, ptr %p\n", s, cmd, argp);
2556 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
2557 if(IS_INTRESOURCE(argp))
2558 {
2559 SetLastError(WSAEFAULT);
2560 return SOCKET_ERROR;
2561 }
2562
2563 switch( cmd )
2564 {
2565 case WS_FIONREAD:
2566 newcmd=FIONREAD;
2567 break;
2568
2569 case WS_FIONBIO:
2570 if( _get_sock_mask(s) )
2571 {
2572 /* AsyncSelect()'ed sockets are always nonblocking */
2573 if (*argp) return 0;
2574 SetLastError(WSAEINVAL);
2575 return SOCKET_ERROR;
2576 }
2577 if (*argp)
2578 _enable_event(SOCKET2HANDLE(s), 0, FD_WINE_NONBLOCKING, 0);
2579 else
2580 _enable_event(SOCKET2HANDLE(s), 0, 0, FD_WINE_NONBLOCKING);
2581 return 0;
2582
2583 case WS_SIOCATMARK:
2584 newcmd=SIOCATMARK;
2585 break;
2586
2587 case WS_FIOASYNC:
2588 WARN("Warning: WS1.1 shouldn't be using async I/O\n");
2589 SetLastError(WSAEINVAL);
2590 return SOCKET_ERROR;
2591
2592 case SIOCGIFBRDADDR:
2593 case SIOCGIFNETMASK:
2594 case SIOCGIFADDR:
2595 /* These don't need any special handling. They are used by
2596 WsControl, and are here to suppress an unnecessary warning. */
2597 break;
2598
2599 default:
2600 /* Netscape tries hard to use bogus ioctl 0x667e */
2601 /* FIXME: 0x667e above is ('f' << 8) | 126, and is a low word of
2602 * FIONBIO (_IOW('f', 126, u_long)), how that should be handled?
2603 */
2604 WARN("\tunknown WS_IOCTL cmd (%08x)\n", cmd);
2605 break;
2606 }
2607
2608 fd = get_sock_fd( s, 0, NULL );
2609 if (fd != -1)
2610 {
2611 if( ioctl(fd, newcmd, (char*)argp ) == 0 )
2612 {
2613 release_sock_fd( s, fd );
2614 return 0;
2615 }
2616 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
2617 release_sock_fd( s, fd );
2618 }
2619 return SOCKET_ERROR;
2620 }
2621
2622 /***********************************************************************
2623 * listen (WS2_32.13)
2624 */
2625 int WINAPI WS_listen(SOCKET s, int backlog)
2626 {
2627 int fd = get_sock_fd( s, FILE_READ_DATA, NULL );
2628
2629 TRACE("socket %04lx, backlog %d\n", s, backlog);
2630 if (fd != -1)
2631 {
2632 if (listen(fd, backlog) == 0)
2633 {
2634 release_sock_fd( s, fd );
2635 _enable_event(SOCKET2HANDLE(s), FD_ACCEPT,
2636 FD_WINE_LISTENING,
2637 FD_CONNECT|FD_WINE_CONNECTED);
2638 return 0;
2639 }
2640 SetLastError(wsaErrno());
2641 release_sock_fd( s, fd );
2642 }
2643 return SOCKET_ERROR;
2644 }
2645
2646 /***********************************************************************
2647 * recv (WS2_32.16)
2648 */
2649 int WINAPI WS_recv(SOCKET s, char *buf, int len, int flags)
2650 {
2651 DWORD n, dwFlags = flags;
2652 WSABUF wsabuf;
2653
2654 wsabuf.len = len;
2655 wsabuf.buf = buf;
2656
2657 if ( WSARecvFrom(s, &wsabuf, 1, &n, &dwFlags, NULL, NULL, NULL, NULL) == SOCKET_ERROR )
2658 return SOCKET_ERROR;
2659 else
2660 return n;
2661 }
2662
2663 /***********************************************************************
2664 * recvfrom (WS2_32.17)
2665 */
2666 int WINAPI WS_recvfrom(SOCKET s, char *buf, INT len, int flags,
2667 struct WS_sockaddr *from, int *fromlen)
2668 {
2669 DWORD n, dwFlags = flags;
2670 WSABUF wsabuf;
2671
2672 wsabuf.len = len;
2673 wsabuf.buf = buf;
2674
2675 if ( WSARecvFrom(s, &wsabuf, 1, &n, &dwFlags, from, fromlen, NULL, NULL) == SOCKET_ERROR )
2676 return SOCKET_ERROR;
2677 else
2678 return n;
2679 }
2680
2681 /* allocate a poll array for the corresponding fd sets */
2682 static struct pollfd *fd_sets_to_poll( const WS_fd_set *readfds, const WS_fd_set *writefds,
2683 const WS_fd_set *exceptfds, int *count_ptr )
2684 {
2685 unsigned int i, j = 0, count = 0;
2686 struct pollfd *fds;
2687
2688 if (readfds) count += readfds->fd_count;
2689 if (writefds) count += writefds->fd_count;
2690 if (exceptfds) count += exceptfds->fd_count;
2691 *count_ptr = count;
2692 if (!count) return NULL;
2693 if (!(fds = HeapAlloc( GetProcessHeap(), 0, count * sizeof(fds[0])))) return NULL;
2694 if (readfds)
2695 for (i = 0; i < readfds->fd_count; i++, j++)
2696 {
2697 fds[j].fd = get_sock_fd( readfds->fd_array[i], FILE_READ_DATA, NULL );
2698 fds[j].events = POLLIN;
2699 fds[j].revents = 0;
2700 }
2701 if (writefds)
2702 for (i = 0; i < writefds->fd_count; i++, j++)
2703 {
2704 fds[j].fd = get_sock_fd( writefds->fd_array[i], FILE_WRITE_DATA, NULL );
2705 fds[j].events = POLLOUT;
2706 fds[j].revents = 0;
2707 }
2708 if (exceptfds)
2709 for (i = 0; i < exceptfds->fd_count; i++, j++)
2710 {
2711 fds[j].fd = get_sock_fd( exceptfds->fd_array[i], 0, NULL );
2712 fds[j].events = POLLHUP;
2713 fds[j].revents = 0;
2714 }
2715 return fds;
2716 }
2717
2718 /* release the file descriptor obtained in fd_sets_to_poll */
2719 /* must be called with the original fd_set arrays, before calling get_poll_results */
2720 static void release_poll_fds( const WS_fd_set *readfds, const WS_fd_set *writefds,
2721 const WS_fd_set *exceptfds, struct pollfd *fds )
2722 {
2723 unsigned int i, j = 0;
2724
2725 if (readfds)
2726 {
2727 for (i = 0; i < readfds->fd_count; i++, j++)
2728 if (fds[j].fd != -1) release_sock_fd( readfds->fd_array[i], fds[j].fd );
2729 }
2730 if (writefds)
2731 {
2732 for (i = 0; i < writefds->fd_count; i++, j++)
2733 if (fds[j].fd != -1) release_sock_fd( writefds->fd_array[i], fds[j].fd );
2734 }
2735 if (exceptfds)
2736 {
2737 for (i = 0; i < exceptfds->fd_count; i++, j++)
2738 if (fds[j].fd != -1)
2739 {
2740 /* make sure we have a real error before releasing the fd */
2741 if (!sock_error_p( fds[j].fd )) fds[j].revents = 0;
2742 release_sock_fd( exceptfds->fd_array[i], fds[j].fd );
2743 }
2744 }
2745 }
2746
2747 /* map the poll results back into the Windows fd sets */
2748 static int get_poll_results( WS_fd_set *readfds, WS_fd_set *writefds, WS_fd_set *exceptfds,
2749 const struct pollfd *fds )
2750 {
2751 unsigned int i, j = 0, k, total = 0;
2752
2753 if (readfds)
2754 {
2755 for (i = k = 0; i < readfds->fd_count; i++, j++)
2756 if (fds[j].revents) readfds->fd_array[k++] = readfds->fd_array[i];
2757 readfds->fd_count = k;
2758 total += k;
2759 }
2760 if (writefds)
2761 {
2762 for (i = k = 0; i < writefds->fd_count; i++, j++)
2763 if (fds[j].revents) writefds->fd_array[k++] = writefds->fd_array[i];
2764 writefds->fd_count = k;
2765 total += k;
2766 }
2767 if (exceptfds)
2768 {
2769 for (i = k = 0; i < exceptfds->fd_count; i++, j++)
2770 if (fds[j].revents) exceptfds->fd_array[k++] = exceptfds->fd_array[i];
2771 exceptfds->fd_count = k;
2772 total += k;
2773 }
2774 return total;
2775 }
2776
2777
2778 /***********************************************************************
2779 * select (WS2_32.18)
2780 */
2781 int WINAPI WS_select(int nfds, WS_fd_set *ws_readfds,
2782 WS_fd_set *ws_writefds, WS_fd_set *ws_exceptfds,
2783 const struct WS_timeval* ws_timeout)
2784 {
2785 struct pollfd *pollfds;
2786 int count, ret, timeout = -1;
2787
2788 TRACE("read %p, write %p, excp %p timeout %p\n",
2789 ws_readfds, ws_writefds, ws_exceptfds, ws_timeout);
2790
2791 if (!(pollfds = fd_sets_to_poll( ws_readfds, ws_writefds, ws_exceptfds, &count )) && count)
2792 {
2793 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
2794 return SOCKET_ERROR;
2795 }
2796
2797 if (ws_timeout) timeout = (ws_timeout->tv_sec * 1000) + (ws_timeout->tv_usec + 999) / 1000;
2798
2799 ret = poll( pollfds, count, timeout );
2800 release_poll_fds( ws_readfds, ws_writefds, ws_exceptfds, pollfds );
2801
2802 if (ret == -1) SetLastError(wsaErrno());
2803 else ret = get_poll_results( ws_readfds, ws_writefds, ws_exceptfds, pollfds );
2804 HeapFree( GetProcessHeap(), 0, pollfds );
2805 return ret;
2806 }
2807
2808 /* helper to send completion messages for client-only i/o operation case */
2809 static void WS_AddCompletion( SOCKET sock, ULONG_PTR CompletionValue, NTSTATUS CompletionStatus,
2810 ULONG Information )
2811 {
2812 NTSTATUS status;
2813
2814 SERVER_START_REQ( add_fd_completion )
2815 {
2816 req->handle = wine_server_obj_handle( SOCKET2HANDLE(sock) );
2817 req->cvalue = CompletionValue;
2818 req->status = CompletionStatus;
2819 req->information = Information;
2820 status = wine_server_call( req );
2821 }
2822 SERVER_END_REQ;
2823 }
2824
2825
2826 /***********************************************************************
2827 * send (WS2_32.19)
2828 */
2829 int WINAPI WS_send(SOCKET s, const char *buf, int len, int flags)
2830 {
2831 DWORD n;
2832 WSABUF wsabuf;
2833
2834 wsabuf.len = len;
2835 wsabuf.buf = (char*) buf;
2836
2837 if ( WSASendTo( s, &wsabuf, 1, &n, flags, NULL, 0, NULL, NULL) == SOCKET_ERROR )
2838 return SOCKET_ERROR;
2839 else
2840 return n;
2841 }
2842
2843 /***********************************************************************
2844 * WSASend (WS2_32.72)
2845 */
2846 INT WINAPI WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
2847 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
2848 LPWSAOVERLAPPED lpOverlapped,
2849 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
2850 {
2851 return WSASendTo( s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags,
2852 NULL, 0, lpOverlapped, lpCompletionRoutine );
2853 }
2854
2855 /***********************************************************************
2856 * WSASendDisconnect (WS2_32.73)
2857 */
2858 INT WINAPI WSASendDisconnect( SOCKET s, LPWSABUF lpBuffers )
2859 {
2860 return WS_shutdown( s, SD_SEND );
2861 }
2862
2863
2864 /***********************************************************************
2865 * WSASendTo (WS2_32.74)
2866 */
2867 INT WINAPI WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
2868 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
2869 const struct WS_sockaddr *to, int tolen,
2870 LPWSAOVERLAPPED lpOverlapped,
2871 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
2872 {
2873 unsigned int i, options;
2874 int n, fd, err;
2875 struct ws2_async *wsa;
2876 int totalLength = 0;
2877 ULONG_PTR cvalue = (lpOverlapped && ((ULONG_PTR)lpOverlapped->hEvent & 1) == 0) ? (ULONG_PTR)lpOverlapped : 0;
2878
2879 TRACE("socket %04lx, wsabuf %p, nbufs %d, flags %d, to %p, tolen %d, ovl %p, func %p\n",
2880 s, lpBuffers, dwBufferCount, dwFlags,
2881 to, tolen, lpOverlapped, lpCompletionRoutine);
2882
2883 fd = get_sock_fd( s, FILE_WRITE_DATA, &options );
2884 TRACE( "fd=%d, options=%x\n", fd, options );
2885
2886 if ( fd == -1 ) return SOCKET_ERROR;
2887
2888 if (!(wsa = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET(struct ws2_async, iovec[dwBufferCount]) )))
2889 {
2890 err = WSAEFAULT;
2891 goto error;
2892 }
2893
2894 wsa->hSocket = SOCKET2HANDLE(s);
2895 wsa->addr = (struct WS_sockaddr *)to;
2896 wsa->addrlen.val = tolen;
2897 wsa->flags = dwFlags;
2898 wsa->n_iovecs = dwBufferCount;
2899 wsa->first_iovec = 0;
2900 for ( i = 0; i < dwBufferCount; i++ )
2901 {
2902 wsa->iovec[i].iov_base = lpBuffers[i].buf;
2903 wsa->iovec[i].iov_len = lpBuffers[i].len;
2904 totalLength += lpBuffers[i].len;
2905 }
2906
2907 if (!lpNumberOfBytesSent)
2908 {
2909 err = WSAEFAULT;
2910 goto error;
2911 }
2912
2913 for (;;)
2914 {
2915 n = WS2_send( fd, wsa );
2916 if (n != -1 || errno != EINTR) break;
2917 }
2918 if (n == -1 && errno != EAGAIN)
2919 {
2920 err = wsaErrno();
2921 if (cvalue) WS_AddCompletion( s, cvalue, err, 0 );
2922 goto error;
2923 }
2924
2925 if ((lpOverlapped || lpCompletionRoutine) &&
2926 !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT)))
2927 {
2928 IO_STATUS_BLOCK *iosb = lpOverlapped ? (IO_STATUS_BLOCK *)lpOverlapped : &wsa->local_iosb;
2929
2930 wsa->user_overlapped = lpOverlapped;
2931 wsa->completion_func = lpCompletionRoutine;
2932 release_sock_fd( s, fd );
2933
2934 if (n == -1)
2935 {
2936 iosb->u.Status = STATUS_PENDING;
2937 iosb->Information = 0;
2938
2939 SERVER_START_REQ( register_async )
2940 {
2941 req->type = ASYNC_TYPE_WRITE;
2942 req->async.handle = wine_server_obj_handle( wsa->hSocket );
2943 req->async.callback = wine_server_client_ptr( WS2_async_send );
2944 req->async.iosb = wine_server_client_ptr( iosb );
2945 req->async.arg = wine_server_client_ptr( wsa );
2946 req->async.event = wine_server_obj_handle( lpCompletionRoutine ? 0 : lpOverlapped->hEvent );
2947 req->async.cvalue = cvalue;
2948 err = wine_server_call( req );
2949 }
2950 SERVER_END_REQ;
2951
2952 if (err != STATUS_PENDING) HeapFree( GetProcessHeap(), 0, wsa );
2953 WSASetLastError( NtStatusToWSAError( err ));
2954 return SOCKET_ERROR;
2955 }
2956
2957 iosb->u.Status = STATUS_SUCCESS;
2958 iosb->Information = n;
2959 *lpNumberOfBytesSent = n;
2960 if (!wsa->completion_func)
2961 {
2962 if (cvalue) WS_AddCompletion( s, cvalue, STATUS_SUCCESS, n );
2963 if (lpOverlapped->hEvent) SetEvent( lpOverlapped->hEvent );
2964 HeapFree( GetProcessHeap(), 0, wsa );
2965 }
2966 else NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC)ws2_async_apc,
2967 (ULONG_PTR)wsa, (ULONG_PTR)iosb, 0 );
2968 WSASetLastError(0);
2969 return 0;
2970 }
2971
2972 if ( _is_blocking(s) )
2973 {
2974 /* On a blocking non-overlapped stream socket,
2975 * sending blocks until the entire buffer is sent. */
2976 DWORD timeout_start = GetTickCount();
2977
2978 *lpNumberOfBytesSent = 0;
2979
2980 while (wsa->first_iovec < dwBufferCount)
2981 {
2982 struct pollfd pfd;
2983 int timeout = GET_SNDTIMEO(fd);
2984
2985 if (n >= 0)
2986 {
2987 *lpNumberOfBytesSent += n;
2988 while (wsa->first_iovec < dwBufferCount && wsa->iovec[wsa->first_iovec].iov_len <= n)
2989 n -= wsa->iovec[wsa->first_iovec++].iov_len;
2990 if (wsa->first_iovec >= dwBufferCount) break;
2991 wsa->iovec[wsa->first_iovec].iov_base = (char*)wsa->iovec[wsa->first_iovec].iov_base + n;
2992 wsa->iovec[wsa->first_iovec].iov_len -= n;
2993 }
2994
2995 if (timeout != -1)
2996 {
2997 timeout -= GetTickCount() - timeout_start;
2998 if (timeout < 0) timeout = 0;
2999 }
3000
3001 pfd.fd = fd;
3002 pfd.events = POLLOUT;
3003
3004 if (!timeout || !poll( &pfd, 1, timeout ))
3005 {
3006 err = WSAETIMEDOUT;
3007 goto error; /* msdn says a timeout in send is fatal */
3008 }
3009
3010 n = WS2_send( fd, wsa );
3011 if (n == -1 && errno != EAGAIN && errno != EINTR)
3012 {
3013 err = wsaErrno();
3014 goto error;
3015 }
3016 }
3017 }
3018 else /* non-blocking */
3019 {
3020 if (n < totalLength)
3021 _enable_event(SOCKET2HANDLE(s), FD_WRITE, 0, 0);
3022 if (n == -1)
3023 {
3024 err = WSAEWOULDBLOCK;
3025 goto error;
3026 }
3027 *lpNumberOfBytesSent = n;
3028 }
3029
3030 TRACE(" -> %i bytes\n", *lpNumberOfBytesSent);
3031
3032 HeapFree( GetProcessHeap(), 0, wsa );
3033 release_sock_fd( s, fd );
3034 WSASetLastError(0);
3035 return 0;
3036
3037 error:
3038 HeapFree( GetProcessHeap(), 0, wsa );
3039 release_sock_fd( s, fd );
3040 WARN(" -> ERROR %d\n", err);
3041 WSASetLastError(err);
3042 return SOCKET_ERROR;
3043 }
3044
3045 /***********************************************************************
3046 * sendto (WS2_32.20)
3047 */
3048 int WINAPI WS_sendto(SOCKET s, const char *buf, int len, int flags,
3049 const struct WS_sockaddr *to, int tolen)
3050 {
3051 DWORD n;
3052 WSABUF wsabuf;
3053
3054 wsabuf.len = len;
3055 wsabuf.buf = (char*) buf;
3056
3057 if ( WSASendTo(s, &wsabuf, 1, &n, flags, to, tolen, NULL, NULL) == SOCKET_ERROR )
3058 return SOCKET_ERROR;
3059 else
3060 return n;
3061 }
3062
3063 /***********************************************************************
3064 * setsockopt (WS2_32.21)
3065 */
3066 int WINAPI WS_setsockopt(SOCKET s, int level, int optname,
3067 const char *optval, int optlen)
3068 {
3069 int fd;
3070 int woptval;
3071 struct linger linger;
3072 struct timeval tval;
3073
3074 TRACE("socket: %04lx, level 0x%x, name 0x%x, ptr %p, len %d\n",
3075 s, level, optname, optval, optlen);
3076
3077 /* some broken apps pass the value directly instead of a pointer to it */
3078 if(IS_INTRESOURCE(optval))
3079 {
3080 SetLastError(WSAEFAULT);
3081 return SOCKET_ERROR;
3082 }
3083
3084 switch(level)
3085 {
3086 case WS_SOL_SOCKET:
3087 switch(optname)
3088 {
3089 /* Some options need some conversion before they can be sent to
3090 * setsockopt. The conversions are done here, then they will fall though
3091 * to the general case. Special options that are not passed to
3092 * setsockopt follow below that.*/
3093
3094 case WS_SO_DONTLINGER:
3095 linger.l_onoff = *((const int*)optval) ? 0: 1;
3096 linger.l_linger = 0;
3097 level = SOL_SOCKET;
3098 optname = SO_LINGER;
3099 optval = (char*)&linger;
3100 optlen = sizeof(struct linger);
3101 break;
3102
3103 case WS_SO_LINGER:
3104 linger.l_onoff = ((LINGER*)optval)->l_onoff;
3105 linger.l_linger = ((LINGER*)optval)->l_linger;
3106 /* FIXME: what is documented behavior if SO_LINGER optval
3107 is null?? */
3108 level = SOL_SOCKET;
3109 optname = SO_LINGER;
3110 optval = (char*)&linger;
3111 optlen = sizeof(struct linger);
3112 break;
3113
3114 case WS_SO_RCVBUF:
3115 if (*(const int*)optval < 2048)
3116 {
3117 WARN("SO_RCVBF for %d bytes is too small: ignored\n", *(const int*)optval );
3118 return 0;
3119 }
3120 /* Fall through */
3121
3122 /* The options listed here don't need any special handling. Thanks to
3123 * the conversion happening above, options from there will fall through
3124 * to this, too.*/
3125 case WS_SO_ACCEPTCONN:
3126 case WS_SO_BROADCAST:
3127 case WS_SO_ERROR:
3128 case WS_SO_KEEPALIVE:
3129 case WS_SO_OOBINLINE:
3130 /* BSD socket SO_REUSEADDR is not 100% compatible to winsock semantics.
3131 * however, using it the BSD way fixes bug 8513 and seems to be what
3132 * most programmers assume, anyway */
3133 case WS_SO_REUSEADDR:
3134 case WS_SO_SNDBUF:
3135 case WS_SO_TYPE:
3136 convert_sockopt(&level, &optname);
3137 break;
3138
3139 /* SO_DEBUG is a privileged operation, ignore it. */
3140 case WS_SO_DEBUG:
3141 TRACE("Ignoring SO_DEBUG\n");
3142 return 0;
3143
3144 /* For some reason the game GrandPrixLegends does set SO_DONTROUTE on its
3145 * socket. According to MSDN, this option is silently ignored.*/
3146 case WS_SO_DONTROUTE:
3147 TRACE("Ignoring SO_DONTROUTE\n");
3148 return 0;
3149
3150 /* Stops two sockets from being bound to the same port. Always happens
3151 * on unix systems, so just drop it. */
3152 case WS_SO_EXCLUSIVEADDRUSE:
3153 TRACE("Ignoring SO_EXCLUSIVEADDRUSE, is always set.\n");
3154 return 0;
3155
3156 /* SO_OPENTYPE does not require a valid socket handle. */
3157 case WS_SO_OPENTYPE:
3158 if (!optlen || optlen < sizeof(int) || !optval)
3159 {
3160 SetLastError(WSAEFAULT);
3161 return SOCKET_ERROR;
3162 }
3163 get_per_thread_data()->opentype = *(const int *)optval;
3164 TRACE("setting global SO_OPENTYPE = 0x%x\n", *((int*)optval) );
3165 return 0;
3166
3167 #ifdef SO_RCVTIMEO
3168 case WS_SO_RCVTIMEO:
3169 #endif
3170 #ifdef SO_SNDTIMEO
3171 case WS_SO_SNDTIMEO:
3172 #endif
3173 #if defined(SO_RCVTIMEO) || defined(SO_SNDTIMEO)
3174 if (optval && optlen == sizeof(UINT32)) {
3175 /* WinSock passes milliseconds instead of struct timeval */
3176 tval.tv_usec = (*(const UINT32*)optval % 1000) * 1000;
3177 tval.tv_sec = *(const UINT32*)optval / 1000;
3178 /* min of 500 milliseconds */
3179 if (tval.tv_sec == 0 && tval.tv_usec < 500000)
3180 tval.tv_usec = 500000;
3181 optlen = sizeof(struct timeval);
3182 optval = (char*)&tval;
3183 } else if (optlen == sizeof(struct timeval)) {
3184 WARN("SO_SND/RCVTIMEO for %d bytes: assuming unixism\n", optlen);
3185 } else {
3186 WARN("SO_SND/RCVTIMEO for %d bytes is weird: ignored\n", optlen);
3187 return 0;
3188 }
3189 convert_sockopt(&level, &optname);
3190 break;
3191 #endif
3192
3193 default:
3194 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
3195 SetLastError(WSAENOPROTOOPT);
3196 return SOCKET_ERROR;
3197 }
3198 break; /* case WS_SOL_SOCKET */
3199
3200 #ifdef HAVE_IPX
3201 case NSPROTO_IPX:
3202 switch(optname)
3203 {
3204 case IPX_PTYPE:
3205 fd = get_sock_fd( s, 0, NULL );
3206 TRACE("trying to set IPX_PTYPE: %d (fd: %d)\n", *(const int*)optval, fd);
3207
3208 /* We try to set the ipx type on ipx socket level. */
3209 #ifdef SOL_IPX
3210 if(setsockopt(fd, SOL_IPX, IPX_TYPE, optval, optlen) == -1)
3211 {
3212 ERR("IPX: could not set ipx option type; expect weird behaviour\n");
3213 release_sock_fd( s, fd );
3214 return SOCKET_ERROR;
3215 }
3216 #else
3217 {
3218 struct ipx val;
3219 /* Should we retrieve val using a getsockopt call and then
3220 * set the modified one? */
3221 val.ipx_pt = *optval;
3222 setsockopt(fd, 0, SO_DEFAULT_HEADERS, &val, sizeof(struct ipx));
3223 }
3224 #endif
3225 release_sock_fd( s, fd );
3226 return 0;
3227
3228 case IPX_FILTERPTYPE:
3229 /* Sets the receive filter packet type, at the moment we don't support it */
3230 FIXME("IPX_FILTERPTYPE: %x\n", *optval);
3231 /* Returning 0 is better for now than returning a SOCKET_ERROR */
3232 return 0;
3233
3234 default:
3235 FIXME("opt_name:%x\n", optname);
3236 return SOCKET_ERROR;
3237 }
3238 break; /* case NSPROTO_IPX */
3239 #endif
3240
3241 /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */
3242 case WS_IPPROTO_TCP:
3243 switch(optname)
3244 {
3245 case WS_TCP_NODELAY:
3246 convert_sockopt(&level, &optname);
3247 break;
3248 default:
3249 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
3250 return SOCKET_ERROR;
3251 }
3252 break;
3253
3254 case WS_IPPROTO_IP:
3255 switch(optname)
3256 {
3257 case WS_IP_ADD_MEMBERSHIP:
3258 case WS_IP_DROP_MEMBERSHIP:
3259 #ifdef IP_HDRINCL
3260 case WS_IP_HDRINCL:
3261 #endif
3262 case WS_IP_MULTICAST_IF:
3263 case WS_IP_MULTICAST_LOOP:
3264 case WS_IP_MULTICAST_TTL:
3265 case WS_IP_OPTIONS:
3266 case WS_IP_TOS:
3267 case WS_IP_TTL:
3268 convert_sockopt(&level, &optname);
3269 break;
3270 case WS_IP_DONTFRAGMENT:
3271 FIXME("IP_DONTFRAGMENT is silently ignored!\n");
3272 return 0;
3273 default:
3274 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
3275 return SOCKET_ERROR;
3276 }
3277 break;
3278
3279 default:
3280 FIXME("Unknown level: 0x%08x\n", level);
3281 return SOCKET_ERROR;
3282 } /* end switch(level) */
3283
3284 /* avoid endianness issues if argument is a 16-bit int */
3285 if (optval && optlen < sizeof(int))
3286 {
3287 woptval= *((const INT16 *) optval);
3288 optval= (char*) &woptval;
3289 optlen=sizeof(int);
3290 }
3291 fd = get_sock_fd( s, 0, NULL );
3292 if (fd == -1) return SOCKET_ERROR;
3293
3294 if (setsockopt(fd, level, optname, optval, optlen) == 0)
3295 {
3296 release_sock_fd( s, fd );
3297 return 0;
3298 }
3299 TRACE("Setting socket error, %d\n", wsaErrno());
3300 SetLastError(wsaErrno());
3301 release_sock_fd( s, fd );
3302
3303 return SOCKET_ERROR;
3304 }
3305
3306 /***********************************************************************
3307 * shutdown (WS2_32.22)
3308 */
3309 int WINAPI WS_shutdown(SOCKET s, int how)
3310 {
3311 int fd, err = WSAENOTSOCK;
3312 unsigned int options, clear_flags = 0;
3313
3314 fd = get_sock_fd( s, 0, &options );
3315 TRACE("socket %04lx, how %i %x\n", s, how, options );
3316
3317 if (fd == -1)
3318 return SOCKET_ERROR;
3319
3320 switch( how )
3321 {
3322 case 0: /* drop receives */
3323 clear_flags |= FD_READ;
3324 break;
3325 case 1: /* drop sends */
3326 clear_flags |= FD_WRITE;
3327 break;
3328 case 2: /* drop all */
3329 clear_flags |= FD_READ|FD_WRITE;
3330 default:
3331 clear_flags |= FD_WINE_LISTENING;
3332 }
3333
3334 if (!(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT)))
3335 {
3336 switch ( how )
3337 {
3338 case SD_RECEIVE:
3339 err = WS2_register_async_shutdown( s, ASYNC_TYPE_READ );
3340 break;
3341 case SD_SEND:
3342 err = WS2_register_async_shutdown( s, ASYNC_TYPE_WRITE );
3343 break;
3344 case SD_BOTH:
3345 default:
3346 err = WS2_register_async_shutdown( s, ASYNC_TYPE_READ );
3347 if (!err) err = WS2_register_async_shutdown( s, ASYNC_TYPE_WRITE );
3348 break;
3349 }
3350 if (err) goto error;
3351 }
3352 else /* non-overlapped mode */
3353 {
3354 if ( shutdown( fd, how ) )
3355 {
3356 err = wsaErrno();
3357 goto error;
3358 }
3359 }
3360
3361 release_sock_fd( s, fd );
3362 _enable_event( SOCKET2HANDLE(s), 0, 0, clear_flags );
3363 if ( how > 1) WSAAsyncSelect( s, 0, 0, 0 );
3364 return 0;
3365
3366 error:
3367 release_sock_fd( s, fd );
3368 _enable_event( SOCKET2HANDLE(s), 0, 0, clear_flags );
3369 WSASetLastError( err );
3370 return SOCKET_ERROR;
3371 }
3372
3373 /***********************************************************************
3374 * socket (WS2_32.23)
3375 */
3376 SOCKET WINAPI WS_socket(int af, int type, int protocol)
3377 {
3378 TRACE("af=%d type=%d protocol=%d\n", af, type, protocol);
3379
3380 return WSASocketA( af, type, protocol, NULL, 0,
3381 get_per_thread_data()->opentype ? 0 : WSA_FLAG_OVERLAPPED );
3382 }
3383
3384
3385 /***********************************************************************
3386 * gethostbyaddr (WS2_32.51)
3387 */
3388 struct WS_hostent* WINAPI WS_gethostbyaddr(const char *addr, int len, int type)
3389 {
3390 struct WS_hostent *retval = NULL;
3391 struct hostent* host;
3392
3393 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3394 char *extrabuf;
3395 int ebufsize=1024;
3396 struct hostent hostentry;
3397 int locerr=ENOBUFS;
3398 host = NULL;
3399 extrabuf=HeapAlloc(GetProcessHeap(),0,ebufsize) ;
3400 while(extrabuf) {
3401 int res = gethostbyaddr_r(addr, len, type,
3402 &hostentry, extrabuf, ebufsize, &host, &locerr);
3403 if( res != ERANGE) break;
3404 ebufsize *=2;
3405 extrabuf=HeapReAlloc(GetProcessHeap(),0,extrabuf,ebufsize) ;
3406 }
3407 if (!host) SetLastError((locerr < 0) ? wsaErrno() : wsaHerrno(locerr));
3408 #else
3409 EnterCriticalSection( &csWSgetXXXbyYYY );
3410 host = gethostbyaddr(addr, len, type);
3411 if (!host) SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno(h_errno));
3412 #endif
3413 if( host != NULL ) retval = WS_dup_he(host);
3414 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3415 HeapFree(GetProcessHeap(),0,extrabuf);
3416 #else
3417 LeaveCriticalSection( &csWSgetXXXbyYYY );
3418 #endif
3419 TRACE("ptr %p, len %d, type %d ret %p\n", addr, len, type, retval);
3420 return retval;
3421 }
3422
3423 /***********************************************************************
3424 * gethostbyname (WS2_32.52)
3425 */
3426 struct WS_hostent* WINAPI WS_gethostbyname(const char* name)
3427 {
3428 struct WS_hostent *retval = NULL;
3429 struct hostent* host;
3430 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3431 char *extrabuf;
3432 int ebufsize=1024;
3433 struct hostent hostentry;
3434 int locerr = ENOBUFS;
3435 #endif
3436 char buf[100];
3437 if( !name || !name[0]) {
3438 name = buf;
3439 if( gethostname( buf, 100) == -1) {
3440 SetLastError( WSAENOBUFS); /* appropriate ? */
3441 return retval;
3442 }
3443 }
3444 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3445 host = NULL;
3446 extrabuf=HeapAlloc(GetProcessHeap(),0,ebufsize) ;
3447 while(extrabuf) {
3448 int res = gethostbyname_r(name, &hostentry, extrabuf, ebufsize, &host, &locerr);
3449 if( res != ERANGE) break;
3450 ebufsize *=2;
3451 extrabuf=HeapReAlloc(GetProcessHeap(),0,extrabuf,ebufsize) ;
3452 }
3453 if (!host) SetLastError((locerr < 0) ? wsaErrno() : wsaHerrno(locerr));
3454 #else
3455 EnterCriticalSection( &csWSgetXXXbyYYY );
3456 host = gethostbyname(name);
3457 if (!host) SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno(h_errno));
3458 #endif
3459 if (host) retval = WS_dup_he(host);
3460 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3461 HeapFree(GetProcessHeap(),0,extrabuf);
3462 #else
3463 LeaveCriticalSection( &csWSgetXXXbyYYY );
3464 #endif
3465 if (retval && retval->h_addr_list[0][0] == 127 &&
3466 strcmp(name, "localhost") != 0)
3467 {
3468 /* hostname != "localhost" but has loopback address. replace by our
3469 * special address.*/
3470 memcpy(retval->h_addr_list[0], magic_loopback_addr, 4);
3471 }
3472 TRACE( "%s ret %p\n", debugstr_a(name), retval );
3473 return retval;
3474 }
3475
3476
3477 /***********************************************************************
3478 * getprotobyname (WS2_32.53)
3479 */
3480 struct WS_protoent* WINAPI WS_getprotobyname(const char* name)
3481 {
3482 struct WS_protoent* retval = NULL;
3483 #ifdef HAVE_GETPROTOBYNAME
3484 struct protoent* proto;
3485 EnterCriticalSection( &csWSgetXXXbyYYY );
3486 if( (proto = getprotobyname(name)) != NULL )
3487 {
3488 retval = WS_dup_pe(proto);
3489 }
3490 else {
3491 MESSAGE("protocol %s not found; You might want to add "
3492 "this to /etc/protocols\n", debugstr_a(name) );
3493 SetLastError(WSANO_DATA);
3494 }
3495 LeaveCriticalSection( &csWSgetXXXbyYYY );
3496 #endif
3497 TRACE( "%s ret %p\n", debugstr_a(name), retval );
3498 return retval;
3499 }
3500
3501
3502 /***********************************************************************
3503 * getprotobynumber (WS2_32.54)
3504 */
3505 struct WS_protoent* WINAPI WS_getprotobynumber(int number)
3506 {
3507 struct WS_protoent* retval = NULL;
3508 #ifdef HAVE_GETPROTOBYNUMBER
3509 struct protoent* proto;
3510 EnterCriticalSection( &csWSgetXXXbyYYY );
3511 if( (proto = getprotobynumber(number)) != NULL )
3512 {
3513 retval = WS_dup_pe(proto);
3514 }
3515 else {
3516 MESSAGE("protocol number %d not found; You might want to add "
3517 "this to /etc/protocols\n", number );
3518 SetLastError(WSANO_DATA);
3519 }
3520 LeaveCriticalSection( &csWSgetXXXbyYYY );
3521 #endif
3522 TRACE("%i ret %p\n", number, retval);
3523 return retval;
3524 }
3525
3526
3527 /***********************************************************************
3528 * getservbyname (WS2_32.55)
3529 */
3530 struct WS_servent* WINAPI WS_getservbyname(const char *name, const char *proto)
3531 {
3532 struct WS_servent* retval = NULL;
3533 struct servent* serv;
3534 char *name_str;
3535 char *proto_str = NULL;
3536
3537 if (!(name_str = strdup_lower(name))) return NULL;
3538
3539 if (proto && *proto)
3540 {
3541 if (!(proto_str = strdup_lower(proto)))
3542 {
3543 HeapFree( GetProcessHeap(), 0, name_str );
3544 return NULL;
3545 }
3546 }
3547
3548 EnterCriticalSection( &csWSgetXXXbyYYY );
3549 serv = getservbyname(name_str, proto_str);
3550 if( serv != NULL )
3551 {
3552 retval = WS_dup_se(serv);
3553 }
3554 else SetLastError(WSANO_DATA);
3555 LeaveCriticalSection( &csWSgetXXXbyYYY );
3556 HeapFree( GetProcessHeap(), 0, proto_str );
3557 HeapFree( GetProcessHeap(), 0, name_str );
3558 TRACE( "%s, %s ret %p\n", debugstr_a(name), debugstr_a(proto), retval );
3559 return retval;
3560 }
3561
3562 /***********************************************************************
3563 * freeaddrinfo (WS2_32.@)
3564 */
3565 void WINAPI WS_freeaddrinfo(struct WS_addrinfo *res)
3566 {
3567 while (res) {
3568 struct WS_addrinfo *next;
3569
3570 HeapFree(GetProcessHeap(),0,res->ai_canonname);
3571 HeapFree(GetProcessHeap(),0,res->ai_addr);
3572 next = res->ai_next;
3573 HeapFree(GetProcessHeap(),0,res);
3574 res = next;
3575 }
3576 }
3577
3578 /* helper functions for getaddrinfo()/getnameinfo() */
3579 static int convert_aiflag_w2u(int winflags) {
3580 unsigned int i;
3581 int unixflags = 0;
3582
3583 for (i=0;i<sizeof(ws_aiflag_map)/sizeof(ws_aiflag_map[0]);i++)
3584 if (ws_aiflag_map[i][0] & winflags) {
3585 unixflags |= ws_aiflag_map[i][1];
3586 winflags &= ~ws_aiflag_map[i][0];
3587 }
3588 if (winflags)
3589 FIXME("Unhandled windows AI_xxx flags %x\n", winflags);
3590 return unixflags;
3591 }
3592
3593 static int convert_niflag_w2u(int winflags) {
3594 unsigned int i;
3595 int unixflags = 0;
3596
3597 for (i=0;i<sizeof(ws_niflag_map)/sizeof(ws_niflag_map[0]);i++)
3598 if (ws_niflag_map[i][0] & winflags) {
3599 unixflags |= ws_niflag_map[i][1];
3600 winflags &= ~ws_niflag_map[i][0];
3601 }
3602 if (winflags)
3603 FIXME("Unhandled windows NI_xxx flags %x\n", winflags);
3604 return unixflags;
3605 }
3606
3607 static int convert_aiflag_u2w(int unixflags) {
3608 unsigned int i;
3609 int winflags = 0;
3610
3611 for (i=0;i<sizeof(ws_aiflag_map)/sizeof(ws_aiflag_map[0]);i++)
3612 if (ws_aiflag_map[i][1] & unixflags) {
3613 winflags |= ws_aiflag_map[i][0];
3614 unixflags &= ~ws_aiflag_map[i][1];
3615 }
3616 if (unixflags) /* will warn usually */
3617 WARN("Unhandled UNIX AI_xxx flags %x\n", unixflags);
3618 return winflags;
3619 }
3620
3621 static int convert_eai_u2w(int unixret) {
3622 int i;
3623
3624 for (i=0;ws_eai_map[i][0];i++)
3625 if (ws_eai_map[i][1] == unixret)
3626 return ws_eai_map[i][0];
3627 return unixret;
3628 }
3629
3630 /***********************************************************************
3631 * getaddrinfo (WS2_32.@)
3632 */
3633 int WINAPI WS_getaddrinfo(LPCSTR nodename, LPCSTR servname, const struct WS_addrinfo *hints, struct WS_addrinfo