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